feat(sdk-coin-apt): addition of test case for apt transaction builder

Ticket: COIN-2258

Author: baltiyal

modules/sdk-coin-apt/src/apt.ts

@@ -11,9 +11,15 @@ import {
   VerifyAddressOptions,
   VerifyTransactionOptions,
 } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
-import { KeyPair as AptKeyPair } from './lib';
+import { BaseCoin as StaticsBaseCoin, coins } from '@bitgo/statics';
+import { KeyPair as AptKeyPair, TransactionBuilderFactory, TransferTransaction } from './lib';
 import utils from './lib/utils';
+import * as _ from 'lodash';
+import BigNumber from 'bignumber.js';
+
+export interface AptParseTransactionOptions extends ParseTransactionOptions {
+  txHex: string;
+}
 
 export class Apt extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -64,7 +70,40 @@ export class Apt extends BaseCoin {
   }
 
   async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
-    throw new Error('Method not implemented.');
+    const coinConfig = coins.get(this.getChain());
+    const { txPrebuild: txPrebuild, txParams: txParams } = params;
+    const transaction = new TransferTransaction(coinConfig);
+    const rawTx = txPrebuild.txHex;
+    if (!rawTx) {
+      throw new Error('missing required tx prebuild property txHex');
+    }
+    transaction.fromRawTransaction(rawTx);
+    const explainedTx = transaction.explainTransaction();
+    if (txParams.recipients !== undefined) {
+      const filteredRecipients = txParams.recipients?.map((recipient) => {
+        return {
+          address: recipient.address, // TODO: check this
+          amount: BigInt(recipient.amount),
+        };
+      });
+      const filteredOutputs = explainedTx.outputs.map((output) => {
+        return {
+          address: output.address,
+          amount: BigInt(output.amount),
+        };
+      });
+      if (!_.isEqual(filteredOutputs, filteredRecipients)) {
+        throw new Error('Tx outputs does not match with expected txParams recipients');
+      }
+      let totalAmount = new BigNumber(0);
+      for (const recipients of txParams.recipients) {
+        totalAmount = totalAmount.plus(recipients.amount);
+      }
+      if (!totalAmount.isEqualTo(explainedTx.outputAmount)) {
+        throw new Error('Tx total amount does not match with expected total amount field');
+      }
+    }
+    return true;
   }
 
   async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
@@ -76,8 +115,26 @@ export class Apt extends BaseCoin {
     return true;
   }
 
-  parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {
-    throw new Error('Method not implemented.');
+  async parseTransaction(params: AptParseTransactionOptions): Promise<ParsedTransaction> {
+    const coinConfig = coins.get(this.getChain());
+    const factory = new TransactionBuilderFactory(coinConfig);
+    const transactionBuilder = factory.from(params.txHex);
+    const rebuiltTransaction = await transactionBuilder.build();
+    const parsedTransaction = rebuiltTransaction.toJson();
+    return {
+      inputs: [
+        {
+          address: parsedTransaction.sender,
+          value: parsedTransaction.recipient.amount,
+        },
+      ],
+      outputs: [
+        {
+          address: parsedTransaction.recipient.address,
+          value: parsedTransaction.recipient.amount,
+        },
+      ],
+    };
   }
 
   generateKeyPair(seed?: Buffer): KeyPair {

modules/sdk-coin-apt/src/lib/iface.ts

@@ -1,5 +1,9 @@
 import { ITransactionExplanation, TransactionFee } from '@bitgo/sdk-core';
 
+export enum AptTransactionType {
+  Transfer = 'Transfer',
+  TokenTransfer = 'TokenTransfer',
+}
 export type TransactionExplanation = ITransactionExplanation<TransactionFee>;
 
 /**

modules/sdk-coin-apt/src/lib/transaction/transaction.ts

@@ -10,11 +10,11 @@ import {
 import { TransactionExplanation, TxData } from '../iface';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import {
-  AccountAddress,
   AccountAuthenticatorEd25519,
   Ed25519PublicKey,
   Ed25519Signature,
   generateUserTransactionHash,
+  Hex,
   RawTransaction,
   SignedTransaction,
   SimpleTransaction,
@@ -27,6 +27,13 @@ export abstract class Transaction extends BaseTransaction {
   protected _rawTransaction: RawTransaction;
   protected _signature: Signature;
 
+  protected _sender: string;
+  protected _recipient: TransactionRecipient;
+  protected _sequenceNumber: bigint;
+  protected _maxGasAmount: bigint;
+  protected _gasUnitPrice: bigint;
+  protected _expirationTime: bigint;
+  protected _chainId: number;
   static DEFAULT_PUBLIC_KEY = Buffer.alloc(32);
   static DEFAULT_SIGNATURE = Buffer.alloc(64);
 
@@ -38,37 +45,69 @@ export abstract class Transaction extends BaseTransaction {
   public get id(): string {
     return this._id ?? UNAVAILABLE_TEXT;
   }
+  get sender(): string {
+    return this._sender;
+  }
 
-  set transactionType(transactionType: TransactionType) {
-    this._type = transactionType;
+  set sender(value: string) {
+    this._sender = value;
   }
 
-  public get signablePayload(): Buffer {
-    const rawTxnHex = this._rawTransaction.bcsToHex().toString();
-    return Buffer.from(rawTxnHex, 'hex');
+  get recipient(): TransactionRecipient {
+    return this._recipient;
+  }
+
+  set recipient(value: TransactionRecipient) {
+    this._recipient = value;
+  }
+
+  get sequenceNumber(): bigint {
+    return this._sequenceNumber;
+  }
+
+  set sequenceNumber(value: bigint) {
+    this._sequenceNumber = value;
+  }
+
+  get maxGasAmount(): bigint {
+    return this._maxGasAmount;
+  }
+
+  set maxGasAmount(value: bigint) {
+    this._maxGasAmount = value;
+  }
+
+  get gasUnitPrice(): bigint {
+    return this._gasUnitPrice;
+  }
+
+  set gasUnitPrice(value: bigint) {
+    this._gasUnitPrice = value;
+  }
+
+  get expirationTime(): bigint {
+    return this._expirationTime;
+  }
+
+  set expirationTime(value: bigint) {
+    this._expirationTime = value;
   }
 
-  public get sender(): string {
-    return this._rawTransaction.sender.toString();
+  get chainId(): number {
+    return this._chainId;
   }
 
-  set sender(senderAddress: string) {
-    // Cannot assign to 'sender' because it is a read-only property in RawTransaction.
-    const { sequence_number, payload, max_gas_amount, gas_unit_price, expiration_timestamp_secs, chain_id } =
-      this._rawTransaction;
-    this._rawTransaction = new RawTransaction(
-      AccountAddress.fromString(senderAddress),
-      sequence_number,
-      payload,
-      max_gas_amount,
-      gas_unit_price,
-      expiration_timestamp_secs,
-      chain_id
-    );
+  set chainId(value: number) {
+    this._chainId = value;
   }
 
-  public get recipient(): TransactionRecipient {
-    return utils.getRecipientFromTransactionPayload(this._rawTransaction.payload);
+  set transactionType(transactionType: TransactionType) {
+    this._type = transactionType;
+  }
+
+  public get signablePayload(): Buffer {
+    const rawTxnHex = this._rawTransaction.bcsToHex().toString();
+    return Buffer.from(rawTxnHex, 'hex');
   }
 
   canSign(_key: BaseKey): boolean {
@@ -81,17 +120,33 @@ export abstract class Transaction extends BaseTransaction {
     }
     return this.serialize();
   }
+  //constructor(sender: AccountAddress, sequence_number: bigint, payload:
+  // TransactionPayload, max_gas_amount: bigint, gas_unit_price: bigint,
+  // expiration_timestamp_secs: bigint, chain_id: ChainId);
+
+  // private initializeRawTransaction(){
+  //   this._rawTransaction = new RawTransaction(
+  //     AccountAddress.from(this.sender),
+  //     this._sequenceNumber,
+  //     this._maxGasAmount,
+  //     this._gasUnitPrice,
+  //     this._expirationTime,
+  //     this._chainId
+  //     new TransactionPayload()
+  //   );
+  // }
 
   serialize(): string {
     let publicKeyBuffer = Transaction.DEFAULT_PUBLIC_KEY;
     let signatureBuffer = Transaction.DEFAULT_SIGNATURE;
     if (this._signature && this._signature.publicKey && this._signature.signature) {
-      publicKeyBuffer = Buffer.from(this._signature.publicKey.pub, 'hex');
+      publicKeyBuffer = Buffer.from(Hex.fromHexString(this._signature.publicKey.pub).toUint8Array());
       signatureBuffer = this._signature.signature;
     }
     const publicKey = new Ed25519PublicKey(publicKeyBuffer);
     const signature = new Ed25519Signature(signatureBuffer);
     const txnAuthenticator = new TransactionAuthenticatorEd25519(publicKey, signature);
+    // this._rawTransaction = new RawTransaction(AccountAddress.from(this.sender),)
     const signedTxn = new SignedTransaction(this._rawTransaction, txnAuthenticator);
     return signedTxn.toString();
   }
@@ -103,7 +158,6 @@ export abstract class Transaction extends BaseTransaction {
     if (!Transaction.DEFAULT_PUBLIC_KEY.equals(publicKeyBuffer) && !Transaction.DEFAULT_SIGNATURE.equals(signature)) {
       this._signatures.push(signature.toString('hex'));
       this._signature = { publicKey, signature };
-      this.serialize();
     }
   }
 
@@ -119,34 +173,43 @@ export abstract class Transaction extends BaseTransaction {
   }
 
   loadInputsAndOutputs(): void {
-    const txRecipient = this.recipient;
     this._inputs = [
       {
-        address: this.sender,
-        value: txRecipient.amount as string,
+        address: this._sender,
+        value: this.recipient.amount as string,
         coin: this._coinConfig.name,
       },
     ];
     this._outputs = [
       {
-        address: txRecipient.address,
-        value: txRecipient.amount as string,
+        address: this.recipient.address,
+        value: this.recipient.amount as string,
         coin: this._coinConfig.name,
       },
     ];
   }
 
+  private populateTransactionData(): void {
+    if (!this._rawTransaction) {
+      throw new InvalidTransactionError('Empty transaction');
+    }
+    this._sender = this._rawTransaction.sender.toString();
+    this._recipient = utils.getRecipientFromTransactionPayload(this._rawTransaction.payload);
+    this._maxGasAmount = this._rawTransaction.max_gas_amount;
+    this._gasUnitPrice = this._rawTransaction.gas_unit_price;
+    this._expirationTime = this._rawTransaction.expiration_timestamp_secs;
+    this._chainId = this._rawTransaction.chain_id.chainId;
+  }
+
   fromRawTransaction(rawTransaction: string): void {
     try {
       const signedTxn = utils.deserializeSignedTransaction(rawTransaction);
       this._rawTransaction = signedTxn.raw_txn;
-
+      this.populateTransactionData();
       this.loadInputsAndOutputs();
-
       const authenticator = signedTxn.authenticator as TransactionAuthenticatorEd25519;
-      const publicKey = Buffer.from(authenticator.public_key.toUint8Array());
       const signature = Buffer.from(authenticator.signature.toUint8Array());
-      this.addSignature({ pub: publicKey.toString() }, signature);
+      this.addSignature({ pub: authenticator.public_key.toString() }, signature);
     } catch (e) {
       console.error('invalid raw transaction', e);
       throw new Error('invalid raw transaction');
@@ -155,6 +218,7 @@ export abstract class Transaction extends BaseTransaction {
 
   /** @inheritDoc */
   explainTransaction(): TransactionExplanation {
+    //TODO: explain transaction to take input as params then take build txn and return the explanation
     const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'];
 
     const outputs: TransactionRecipient[] = [this.recipient];

modules/sdk-coin-apt/src/lib/transaction/transferTransaction.ts

@@ -3,6 +3,9 @@ import { TxData } from '../iface';
 import { TransactionPayloadEntryFunction } from '@aptos-labs/ts-sdk';
 
 export class TransferTransaction extends Transaction {
+  constructor(coinConfig) {
+    super(coinConfig);
+  }
   toJson(): TxData {
     const rawTxn = this._rawTransaction;
     const payload = this._rawTransaction.payload as TransactionPayloadEntryFunction;

modules/sdk-coin-apt/src/lib/transferBuilder.ts

@@ -1,17 +1,23 @@
 import { TransactionBuilder } from './transactionBuilder';
 import { BaseCoin as CoinConfig } from '@bitgo/statics';
-import { TransactionType } from '@bitgo/sdk-core';
+import { Recipient, TransactionType } from '@bitgo/sdk-core';
 import { TransferTransaction } from './transaction/transferTransaction';
 
 export class TransferBuilder extends TransactionBuilder {
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
+    this.transaction = new TransferTransaction(_coinConfig);
   }
 
   protected get transactionType(): TransactionType {
     return TransactionType.Send;
   }
 
+  send(txRecipient: Recipient): this {
+    this.transaction.txRecipient = txRecipient;
+    return this;
+  }
+
   /**
    * Initialize the transaction builder fields using the decoded transaction data
    *

modules/sdk-coin-apt/src/lib/utils.ts

@@ -67,7 +67,8 @@ export class Utils implements BaseUtils {
     if (payload instanceof TransactionPayloadEntryFunction) {
       const entryFunction = payload.entryFunction;
       address = entryFunction.args[0].toString();
-      amount = entryFunction.args[1].toString();
+      const amountBuffer = Buffer.from(entryFunction.args[1].bcsToBytes());
+      amount = amountBuffer.readBigUint64LE().toString();
     }
     return { address, amount };
   }
@@ -107,6 +108,10 @@ export class Utils implements BaseUtils {
     const deserializer = new Deserializer(txnBytes);
     return deserializer.deserialize(SignedTransaction);
   }
+
+  // initializeRawTransaction(sender: string, sequenceNumber): RawTransaction {
+  //   return new RawTransaction();
+  // }
 }
 
 const utils = new Utils();