// ToXdrObject creates xdr.Asset object from build.Asset object
func (a Asset) ToXdrObject() (xdr.Asset, error) {
if a.Native {
return xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
}
var issuer xdr.AccountId
err := setAccountId(a.Issuer, &issuer)
if err != nil {
return xdr.Asset{}, err
}
length := len(a.Code)
switch {
case length >= 1 && length <= 4:
var codeArray [4]byte
byteArray := []byte(a.Code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum4{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, asset)
case length >= 5 && length <= 12:
var codeArray [12]byte
byteArray := []byte(a.Code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum12{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, asset)
default:
return xdr.Asset{}, errors.New("Asset code length is invalid")
}
}
// MutatePayment for Asset sets the PaymentOp's Asset field
func (m CreditAmount) MutatePayment(o *xdr.PaymentOp) (err error) {
o.Amount, err = amount.Parse(m.Amount)
if err != nil {
return
}
length := len(m.Code)
var issuer xdr.AccountId
err = setAccountId(m.Issuer, &issuer)
if err != nil {
return
}
switch {
case length >= 1 && length <= 4:
var code [4]byte
byteArray := []byte(m.Code)
copy(code[:], byteArray[0:length])
asset := xdr.AssetAlphaNum4{code, issuer}
o.Asset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, asset)
case length >= 5 && length <= 12:
var code [12]byte
byteArray := []byte(m.Code)
copy(code[:], byteArray[0:length])
asset := xdr.AssetAlphaNum12{code, issuer}
o.Asset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, asset)
default:
err = errors.New("Asset code length is invalid")
}
return
}
func createAlphaNumAsset(code, issuerAccountId string) (xdr.Asset, error) {
var issuer xdr.AccountId
err := setAccountId(issuerAccountId, &issuer)
if err != nil {
return xdr.Asset{}, err
}
length := len(code)
switch {
case length >= 1 && length <= 4:
var codeArray [4]byte
byteArray := []byte(code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum4{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, asset)
case length >= 5 && length <= 12:
var codeArray [12]byte
byteArray := []byte(code)
copy(codeArray[:], byteArray[0:length])
asset := xdr.AssetAlphaNum12{codeArray, issuer}
return xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, asset)
default:
return xdr.Asset{}, errors.New("Asset code length is invalid")
}
}
func (q AssetsForAddressQuery) Select(ctx context.Context, dest interface{}) error {
var tls []CoreTrustlineRecord
tlq := CoreTrustlinesByAddressQuery{q.SqlQuery, q.Address}
err := Select(ctx, tlq, &tls)
if err != nil {
return err
}
dtl, ok := dest.(*[]xdr.Asset)
if !ok {
return errors.New("Invalid destination")
}
result := make([]xdr.Asset, len(tls)+1)
*dtl = result
for i, tl := range tls {
result[i], err = assetFromDB(tl.Assettype, tl.Assetcode, tl.Issuer)
if err != nil {
return err
}
}
result[len(result)-1], err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
return err
}
// AssetsForAddress loads `dest` as `[]xdr.Asset` with every asset the account
// at `addy` can hold.
func (q *Q) AssetsForAddress(dest interface{}, addy string) error {
var tls []Trustline
err := q.TrustlinesByAddress(&tls, addy)
if err != nil {
return err
}
dtl, ok := dest.(*[]xdr.Asset)
if !ok {
return errors.New("Invalid destination")
}
result := make([]xdr.Asset, len(tls)+1)
*dtl = result
for i, tl := range tls {
result[i], err = AssetFromDB(tl.Assettype, tl.Assetcode, tl.Issuer)
if err != nil {
return err
}
}
result[len(result)-1], err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
return err
}
func AssetFromDB(typ xdr.AssetType, code string, issuer string) (result xdr.Asset, err error) {
switch typ {
case xdr.AssetTypeAssetTypeNative:
result, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
case xdr.AssetTypeAssetTypeCreditAlphanum4:
var (
an xdr.AssetAlphaNum4
decoded []byte
pkey xdr.Uint256
)
copy(an.AssetCode[:], []byte(code))
decoded, err = strkey.Decode(strkey.VersionByteAccountID, issuer)
if err != nil {
return
}
copy(pkey[:], decoded)
an.Issuer, err = xdr.NewAccountId(xdr.CryptoKeyTypeKeyTypeEd25519, pkey)
if err != nil {
return
}
result, err = xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum4, an)
case xdr.AssetTypeAssetTypeCreditAlphanum12:
var (
an xdr.AssetAlphaNum12
decoded []byte
pkey xdr.Uint256
)
copy(an.AssetCode[:], []byte(code))
decoded, err = strkey.Decode(strkey.VersionByteAccountID, issuer)
if err != nil {
return
}
copy(pkey[:], decoded)
an.Issuer, err = xdr.NewAccountId(xdr.CryptoKeyTypeKeyTypeEd25519, pkey)
if err != nil {
return
}
result, err = xdr.NewAsset(xdr.AssetTypeAssetTypeCreditAlphanum12, an)
}
return
}
// MutatePayment for NativeAmount sets the PaymentOp's currency field to
// native and sets its amount to the provided integer
func (m NativeAmount) MutatePayment(o *xdr.PaymentOp) (err error) {
o.Asset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
if err != nil {
return
}
o.Amount, err = amount.Parse(m.Amount)
return
}
func makeAsset(typ xdr.AssetType, code string, issuer string) xdr.Asset {
if typ == xdr.AssetTypeAssetTypeNative {
result, _ := xdr.NewAsset(typ, nil)
return result
}
an := xdr.AssetAlphaNum4{}
copy(an.AssetCode[:], code[:])
raw := strkey.MustDecode(strkey.VersionByteAccountID, issuer)
var key xdr.Uint256
copy(key[:], raw)
an.Issuer, _ = xdr.NewAccountId(xdr.CryptoKeyTypeKeyTypeEd25519, key)
result, _ := xdr.NewAsset(typ, an)
return result
}
// MutatePayment for NativeAmount sets the PaymentOp's currency field to
// native and sets its amount to the provided integer
func (m NativeAmount) MutatePayment(o interface{}) (err error) {
switch o := o.(type) {
default:
err = errors.New("Unexpected operation type")
case *xdr.PaymentOp:
o.Amount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.Asset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
case *xdr.PathPaymentOp:
o.DestAmount, err = amount.Parse(m.Amount)
if err != nil {
return
}
o.DestAsset, err = xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
}
return
}
// GetAsset
func (base *Base) GetAsset(prefix string) (result xdr.Asset) {
if base.Err != nil {
return
}
var value interface{}
t := base.GetAssetType(prefix + "asset_type")
switch t {
case xdr.AssetTypeAssetTypeCreditAlphanum4:
a := xdr.AssetAlphaNum4{}
a.Issuer = base.GetAccountID(prefix + "asset_issuer")
c := base.GetString(prefix + "asset_code")
if len(c) > len(a.AssetCode) {
base.SetInvalidField(prefix+"asset_code", nil)
return
}
copy(a.AssetCode[:len(c)], []byte(c))
value = a
case xdr.AssetTypeAssetTypeCreditAlphanum12:
a := xdr.AssetAlphaNum12{}
a.Issuer = base.GetAccountID(prefix + "asset_issuer")
c := base.GetString(prefix + "asset_code")
if len(c) > len(a.AssetCode) {
base.SetInvalidField(prefix+"asset_code", nil)
return
}
copy(a.AssetCode[:len(c)], []byte(c))
value = a
}
result, err := xdr.NewAsset(t, value)
if err != nil {
panic(err)
}
return
}
// MutatePayment for NativeAmount sets the PaymentOp's currency field to
// native and sets its amount to the provided integer
func (m NativeAmount) MutatePayment(o *xdr.PaymentOp) error {
asset, err := xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
o.Asset = asset
o.Amount = xdr.Int64(m.Amount)
return err
}
// ExampleLowLevelTransaction creates and signs a simple transaction, and then
// encodes it into a hex string capable of being submitted to stellar-core.
//
// It uses the low-level xdr facilities to create the transaction.
func ExampleLowLevelTransaction() {
spub, spriv, err := GenerateKeyFromSeed("SA26PHIKZM6CXDGR472SSGUQQRYXM6S437ZNHZGRM6QA4FOPLLLFRGDX")
if err != nil {
panic(err)
}
dpub, _, err := GenerateKeyFromSeed("SBQHO2IMYKXAYJFCWGXC7YKLJD2EGDPSK3IUDHVJ6OOTTKLSCK6Z6POM")
if err != nil {
panic(err)
}
asset, err := xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
if err != nil {
panic(err)
}
destination, err := AddressToAccountId(dpub.Address())
if err != nil {
panic(err)
}
op := xdr.PaymentOp{
Destination: destination,
Asset: asset,
Amount: 50 * 10000000,
}
memo, err := xdr.NewMemo(xdr.MemoTypeMemoNone, nil)
source, err := AddressToAccountId(spub.Address())
if err != nil {
panic(err)
}
body, err := xdr.NewOperationBody(xdr.OperationTypePayment, op)
if err != nil {
panic(err)
}
tx := xdr.Transaction{
SourceAccount: source,
Fee: 10,
SeqNum: xdr.SequenceNumber(1),
Memo: memo,
Operations: []xdr.Operation{
{Body: body},
},
}
var txBytes bytes.Buffer
_, err = xdr.Marshal(&txBytes, tx)
if err != nil {
panic(err)
}
txHash := Hash(txBytes.Bytes())
signature := spriv.Sign(txHash[:])
ds := xdr.DecoratedSignature{
Hint: spriv.Hint(),
Signature: xdr.Signature(signature[:]),
}
txe := xdr.TransactionEnvelope{
Tx: tx,
Signatures: []xdr.DecoratedSignature{ds},
}
var txeBytes bytes.Buffer
_, err = xdr.Marshal(&txeBytes, txe)
if err != nil {
panic(err)
}
txeB64 := base64.StdEncoding.EncodeToString(txeBytes.Bytes())
fmt.Printf("tx base64: %s", txeB64)
// Output: tx base64: AAAAAAU08yUQ8sHqhY8j9mXWwERfHC/3cKFSe/spAr0rGtO2AAAACgAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAA+fnTe7/v4whpBUx96oj92jfZPz7S00l3O2xeyeqWIA0AAAAAAAAAAB3NZQAAAAAAAAAAATXnnQoAAABAieruUIGcQH6RlQ+prYflPFU3nED2NvWhtaC+tgnKsqgiKURK4xo/W7EgH0+I6aQok52awbE+ksOxEQ5MLJ9eAw==
}