feat(sdk-coin-apt): transaction builder

TICKET: COIN-2258

modules/sdk-coin-apt/package.json

@@ -40,7 +40,7 @@
     ]
   },
   "dependencies": {
-    "@aptos-labs/ts-sdk": "^1.32.0",
+    "@aptos-labs/ts-sdk": "^1.33.1",
     "@bitgo/sdk-core": "^28.17.2",
     "@bitgo/statics": "^50.16.0",
     "bignumber.js": "^9.1.2"

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

@@ -2,3 +2,4 @@ export const APT_ADDRESS_LENGTH = 64;
 export const APT_TRANSACTION_ID_LENGTH = 64;
 export const APT_BLOCK_ID_LENGTH = 64;
 export const APT_SIGNATURE_LENGTH = 128;
+export const UNAVAILABLE_TEXT = 'UNAVAILABLE';

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

@@ -1,16 +1,6 @@
-import {
-  TransactionExplanation as BaseTransactionExplanation,
-  TransactionType as BitGoTransactionType,
-} from '@bitgo/sdk-core';
+import { ITransactionExplanation, TransactionFee } from '@bitgo/sdk-core';
 
-export enum AptTransactionType {
-  Transfer = 'Transfer',
-  TokenTransfer = 'TokenTransfer',
-}
-
-export interface TransactionExplanation extends BaseTransactionExplanation {
-  type: BitGoTransactionType;
-}
+export type TransactionExplanation = ITransactionExplanation<TransactionFee>;
 
 /**
  * The transaction data returned from the toJson() function of a transaction

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

@@ -2,7 +2,8 @@ import * as Utils from './utils';
 import * as Interface from './iface';
 
 export { KeyPair } from './keyPair';
-export { Transaction } from './transaction';
+export { Transaction } from './transaction/transaction';
+export { TransferTransaction } from './transaction/transferTransaction';
 export { TransactionBuilder } from './transactionBuilder';
 export { TransferBuilder } from './transferBuilder';
 export { TransactionBuilderFactory } from './transactionBuilderFactory';

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

@@ -0,0 +1,163 @@
+import {
+  BaseKey,
+  BaseTransaction,
+  InvalidTransactionError,
+  PublicKey,
+  Signature,
+  TransactionRecipient,
+  TransactionType,
+} from '@bitgo/sdk-core';
+import { TransactionExplanation, TxData } from '../iface';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import {
+  AccountAddress,
+  AccountAuthenticatorEd25519,
+  Deserializer,
+  Ed25519PublicKey,
+  Ed25519Signature,
+  generateUserTransactionHash,
+  Hex,
+  RawTransaction,
+  SignedTransaction,
+  SimpleTransaction,
+  TransactionAuthenticatorEd25519,
+} from '@aptos-labs/ts-sdk';
+import { UNAVAILABLE_TEXT } from '../constants';
+import utils from '../utils';
+
+export abstract class Transaction extends BaseTransaction {
+  protected _rawTransaction: RawTransaction;
+  protected _signature: Signature;
+
+  constructor(coinConfig: Readonly<CoinConfig>) {
+    super(coinConfig);
+  }
+
+  /** @inheritDoc **/
+  public get id(): string {
+    return this._id ?? UNAVAILABLE_TEXT;
+  }
+
+  set transactionType(transactionType: TransactionType) {
+    this._type = transactionType;
+  }
+
+  public get signablePayload(): Buffer {
+    const rawTxnHex = this._rawTransaction.bcsToHex().toString();
+    return Buffer.from(rawTxnHex, 'hex');
+  }
+
+  public get sender(): string {
+    return this._rawTransaction.sender.toString();
+  }
+
+  set sender(senderAddress: string) {
+    this._rawTransaction.sender = AccountAddress.fromString(senderAddress);
+  }
+
+  public get recipient(): TransactionRecipient {
+    return utils.getRecipientFromTransactionPayload(this._rawTransaction.payload);
+  }
+
+  canSign(_key: BaseKey): boolean {
+    return false;
+  }
+
+  toBroadcastFormat(): string {
+    if (!this._rawTransaction) {
+      throw new InvalidTransactionError('Empty transaction');
+    }
+    return this.serialize();
+  }
+
+  serialize(): string {
+    if (!this._signature || !this._signature.publicKey || !this._signature.signature) {
+      return this._rawTransaction.bcsToHex().toString();
+    }
+    const publicKey = new Ed25519PublicKey(Buffer.from(this._signature.publicKey.pub, 'hex'));
+    const signature = new Ed25519Signature(this._signature.signature);
+    const txnAuthenticator = new TransactionAuthenticatorEd25519(publicKey, signature);
+    const signedTxn = new SignedTransaction(this._rawTransaction, txnAuthenticator);
+    return signedTxn.bcsToHex().toString();
+  }
+
+  abstract toJson(): TxData;
+
+  addSignature(publicKey: PublicKey, signature: Buffer): void {
+    this._signatures.push(signature.toString('hex'));
+    this._signature = { publicKey, signature };
+    this.serialize();
+  }
+
+  async build(): Promise<void> {
+    this.loadInputsAndOutputs();
+    if (this._signature) {
+      const publicKey = new Ed25519PublicKey(Buffer.from(this._signature.publicKey.pub, 'hex'));
+      const signature = new Ed25519Signature(this._signature.signature);
+
+      this._id = generateUserTransactionHash({
+        transaction: new SimpleTransaction(this._rawTransaction),
+        senderAuthenticator: new AccountAuthenticatorEd25519(publicKey, signature),
+      });
+    }
+  }
+
+  loadInputsAndOutputs(): void {
+    const txRecipient = this.recipient;
+    this._inputs = [
+      {
+        address: this.sender,
+        value: txRecipient.amount as string,
+        coin: this._coinConfig.name,
+      },
+    ];
+    this._outputs = [
+      {
+        address: txRecipient.address,
+        value: txRecipient.amount as string,
+        coin: this._coinConfig.name,
+      },
+    ];
+  }
+
+  fromRawTransaction(rawTransaction: string): void {
+    try {
+      const txnBytes = Hex.fromHexString(rawTransaction).toUint8Array();
+      const deserializer = new Deserializer(txnBytes);
+      this._rawTransaction = deserializer.deserialize(RawTransaction);
+
+      this.loadInputsAndOutputs();
+    } catch (e) {
+      console.error('invalid raw transaction', e);
+      throw new Error('invalid raw transaction');
+    }
+  }
+
+  /** @inheritDoc */
+  explainTransaction(): TransactionExplanation {
+    const displayOrder = ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'];
+
+    const outputs: TransactionRecipient[] = [this.recipient];
+    const outputAmount = outputs[0].amount;
+    return {
+      displayOrder,
+      id: this.id,
+      outputs,
+      outputAmount,
+      changeOutputs: [],
+      changeAmount: '0',
+      fee: { fee: 'UNKNOWN' },
+    };
+  }
+
+  static deserializeRawTransaction(rawTransaction: string): RawTransaction {
+    try {
+      const txnBytes = Hex.fromHexString(rawTransaction).toUint8Array();
+      const deserializer = new Deserializer(txnBytes);
+      return deserializer.deserialize(RawTransaction);
+    } catch (e) {
+      console.error('invalid raw transaction', e);
+      throw new Error('invalid raw transaction');
+    }
+  }
+}

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

@@ -0,0 +1,26 @@
+import { Transaction } from './transaction';
+import { TxData } from '../iface';
+import { TransactionPayloadEntryFunction } from '@aptos-labs/ts-sdk';
+
+export class TransferTransaction extends Transaction {
+  toJson(): TxData {
+    const rawTxn = this._rawTransaction;
+    const payload = this._rawTransaction.payload as TransactionPayloadEntryFunction;
+    const entryFunction = payload.entryFunction;
+    return {
+      id: this.id,
+      sender: this.sender,
+      sequenceNumber: rawTxn.sequence_number,
+      maxGasAmount: rawTxn.max_gas_amount,
+      gasUnitPrice: rawTxn.gas_unit_price,
+      expirationTime: rawTxn.expiration_timestamp_secs,
+      payload: {
+        function: entryFunction.function_name.identifier,
+        typeArguments: entryFunction.type_args.map((a) => a.toString()),
+        arguments: entryFunction.args.map((a) => a.toString()),
+        type: 'entry_function_payload',
+      },
+      chainId: rawTxn.chain_id.chainId,
+    };
+  }
+}

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

@@ -3,19 +3,24 @@ import {
   BaseKey,
   BaseTransactionBuilder,
   BuildTransactionError,
-  FeeOptions,
+  ParseTransactionError,
   PublicKey as BasePublicKey,
   Signature,
   TransactionType,
 } from '@bitgo/sdk-core';
-import { Transaction } from './transaction';
+import { Transaction } from './transaction/transaction';
 import utils from './utils';
 import BigNumber from 'bignumber.js';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
 
 export abstract class TransactionBuilder extends BaseTransactionBuilder {
   protected _transaction: Transaction;
   private _signatures: Signature[] = [];
 
+  constructor(coinConfig: Readonly<CoinConfig>) {
+    super(coinConfig);
+  }
+
   // get and set region
   /**
    * The transaction type.
@@ -40,6 +45,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
   /** @inheritDoc */
   addSignature(publicKey: BasePublicKey, signature: Buffer): void {
     this._signatures.push({ publicKey, signature });
+    this.transaction.addSignature(publicKey, signature);
   }
 
   /**
@@ -50,23 +56,32 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
    * @returns {TransactionBuilder} This transaction builder
    */
   sender(senderAddress: string): this {
-    throw new Error('Method not implemented.');
-  }
-
-  fee(feeOptions: FeeOptions): this {
-    throw new Error('Method not implemented.');
+    this.validateAddress({ address: senderAddress });
+    this._transaction.sender = senderAddress;
+    return this;
   }
 
   /** @inheritdoc */
   protected fromImplementation(rawTransaction: string): Transaction {
-    throw new Error('Method not implemented.');
+    this.transaction.fromRawTransaction(rawTransaction);
+    this.transaction.transactionType = this.transactionType;
+    return this.transaction;
   }
 
   /** @inheritdoc */
   protected async buildImplementation(): Promise<Transaction> {
-    throw new Error('Method not implemented.');
+    this.transaction.transactionType = this.transactionType;
+    await this.transaction.build();
+    return this.transaction;
   }
 
+  /**
+   * Initialize the transaction builder fields using the decoded transaction data
+   *
+   * @param {Transaction} tx the transaction data
+   */
+  abstract initBuilder(tx: Transaction): void;
+
   // region Validators
   /** @inheritdoc */
   validateAddress(address: BaseAddress, addressFormat?: string): void {
@@ -82,12 +97,20 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
 
   /** @inheritdoc */
   validateRawTransaction(rawTransaction: string): void {
-    throw new Error('Method not implemented.');
+    if (!rawTransaction) {
+      throw new ParseTransactionError('Invalid raw transaction: Undefined');
+    }
+    if (!utils.isValidRawTransaction(rawTransaction)) {
+      throw new ParseTransactionError('Invalid raw transaction');
+    }
   }
 
   /** @inheritdoc */
   validateTransaction(transaction?: Transaction): void {
-    throw new Error('Method not implemented.');
+    if (!transaction) {
+      throw new Error('transaction not defined');
+    }
+    this.validateRawTransaction(transaction.toBroadcastFormat());
   }
 
   /** @inheritdoc */