id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c182000 | append(pathSend.Path, asset)
return pathSend
} | |
c182001 | sendAsset,
MaxAmount: maxAmount,
}
} | |
c182002 | 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
} | |
c182003 |
err := m.MutateTransactionEnvelope(b)
if err != nil {
b.Err = err
return
}
}
} | |
c182004 | {
return
}
b.child.Mutate(muts...)
b.Err = b.child.Err
} | |
c182005 | _, err := xdr.Marshal(&txBytes, b.E)
if err != nil {
return nil, err
}
return txBytes.Bytes(), nil
} | |
c182006 | {
bs, err := b.Bytes()
return base64.StdEncoding.EncodeToString(bs), err
} | |
c182007 |
newChild := *m
txe.child = &newChild
m.TX = &txe.E.Tx
return nil
} | |
c182008 | long")
}
value := xdr.String32(m)
o.HomeDomain = &value
return
} | |
c182009 | {
o.InflationDest = &xdr.AccountId{}
err = setAccountId(string(m), o.InflationDest)
return
} | |
c182010 | val := xdr.Uint32(m)
o.MasterWeight = &val
return
} | |
c182011 |
signer.Weight = xdr.Uint32(m.Weight)
err = setAccountId(m.PublicKey, &signer.PubKey)
o.Signer = &signer
return
} | |
c182012 | &low,
Medium: &medium,
High: &high,
}
} | |
c182013 | o.MedThreshold = &val
}
if m.High != nil {
val := xdr.Uint32(*m.High)
o.HighThreshold = &val
}
return
} | |
c182014 | val = xdr.Uint32(m)
} else {
val = xdr.Uint32(m) | *o.SetFlags
}
o.SetFlags = &val
return
} | |
c182015 | val = xdr.Uint32(m)
} else {
val = xdr.Uint32(m) | *o.ClearFlags
}
o.ClearFlags = &val
return
} | |
c182016 | setAccountId(m.AddressOrSeed, &o.Destination)
} | |
c182017 | o.StartingBalance, err = amount.Parse(m.Amount)
return
} | |
c182018 | FromRawSeed(rawSeed)
if err != nil {
return nil, err
}
return kp, nil
} | |
c182019 | if err != nil {
panic(err)
}
return kp
} | |
c182020 |
_, err = strkey.Decode(strkey.VersionByteSeed, addressOrSeed)
if err == nil {
return &Full{addressOrSeed}, nil
}
return nil, err
} | |
c182021 | err != nil {
panic(err)
}
return kp
} | |
c182022 | error {
o.Authorize = m.Value
return nil
} | |
c182023 |
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
} | |
c182024 | setAccountId(m.Address, &o.Trustor)
} | |
c182025 | = 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
} | |
c182026 | != nil {
return err
}
*a = newa
return nil
} | |
c182027 |
return t
}
return fmt.Sprintf("%s/%s/%s", t, c, i)
} | |
c182028 | := 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))
}
} | |
c182029 | := a.Extract(typ, code, issuer)
if err != nil {
panic(err)
}
} | |
c182030 | {
// delegate to xdr package's Unmarshal
return xdr.Unmarshal(r, v)
} | |
c182031 | to xdr package's Marshal
return xdr.Marshal(w, v)
} | |
c182032 | ok := cryptoKeyTypeMap[v]
return ok
} | |
c182033 | err = fmt.Errorf("invalid value, must be Uint256")
return
}
result.Ed25519 = &tv
}
return
} | |
c182034 | u.GetEd25519()
if !ok {
panic("arm Ed25519 is not set")
}
return val
} | |
c182035 | NodeId, err error) {
u, err := NewPublicKey(aType, value)
result = NodeId(u)
return
} | |
c182036 | AccountId, err error) {
u, err := NewPublicKey(aType, value)
result = AccountId(u)
return
} | |
c182037 | ok := assetTypeMap[v]
return ok
} | |
c182038 | true
case AssetTypeAssetTypeCreditAlphanum12:
return "AlphaNum12", true
}
return "-", false
} | |
c182039 | 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
} | |
c182040 | panic("arm AlphaNum4 is not set")
}
return val
} | |
c182041 | := u.ArmForSwitch(int32(u.Type))
if armName == "AlphaNum4" {
result = *u.AlphaNum4
ok = true
}
return
} | |
c182042 | panic("arm AlphaNum12 is not set")
}
return val
} | |
c182043 | := u.ArmForSwitch(int32(u.Type))
if armName == "AlphaNum12" {
result = *u.AlphaNum12
ok = true
}
return
} | |
c182044 | ok := thresholdIndexesMap[v]
return ok
} | |
c182045 | ok := ledgerEntryTypeMap[v]
return ok
} | |
c182046 | ok := accountFlagsMap[v]
return ok
} | |
c182047 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182048 | ok := trustLineFlagsMap[v]
return ok
} | |
c182049 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182050 | ok := offerEntryFlagsMap[v]
return ok
} | |
c182051 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182052 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182053 |
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
} | |
c182054 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182055 | ok := envelopeTypeMap[v]
return ok
} | |
c182056 | ok := operationTypeMap[v]
return ok
} | |
c182057 |
return "AssetCode4", true
case AssetTypeAssetTypeCreditAlphanum12:
return "AssetCode12", true
}
return "-", false
} | |
c182058 | 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
} | |
c182059 | panic("arm AssetCode4 is not set")
}
return val
} | |
c182060 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "AssetCode4" {
result = *u.AssetCode4
ok = true
}
return
} | |
c182061 | panic("arm AssetCode12 is not set")
}
return val
} | |
c182062 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "AssetCode12" {
result = *u.AssetCode12
ok = true
}
return
} | |
c182063 |
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
} | |
c182064 | panic("arm CreateAccountOp is not set")
}
return val
} | |
c182065 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "CreateAccountOp" {
result = *u.CreateAccountOp
ok = true
}
return
} | |
c182066 | panic("arm PaymentOp is not set")
}
return val
} | |
c182067 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "PaymentOp" {
result = *u.PaymentOp
ok = true
}
return
} | |
c182068 | panic("arm PathPaymentOp is not set")
}
return val
} | |
c182069 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "PathPaymentOp" {
result = *u.PathPaymentOp
ok = true
}
return
} | |
c182070 | panic("arm ManageOfferOp is not set")
}
return val
} | |
c182071 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageOfferOp" {
result = *u.ManageOfferOp
ok = true
}
return
} | |
c182072 | panic("arm CreatePassiveOfferOp is not set")
}
return val
} | |
c182073 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "CreatePassiveOfferOp" {
result = *u.CreatePassiveOfferOp
ok = true
}
return
} | |
c182074 | panic("arm SetOptionsOp is not set")
}
return val
} | |
c182075 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "SetOptionsOp" {
result = *u.SetOptionsOp
ok = true
}
return
} | |
c182076 | panic("arm ChangeTrustOp is not set")
}
return val
} | |
c182077 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "ChangeTrustOp" {
result = *u.ChangeTrustOp
ok = true
}
return
} | |
c182078 | panic("arm AllowTrustOp is not set")
}
return val
} | |
c182079 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "AllowTrustOp" {
result = *u.AllowTrustOp
ok = true
}
return
} | |
c182080 | panic("arm Destination is not set")
}
return val
} | |
c182081 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "Destination" {
result = *u.Destination
ok = true
}
return
} | |
c182082 | panic("arm ManageDataOp is not set")
}
return val
} | |
c182083 | _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageDataOp" {
result = *u.ManageDataOp
ok = true
}
return
} | |
c182084 | ok := memoTypeMap[v]
return ok
} | |
c182085 | return "Text", true
case MemoTypeMemoId:
return "Id", true
case MemoTypeMemoHash:
return "Hash", true
case MemoTypeMemoReturn:
return "RetHash", true
}
return "-", false
} | |
c182086 |
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
} | |
c182087 |
if !ok {
panic("arm Text is not set")
}
return val
} | |
c182088 | == "Text" {
result = *u.Text
ok = true
}
return
} | |
c182089 |
if !ok {
panic("arm Id is not set")
}
return val
} | |
c182090 | armName == "Id" {
result = *u.Id
ok = true
}
return
} | |
c182091 |
if !ok {
panic("arm Hash is not set")
}
return val
} | |
c182092 | == "Hash" {
result = *u.Hash
ok = true
}
return
} | |
c182093 |
if !ok {
panic("arm RetHash is not set")
}
return val
} | |
c182094 | err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
} | |
c182095 | int32) bool {
_, ok := createAccountResultCodeMap[v]
return ok
} | |
c182096 | {
case CreateAccountResultCodeCreateAccountSuccess:
return "", true
default:
return "", true
}
} | |
c182097 | {
case CreateAccountResultCodeCreateAccountSuccess:
// void
default:
// void
}
return
} | |
c182098 | ok := paymentResultCodeMap[v]
return ok
} | |
c182099 | {
case PaymentResultCodePaymentSuccess:
return "", true
default:
return "", true
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.