_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q182000
|
Through
|
test
|
func (pathSend PayWithPath) Through(asset Asset) PayWithPath {
pathSend.Path = append(pathSend.Path, asset)
return pathSend
}
|
go
|
{
"resource": ""
}
|
q182001
|
PayWith
|
test
|
func PayWith(sendAsset Asset, maxAmount string) PayWithPath {
return PayWithPath{
Asset: sendAsset,
MaxAmount: maxAmount,
}
}
|
go
|
{
"resource": ""
}
|
q182002
|
continuedFraction
|
test
|
func continuedFraction(price string) (xdrPrice xdr.Price, err error) {
number := &big.Rat{}
maxInt32 := &big.Rat{}
zero := &big.Rat{}
one := &big.Rat{}
_, ok := number.SetString(price)
if !ok {
return xdrPrice, fmt.Errorf("cannot parse price: %s", price)
}
maxInt32.SetInt64(int64(math.MaxInt32))
zero.SetInt64(int64(0))
one.SetInt64(int64(1))
fractions := [][2]*big.Rat{
{zero, one},
{one, zero},
}
i := 2
for {
if number.Cmp(maxInt32) == 1 {
break
}
f := &big.Rat{}
h := &big.Rat{}
k := &big.Rat{}
a := floor(number)
f.Sub(number, a)
h.Mul(a, fractions[i-1][0])
h.Add(h, fractions[i-2][0])
k.Mul(a, fractions[i-1][1])
k.Add(k, fractions[i-2][1])
if h.Cmp(maxInt32) == 1 || k.Cmp(maxInt32) == 1 {
break
}
fractions = append(fractions, [2]*big.Rat{h, k})
if f.Cmp(zero) == 0 {
break
}
number.Quo(one, f)
i++
}
n, d := fractions[len(fractions)-1][0], fractions[len(fractions)-1][1]
if n.Cmp(zero) == 0 || d.Cmp(zero) == 0 {
return xdrPrice, errors.New("Couldn't find approximation")
}
return xdr.Price{
N: xdr.Int32(n.Num().Int64()),
D: xdr.Int32(d.Num().Int64()),
}, nil
}
|
go
|
{
"resource": ""
}
|
q182003
|
Mutate
|
test
|
func (b *TransactionEnvelopeBuilder) Mutate(muts ...TransactionEnvelopeMutator) {
b.Init()
for _, m := range muts {
err := m.MutateTransactionEnvelope(b)
if err != nil {
b.Err = err
return
}
}
}
|
go
|
{
"resource": ""
}
|
q182004
|
MutateTX
|
test
|
func (b *TransactionEnvelopeBuilder) MutateTX(muts ...TransactionMutator) {
b.Init()
if b.Err != nil {
return
}
b.child.Mutate(muts...)
b.Err = b.child.Err
}
|
go
|
{
"resource": ""
}
|
q182005
|
Bytes
|
test
|
func (b *TransactionEnvelopeBuilder) Bytes() ([]byte, error) {
if b.Err != nil {
return nil, b.Err
}
var txBytes bytes.Buffer
_, err := xdr.Marshal(&txBytes, b.E)
if err != nil {
return nil, err
}
return txBytes.Bytes(), nil
}
|
go
|
{
"resource": ""
}
|
q182006
|
Base64
|
test
|
func (b *TransactionEnvelopeBuilder) Base64() (string, error) {
bs, err := b.Bytes()
return base64.StdEncoding.EncodeToString(bs), err
}
|
go
|
{
"resource": ""
}
|
q182007
|
MutateTransactionEnvelope
|
test
|
func (m *TransactionBuilder) MutateTransactionEnvelope(txe *TransactionEnvelopeBuilder) error {
if m.Err != nil {
return m.Err
}
txe.E.Tx = *m.TX
newChild := *m
txe.child = &newChild
m.TX = &txe.E.Tx
return nil
}
|
go
|
{
"resource": ""
}
|
q182008
|
MutateSetOptions
|
test
|
func (m HomeDomain) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
if len(m) > 32 {
return errors.New("HomeDomain is too long")
}
value := xdr.String32(m)
o.HomeDomain = &value
return
}
|
go
|
{
"resource": ""
}
|
q182009
|
MutateSetOptions
|
test
|
func (m InflationDest) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
o.InflationDest = &xdr.AccountId{}
err = setAccountId(string(m), o.InflationDest)
return
}
|
go
|
{
"resource": ""
}
|
q182010
|
MutateSetOptions
|
test
|
func (m MasterWeight) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
val := xdr.Uint32(m)
o.MasterWeight = &val
return
}
|
go
|
{
"resource": ""
}
|
q182011
|
MutateSetOptions
|
test
|
func (m Signer) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
var signer xdr.Signer
signer.Weight = xdr.Uint32(m.Weight)
err = setAccountId(m.PublicKey, &signer.PubKey)
o.Signer = &signer
return
}
|
go
|
{
"resource": ""
}
|
q182012
|
SetThresholds
|
test
|
func SetThresholds(low, medium, high uint32) Thresholds {
return Thresholds{
Low: &low,
Medium: &medium,
High: &high,
}
}
|
go
|
{
"resource": ""
}
|
q182013
|
MutateSetOptions
|
test
|
func (m Thresholds) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
if m.Low != nil {
val := xdr.Uint32(*m.Low)
o.LowThreshold = &val
}
if m.Medium != nil {
val := xdr.Uint32(*m.Medium)
o.MedThreshold = &val
}
if m.High != nil {
val := xdr.Uint32(*m.High)
o.HighThreshold = &val
}
return
}
|
go
|
{
"resource": ""
}
|
q182014
|
MutateSetOptions
|
test
|
func (m SetFlag) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
if !isFlagValid(xdr.AccountFlags(m)) {
return errors.New("Unknown flag in SetFlag mutator")
}
var val xdr.Uint32
if o.SetFlags == nil {
val = xdr.Uint32(m)
} else {
val = xdr.Uint32(m) | *o.SetFlags
}
o.SetFlags = &val
return
}
|
go
|
{
"resource": ""
}
|
q182015
|
MutateSetOptions
|
test
|
func (m ClearFlag) MutateSetOptions(o *xdr.SetOptionsOp) (err error) {
if !isFlagValid(xdr.AccountFlags(m)) {
return errors.New("Unknown flag in SetFlag mutator")
}
var val xdr.Uint32
if o.ClearFlags == nil {
val = xdr.Uint32(m)
} else {
val = xdr.Uint32(m) | *o.ClearFlags
}
o.ClearFlags = &val
return
}
|
go
|
{
"resource": ""
}
|
q182016
|
MutateCreateAccount
|
test
|
func (m Destination) MutateCreateAccount(o *xdr.CreateAccountOp) error {
return setAccountId(m.AddressOrSeed, &o.Destination)
}
|
go
|
{
"resource": ""
}
|
q182017
|
MutateCreateAccount
|
test
|
func (m NativeAmount) MutateCreateAccount(o *xdr.CreateAccountOp) (err error) {
o.StartingBalance, err = amount.Parse(m.Amount)
return
}
|
go
|
{
"resource": ""
}
|
q182018
|
Random
|
test
|
func Random() (*Full, error) {
var rawSeed [32]byte
_, err := io.ReadFull(rand.Reader, rawSeed[:])
if err != nil {
return nil, err
}
kp, err := FromRawSeed(rawSeed)
if err != nil {
return nil, err
}
return kp, nil
}
|
go
|
{
"resource": ""
}
|
q182019
|
Master
|
test
|
func Master(networkPassphrase string) KP {
kp, err := FromRawSeed(network.ID(networkPassphrase))
if err != nil {
panic(err)
}
return kp
}
|
go
|
{
"resource": ""
}
|
q182020
|
Parse
|
test
|
func Parse(addressOrSeed string) (KP, error) {
_, err := strkey.Decode(strkey.VersionByteAccountID, addressOrSeed)
if err == nil {
return &FromAddress{addressOrSeed}, nil
}
if err != strkey.ErrInvalidVersionByte {
return nil, err
}
_, err = strkey.Decode(strkey.VersionByteSeed, addressOrSeed)
if err == nil {
return &Full{addressOrSeed}, nil
}
return nil, err
}
|
go
|
{
"resource": ""
}
|
q182021
|
MustParse
|
test
|
func MustParse(addressOrSeed string) KP {
kp, err := Parse(addressOrSeed)
if err != nil {
panic(err)
}
return kp
}
|
go
|
{
"resource": ""
}
|
q182022
|
MutateAllowTrust
|
test
|
func (m Authorize) MutateAllowTrust(o *xdr.AllowTrustOp) error {
o.Authorize = m.Value
return nil
}
|
go
|
{
"resource": ""
}
|
q182023
|
MutateAllowTrust
|
test
|
func (m AllowTrustAsset) MutateAllowTrust(o *xdr.AllowTrustOp) (err error) {
length := len(m.Code)
switch {
case length >= 1 && length <= 4:
var code [4]byte
byteArray := []byte(m.Code)
copy(code[:], byteArray[0:length])
o.Asset, err = xdr.NewAllowTrustOpAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, code)
case length >= 5 && length <= 12:
var code [12]byte
byteArray := []byte(m.Code)
copy(code[:], byteArray[0:length])
o.Asset, err = xdr.NewAllowTrustOpAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, code)
default:
err = errors.New("Asset code length is invalid")
}
return
}
|
go
|
{
"resource": ""
}
|
q182024
|
MutateAllowTrust
|
test
|
func (m Trustor) MutateAllowTrust(o *xdr.AllowTrustOp) error {
return setAccountId(m.Address, &o.Trustor)
}
|
go
|
{
"resource": ""
}
|
q182025
|
ToAsset
|
test
|
func (a AllowTrustOpAsset) ToAsset(issuer AccountId) (ret Asset) {
var err error
switch a.Type {
case AssetTypeAssetTypeCreditAlphanum4:
ret, err = NewAsset(AssetTypeAssetTypeCreditAlphanum4, AssetAlphaNum4{
AssetCode: a.MustAssetCode4(),
Issuer: issuer,
})
case AssetTypeAssetTypeCreditAlphanum12:
ret, err = NewAsset(AssetTypeAssetTypeCreditAlphanum12, AssetAlphaNum12{
AssetCode: a.MustAssetCode12(),
Issuer: issuer,
})
default:
err = fmt.Errorf("Unexpected type for AllowTrustOpAsset: %d", a.Type)
}
if err != nil {
panic(err)
}
return
}
|
go
|
{
"resource": ""
}
|
q182026
|
SetNative
|
test
|
func (a *Asset) SetNative() error {
newa, err := NewAsset(AssetTypeAssetTypeNative, nil)
if err != nil {
return err
}
*a = newa
return nil
}
|
go
|
{
"resource": ""
}
|
q182027
|
String
|
test
|
func (a Asset) String() string {
var t, c, i string
a.MustExtract(&t, &c, &i)
if a.Type == AssetTypeAssetTypeNative {
return t
}
return fmt.Sprintf("%s/%s/%s", t, c, i)
}
|
go
|
{
"resource": ""
}
|
q182028
|
Equals
|
test
|
func (a Asset) Equals(other Asset) bool {
if a.Type != other.Type {
return false
}
switch a.Type {
case AssetTypeAssetTypeNative:
return true
case AssetTypeAssetTypeCreditAlphanum4:
l := a.MustAlphaNum4()
r := other.MustAlphaNum4()
return l.AssetCode == r.AssetCode && l.Issuer.Equals(r.Issuer)
case AssetTypeAssetTypeCreditAlphanum12:
l := a.MustAlphaNum12()
r := other.MustAlphaNum12()
return l.AssetCode == r.AssetCode && l.Issuer.Equals(r.Issuer)
default:
panic(fmt.Errorf("Unknown asset type: %v", a.Type))
}
}
|
go
|
{
"resource": ""
}
|
q182029
|
MustExtract
|
test
|
func (a Asset) MustExtract(typ interface{}, code interface{}, issuer interface{}) {
err := a.Extract(typ, code, issuer)
if err != nil {
panic(err)
}
}
|
go
|
{
"resource": ""
}
|
q182030
|
Unmarshal
|
test
|
func Unmarshal(r io.Reader, v interface{}) (int, error) {
// delegate to xdr package's Unmarshal
return xdr.Unmarshal(r, v)
}
|
go
|
{
"resource": ""
}
|
q182031
|
Marshal
|
test
|
func Marshal(w io.Writer, v interface{}) (int, error) {
// delegate to xdr package's Marshal
return xdr.Marshal(w, v)
}
|
go
|
{
"resource": ""
}
|
q182032
|
ValidEnum
|
test
|
func (e CryptoKeyType) ValidEnum(v int32) bool {
_, ok := cryptoKeyTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182033
|
NewPublicKey
|
test
|
func NewPublicKey(aType CryptoKeyType, value interface{}) (result PublicKey, err error) {
result.Type = aType
switch CryptoKeyType(aType) {
case CryptoKeyTypeKeyTypeEd25519:
tv, ok := value.(Uint256)
if !ok {
err = fmt.Errorf("invalid value, must be Uint256")
return
}
result.Ed25519 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182034
|
MustEd25519
|
test
|
func (u PublicKey) MustEd25519() Uint256 {
val, ok := u.GetEd25519()
if !ok {
panic("arm Ed25519 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182035
|
NewNodeId
|
test
|
func NewNodeId(aType CryptoKeyType, value interface{}) (result NodeId, err error) {
u, err := NewPublicKey(aType, value)
result = NodeId(u)
return
}
|
go
|
{
"resource": ""
}
|
q182036
|
NewAccountId
|
test
|
func NewAccountId(aType CryptoKeyType, value interface{}) (result AccountId, err error) {
u, err := NewPublicKey(aType, value)
result = AccountId(u)
return
}
|
go
|
{
"resource": ""
}
|
q182037
|
ValidEnum
|
test
|
func (e AssetType) ValidEnum(v int32) bool {
_, ok := assetTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182038
|
ArmForSwitch
|
test
|
func (u Asset) ArmForSwitch(sw int32) (string, bool) {
switch AssetType(sw) {
case AssetTypeAssetTypeNative:
return "", true
case AssetTypeAssetTypeCreditAlphanum4:
return "AlphaNum4", true
case AssetTypeAssetTypeCreditAlphanum12:
return "AlphaNum12", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182039
|
NewAsset
|
test
|
func NewAsset(aType AssetType, value interface{}) (result Asset, err error) {
result.Type = aType
switch AssetType(aType) {
case AssetTypeAssetTypeNative:
// void
case AssetTypeAssetTypeCreditAlphanum4:
tv, ok := value.(AssetAlphaNum4)
if !ok {
err = fmt.Errorf("invalid value, must be AssetAlphaNum4")
return
}
result.AlphaNum4 = &tv
case AssetTypeAssetTypeCreditAlphanum12:
tv, ok := value.(AssetAlphaNum12)
if !ok {
err = fmt.Errorf("invalid value, must be AssetAlphaNum12")
return
}
result.AlphaNum12 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182040
|
MustAlphaNum4
|
test
|
func (u Asset) MustAlphaNum4() AssetAlphaNum4 {
val, ok := u.GetAlphaNum4()
if !ok {
panic("arm AlphaNum4 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182041
|
GetAlphaNum4
|
test
|
func (u Asset) GetAlphaNum4() (result AssetAlphaNum4, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AlphaNum4" {
result = *u.AlphaNum4
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182042
|
MustAlphaNum12
|
test
|
func (u Asset) MustAlphaNum12() AssetAlphaNum12 {
val, ok := u.GetAlphaNum12()
if !ok {
panic("arm AlphaNum12 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182043
|
GetAlphaNum12
|
test
|
func (u Asset) GetAlphaNum12() (result AssetAlphaNum12, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AlphaNum12" {
result = *u.AlphaNum12
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182044
|
ValidEnum
|
test
|
func (e ThresholdIndexes) ValidEnum(v int32) bool {
_, ok := thresholdIndexesMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182045
|
ValidEnum
|
test
|
func (e LedgerEntryType) ValidEnum(v int32) bool {
_, ok := ledgerEntryTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182046
|
ValidEnum
|
test
|
func (e AccountFlags) ValidEnum(v int32) bool {
_, ok := accountFlagsMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182047
|
NewAccountEntryExt
|
test
|
func NewAccountEntryExt(v int32, value interface{}) (result AccountEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182048
|
ValidEnum
|
test
|
func (e TrustLineFlags) ValidEnum(v int32) bool {
_, ok := trustLineFlagsMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182049
|
NewTrustLineEntryExt
|
test
|
func NewTrustLineEntryExt(v int32, value interface{}) (result TrustLineEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182050
|
ValidEnum
|
test
|
func (e OfferEntryFlags) ValidEnum(v int32) bool {
_, ok := offerEntryFlagsMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182051
|
NewOfferEntryExt
|
test
|
func NewOfferEntryExt(v int32, value interface{}) (result OfferEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182052
|
NewDataEntryExt
|
test
|
func NewDataEntryExt(v int32, value interface{}) (result DataEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182053
|
NewLedgerEntryData
|
test
|
func NewLedgerEntryData(aType LedgerEntryType, value interface{}) (result LedgerEntryData, err error) {
result.Type = aType
switch LedgerEntryType(aType) {
case LedgerEntryTypeAccount:
tv, ok := value.(AccountEntry)
if !ok {
err = fmt.Errorf("invalid value, must be AccountEntry")
return
}
result.Account = &tv
case LedgerEntryTypeTrustline:
tv, ok := value.(TrustLineEntry)
if !ok {
err = fmt.Errorf("invalid value, must be TrustLineEntry")
return
}
result.TrustLine = &tv
case LedgerEntryTypeOffer:
tv, ok := value.(OfferEntry)
if !ok {
err = fmt.Errorf("invalid value, must be OfferEntry")
return
}
result.Offer = &tv
case LedgerEntryTypeData:
tv, ok := value.(DataEntry)
if !ok {
err = fmt.Errorf("invalid value, must be DataEntry")
return
}
result.Data = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182054
|
NewLedgerEntryExt
|
test
|
func NewLedgerEntryExt(v int32, value interface{}) (result LedgerEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182055
|
ValidEnum
|
test
|
func (e EnvelopeType) ValidEnum(v int32) bool {
_, ok := envelopeTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182056
|
ValidEnum
|
test
|
func (e OperationType) ValidEnum(v int32) bool {
_, ok := operationTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182057
|
ArmForSwitch
|
test
|
func (u AllowTrustOpAsset) ArmForSwitch(sw int32) (string, bool) {
switch AssetType(sw) {
case AssetTypeAssetTypeCreditAlphanum4:
return "AssetCode4", true
case AssetTypeAssetTypeCreditAlphanum12:
return "AssetCode12", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182058
|
NewAllowTrustOpAsset
|
test
|
func NewAllowTrustOpAsset(aType AssetType, value interface{}) (result AllowTrustOpAsset, err error) {
result.Type = aType
switch AssetType(aType) {
case AssetTypeAssetTypeCreditAlphanum4:
tv, ok := value.([4]byte)
if !ok {
err = fmt.Errorf("invalid value, must be [4]byte")
return
}
result.AssetCode4 = &tv
case AssetTypeAssetTypeCreditAlphanum12:
tv, ok := value.([12]byte)
if !ok {
err = fmt.Errorf("invalid value, must be [12]byte")
return
}
result.AssetCode12 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182059
|
MustAssetCode4
|
test
|
func (u AllowTrustOpAsset) MustAssetCode4() [4]byte {
val, ok := u.GetAssetCode4()
if !ok {
panic("arm AssetCode4 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182060
|
GetAssetCode4
|
test
|
func (u AllowTrustOpAsset) GetAssetCode4() (result [4]byte, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AssetCode4" {
result = *u.AssetCode4
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182061
|
MustAssetCode12
|
test
|
func (u AllowTrustOpAsset) MustAssetCode12() [12]byte {
val, ok := u.GetAssetCode12()
if !ok {
panic("arm AssetCode12 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182062
|
GetAssetCode12
|
test
|
func (u AllowTrustOpAsset) GetAssetCode12() (result [12]byte, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AssetCode12" {
result = *u.AssetCode12
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182063
|
NewOperationBody
|
test
|
func NewOperationBody(aType OperationType, value interface{}) (result OperationBody, err error) {
result.Type = aType
switch OperationType(aType) {
case OperationTypeCreateAccount:
tv, ok := value.(CreateAccountOp)
if !ok {
err = fmt.Errorf("invalid value, must be CreateAccountOp")
return
}
result.CreateAccountOp = &tv
case OperationTypePayment:
tv, ok := value.(PaymentOp)
if !ok {
err = fmt.Errorf("invalid value, must be PaymentOp")
return
}
result.PaymentOp = &tv
case OperationTypePathPayment:
tv, ok := value.(PathPaymentOp)
if !ok {
err = fmt.Errorf("invalid value, must be PathPaymentOp")
return
}
result.PathPaymentOp = &tv
case OperationTypeManageOffer:
tv, ok := value.(ManageOfferOp)
if !ok {
err = fmt.Errorf("invalid value, must be ManageOfferOp")
return
}
result.ManageOfferOp = &tv
case OperationTypeCreatePassiveOffer:
tv, ok := value.(CreatePassiveOfferOp)
if !ok {
err = fmt.Errorf("invalid value, must be CreatePassiveOfferOp")
return
}
result.CreatePassiveOfferOp = &tv
case OperationTypeSetOptions:
tv, ok := value.(SetOptionsOp)
if !ok {
err = fmt.Errorf("invalid value, must be SetOptionsOp")
return
}
result.SetOptionsOp = &tv
case OperationTypeChangeTrust:
tv, ok := value.(ChangeTrustOp)
if !ok {
err = fmt.Errorf("invalid value, must be ChangeTrustOp")
return
}
result.ChangeTrustOp = &tv
case OperationTypeAllowTrust:
tv, ok := value.(AllowTrustOp)
if !ok {
err = fmt.Errorf("invalid value, must be AllowTrustOp")
return
}
result.AllowTrustOp = &tv
case OperationTypeAccountMerge:
tv, ok := value.(AccountId)
if !ok {
err = fmt.Errorf("invalid value, must be AccountId")
return
}
result.Destination = &tv
case OperationTypeInflation:
// void
case OperationTypeManageData:
tv, ok := value.(ManageDataOp)
if !ok {
err = fmt.Errorf("invalid value, must be ManageDataOp")
return
}
result.ManageDataOp = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182064
|
MustCreateAccountOp
|
test
|
func (u OperationBody) MustCreateAccountOp() CreateAccountOp {
val, ok := u.GetCreateAccountOp()
if !ok {
panic("arm CreateAccountOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182065
|
GetCreateAccountOp
|
test
|
func (u OperationBody) GetCreateAccountOp() (result CreateAccountOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "CreateAccountOp" {
result = *u.CreateAccountOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182066
|
MustPaymentOp
|
test
|
func (u OperationBody) MustPaymentOp() PaymentOp {
val, ok := u.GetPaymentOp()
if !ok {
panic("arm PaymentOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182067
|
GetPaymentOp
|
test
|
func (u OperationBody) GetPaymentOp() (result PaymentOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "PaymentOp" {
result = *u.PaymentOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182068
|
MustPathPaymentOp
|
test
|
func (u OperationBody) MustPathPaymentOp() PathPaymentOp {
val, ok := u.GetPathPaymentOp()
if !ok {
panic("arm PathPaymentOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182069
|
GetPathPaymentOp
|
test
|
func (u OperationBody) GetPathPaymentOp() (result PathPaymentOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "PathPaymentOp" {
result = *u.PathPaymentOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182070
|
MustManageOfferOp
|
test
|
func (u OperationBody) MustManageOfferOp() ManageOfferOp {
val, ok := u.GetManageOfferOp()
if !ok {
panic("arm ManageOfferOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182071
|
GetManageOfferOp
|
test
|
func (u OperationBody) GetManageOfferOp() (result ManageOfferOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageOfferOp" {
result = *u.ManageOfferOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182072
|
MustCreatePassiveOfferOp
|
test
|
func (u OperationBody) MustCreatePassiveOfferOp() CreatePassiveOfferOp {
val, ok := u.GetCreatePassiveOfferOp()
if !ok {
panic("arm CreatePassiveOfferOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182073
|
GetCreatePassiveOfferOp
|
test
|
func (u OperationBody) GetCreatePassiveOfferOp() (result CreatePassiveOfferOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "CreatePassiveOfferOp" {
result = *u.CreatePassiveOfferOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182074
|
MustSetOptionsOp
|
test
|
func (u OperationBody) MustSetOptionsOp() SetOptionsOp {
val, ok := u.GetSetOptionsOp()
if !ok {
panic("arm SetOptionsOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182075
|
GetSetOptionsOp
|
test
|
func (u OperationBody) GetSetOptionsOp() (result SetOptionsOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "SetOptionsOp" {
result = *u.SetOptionsOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182076
|
MustChangeTrustOp
|
test
|
func (u OperationBody) MustChangeTrustOp() ChangeTrustOp {
val, ok := u.GetChangeTrustOp()
if !ok {
panic("arm ChangeTrustOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182077
|
GetChangeTrustOp
|
test
|
func (u OperationBody) GetChangeTrustOp() (result ChangeTrustOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ChangeTrustOp" {
result = *u.ChangeTrustOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182078
|
MustAllowTrustOp
|
test
|
func (u OperationBody) MustAllowTrustOp() AllowTrustOp {
val, ok := u.GetAllowTrustOp()
if !ok {
panic("arm AllowTrustOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182079
|
GetAllowTrustOp
|
test
|
func (u OperationBody) GetAllowTrustOp() (result AllowTrustOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AllowTrustOp" {
result = *u.AllowTrustOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182080
|
MustDestination
|
test
|
func (u OperationBody) MustDestination() AccountId {
val, ok := u.GetDestination()
if !ok {
panic("arm Destination is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182081
|
GetDestination
|
test
|
func (u OperationBody) GetDestination() (result AccountId, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Destination" {
result = *u.Destination
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182082
|
MustManageDataOp
|
test
|
func (u OperationBody) MustManageDataOp() ManageDataOp {
val, ok := u.GetManageDataOp()
if !ok {
panic("arm ManageDataOp is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182083
|
GetManageDataOp
|
test
|
func (u OperationBody) GetManageDataOp() (result ManageDataOp, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageDataOp" {
result = *u.ManageDataOp
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182084
|
ValidEnum
|
test
|
func (e MemoType) ValidEnum(v int32) bool {
_, ok := memoTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182085
|
ArmForSwitch
|
test
|
func (u Memo) ArmForSwitch(sw int32) (string, bool) {
switch MemoType(sw) {
case MemoTypeMemoNone:
return "", true
case MemoTypeMemoText:
return "Text", true
case MemoTypeMemoId:
return "Id", true
case MemoTypeMemoHash:
return "Hash", true
case MemoTypeMemoReturn:
return "RetHash", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182086
|
NewMemo
|
test
|
func NewMemo(aType MemoType, value interface{}) (result Memo, err error) {
result.Type = aType
switch MemoType(aType) {
case MemoTypeMemoNone:
// void
case MemoTypeMemoText:
tv, ok := value.(string)
if !ok {
err = fmt.Errorf("invalid value, must be string")
return
}
result.Text = &tv
case MemoTypeMemoId:
tv, ok := value.(Uint64)
if !ok {
err = fmt.Errorf("invalid value, must be Uint64")
return
}
result.Id = &tv
case MemoTypeMemoHash:
tv, ok := value.(Hash)
if !ok {
err = fmt.Errorf("invalid value, must be Hash")
return
}
result.Hash = &tv
case MemoTypeMemoReturn:
tv, ok := value.(Hash)
if !ok {
err = fmt.Errorf("invalid value, must be Hash")
return
}
result.RetHash = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182087
|
MustText
|
test
|
func (u Memo) MustText() string {
val, ok := u.GetText()
if !ok {
panic("arm Text is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182088
|
GetText
|
test
|
func (u Memo) GetText() (result string, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Text" {
result = *u.Text
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182089
|
MustId
|
test
|
func (u Memo) MustId() Uint64 {
val, ok := u.GetId()
if !ok {
panic("arm Id is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182090
|
GetId
|
test
|
func (u Memo) GetId() (result Uint64, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Id" {
result = *u.Id
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182091
|
MustHash
|
test
|
func (u Memo) MustHash() Hash {
val, ok := u.GetHash()
if !ok {
panic("arm Hash is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182092
|
GetHash
|
test
|
func (u Memo) GetHash() (result Hash, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Hash" {
result = *u.Hash
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182093
|
MustRetHash
|
test
|
func (u Memo) MustRetHash() Hash {
val, ok := u.GetRetHash()
if !ok {
panic("arm RetHash is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182094
|
NewTransactionExt
|
test
|
func NewTransactionExt(v int32, value interface{}) (result TransactionExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182095
|
ValidEnum
|
test
|
func (e CreateAccountResultCode) ValidEnum(v int32) bool {
_, ok := createAccountResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182096
|
ArmForSwitch
|
test
|
func (u CreateAccountResult) ArmForSwitch(sw int32) (string, bool) {
switch CreateAccountResultCode(sw) {
case CreateAccountResultCodeCreateAccountSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182097
|
NewCreateAccountResult
|
test
|
func NewCreateAccountResult(code CreateAccountResultCode, value interface{}) (result CreateAccountResult, err error) {
result.Code = code
switch CreateAccountResultCode(code) {
case CreateAccountResultCodeCreateAccountSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182098
|
ValidEnum
|
test
|
func (e PaymentResultCode) ValidEnum(v int32) bool {
_, ok := paymentResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182099
|
ArmForSwitch
|
test
|
func (u PaymentResult) ArmForSwitch(sw int32) (string, bool) {
switch PaymentResultCode(sw) {
case PaymentResultCodePaymentSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.