Get the operation record of a payment

Question

Using the javascript sdk, I'm sending a payment like so:

const operation = Operation.payment({
    destination: toAddress,
    asset: asset,
    amount: amount.toString()
});

const account = await server.loadAccount(address);
const transactionBuilder = new StellarSdk.TransactionBuilder(account);
transactionBuilder.addOperation(operation);

const transaction = transactionBuilder.build();
transaction.sign(this.keys);

const payment = await this.server.submitTransaction(transaction);

This works well, but I also want to get the operation record for that transaction.
It seems that the type of payment should be TransactionRecord:

interface TransactionRecord extends Record {
    id: string;
    paging_token: string;
    hash: string;
    ledger_attr: number;
    created_at: string;
    max_fee: number;
    fee_paid: number;
    operation_count: number;
    result_code: number;
    result_code_s: string;
    source_account: string;
    source_account_sequence: string;
    envelope_xdr: string;
    result_xdr: string;
    result_meta_xdr: string;
    memo: string;

    account: CallFunction<AccountRecord>;
    effects: CallCollectionFunction<EffectRecord>;
    ledger: CallFunction<LedgerRecord>;
    operations: CallCollectionFunction<OperationRecord>;
    precedes: CallFunction<TransactionRecord>;
    self: CallFunction<TransactionRecord>;
    succeeds: CallFunction<TransactionRecord>;
}

But when I try to do this:

(await payment.operations())._embedded.records[0] as PaymentOperationRecord;

I get an error because payment.operations is undefined.
I logged the value of payment and it was something like:

{
    _links: {
        transaction: { 
            href: '...' 
        } 
    },
    hash: '...',
    ledger: 0000000,
    envelope_xdr: '...',
    result_xdr: '...',
    result_meta_xdr: '...' 
}

Am I mistaken in thinking that the type of the result should be TransactionRecord? And if so, what is this type? I couldn't find anything in the typescript definition files to match it, and the official documentation doesn't say much about it.

Thanks.

Answer 1

That is the object returned from a successful submitTransaction call, it is not the transaction record object that you get from calling server.transactions().transaction(hash).

If you would like to get the operation object, you can either decode the envelope_xdr or call server.operations.forTransactions(transactionID) just parse the transactionID from the _links object of the submitTransaction result. Sample:

  server.operations()          
      .forTransaction(transId)
      .call()
      .then(function (opResult) {
          console.log(opResult);              
      })
      .catch(function (err) {
          console.error(err);
      });

and you'll get an operation object with this format:

{ records:
   [ { _links: [Object],
       id: '44177754433802241',
       paging_token: '44177754433802241',
       source_account: 'GCPRLQQ564KOUEXFEFGODULAT2ME7SCTY5QE6RSGIATZVFQWFVNCDGOR',
       type: 'payment',
       type_i: 1,
       created_at: '2018-07-30T10:16:34Z',
       transaction_hash: 'e52bbe411b14501514420958287c3d0a50554ebff662a26b16a45de6d09fd076',
       asset_type: 'native',
       from: 'GCPRLQQ564KOUEXFEFGODULAT2ME7SCTY5QE6RSGIATZVFQWFVNCDGOR',
       to: 'GATGC7IEHN6SBRPTEGIACCWXB6VHGVA7UYZGOIBE4LFXRSKYCLWO5QH3',
       amount: '2.9900000',
       self: [Function],
       transaction: [Function],
       effects: [Function],
       succeeds: [Function],
       precedes: [Function] } ],
  next: [Function: next],
  prev: [Function: prev] 
}

Answer 2

According to the Stellar docs and source code, what you get back is just a plain object, straight from Horizon.

https://stellar.github.io/js-stellar-sdk/Server.html#submitTransaction

https://github.com/stellar/js-stellar-sdk/blob/master/src/server.js#L63

Here is more documentation on what Horizon returns:

https://github.com/stellar/go/blob/master/services/horizon/internal/docs/reference/endpoints/transactions-create.md#response