@bitgo-beta/sdk-coin-apt 1.0.0-alpha.162 → 1.0.0-alpha.164

package/dist/src/lib/iface.d.ts

@@ -55,8 +55,7 @@ export interface RecipientsValidationResult {
  * ```
  *
  * @remarks
- * - The `abi` field is required to ensure type safety
- * - Invalid ABI will cause transaction building to fail
+ * - The `abi` field is optional but provides type validation when present
  * - ABI must match the exact function signature of the target entry function
  */
 export interface CustomTransactionParams {
@@ -93,9 +92,9 @@ export interface CustomTransactionParams {
      */
     functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
     /**
-     * Entry function ABI for type validation and safety (required)
+     * Entry function ABI for type validation and safety (optional)
      *
-     * Provides:
+     * When provided:
      * - Validates argument count matches expected parameters
      * - Performs type checking during transaction building
      * - Improves error messages for invalid calls
@@ -104,6 +103,6 @@ export interface CustomTransactionParams {
      * - Providing incorrect ABI will cause transaction building to fail
      * - Must match the exact function signature of the target entry function
      */
-    abi: EntryFunctionABI;
+    abi?: EntryFunctionABI;
 }
 //# sourceMappingURL=iface.d.ts.map

package/dist/src/lib/iface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,IAAI,0BAA0B,EACpD,oBAAoB,EACpB,eAAe,IAAI,oBAAoB,EACxC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,gCAAgC,EAAE,MAAM,oBAAoB,CAAC;AAEpH,MAAM,WAAW,yBAA0B,SAAQ,0BAA0B;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,SAAS,EAAE,oBAAoB,CAAC;IAChC,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE;QACV,qBAAqB,EAAE,MAAM,EAAE,CAAC;QAChC,mBAAmB,EAAE,UAAU,EAAE,CAAC;KACnC,CAAC;IACF,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,KAAK,CAAC,0BAA0B,GAAG,gCAAgC,CAAC,CAAC;IAEzF;;;;;;;;;;;OAWG;IACH,GAAG,EAAE,gBAAgB,CAAC;CACvB"}
+{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../src/lib/iface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,IAAI,0BAA0B,EACpD,oBAAoB,EACpB,eAAe,IAAI,oBAAoB,EACxC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,gCAAgC,EAAE,MAAM,oBAAoB,CAAC;AAEpH,MAAM,WAAW,yBAA0B,SAAQ,0BAA0B;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,SAAS,EAAE,oBAAoB,CAAC;IAChC,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE;QACV,qBAAqB,EAAE,MAAM,EAAE,CAAC;QAChC,mBAAmB,EAAE,UAAU,EAAE,CAAC;KACnC,CAAC;IACF,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,KAAK,CAAC,0BAA0B,GAAG,gCAAgC,CAAC,CAAC;IAEzF;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACxB"}

package/dist/src/lib/iface.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/transaction/customTransaction.d.ts

@@ -3,31 +3,25 @@ import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { EntryFunctionABI, InputGenerateTransactionPayloadData, TransactionPayload } from '@aptos-labs/ts-sdk';
 import { CustomTransactionParams } from '../iface';
 /**
- * Transaction class for custom Aptos transactions with entry function payloads.
+ * Transaction class for custom Aptos transactions.
  */
 export declare class CustomTransaction extends Transaction {
     private _moduleName;
     private _functionName;
     private _typeArguments;
     private _functionArguments;
-    private _entryFunctionAbi;
+    private _entryFunctionAbi?;
     constructor(coinConfig: Readonly<CoinConfig>);
     /**
      * Set the custom transaction parameters
-     *
-     * @param {CustomTransactionParams} params - Custom transaction parameters
      */
     setCustomTransactionParams(params: CustomTransactionParams): void;
     /**
      * Set the entry function ABI
-     *
-     * @param {EntryFunctionABI} abi - The ABI definition for the entry function
      */
     setEntryFunctionAbi(abi: EntryFunctionABI): void;
     /**
-     * Get the full function name in the format moduleName::functionName
-     *
-     * @returns {string} The full function name
+     * Get the full function name
      */
     get fullFunctionName(): string;
     /**
@@ -37,37 +31,24 @@ export declare class CustomTransaction extends Transaction {
      */
     protected parseTransactionPayload(payload: TransactionPayload): void;
     /**
-     * Generate the transaction payload data for the custom transaction
-     *
-     * @returns {InputGenerateTransactionPayloadData} The transaction payload data
+     * Generate transaction payload data
      */
     protected getTransactionPayloadData(): InputGenerateTransactionPayloadData;
     /**
-     * Get the custom transaction parameters
-     *
-     * @returns {CustomTransactionParams} The custom transaction parameters
+     * Convert argument based on ABI type information
+     */
+    private convertArgumentByABI;
+    /**
+     * Get custom transaction parameters
      */
     getCustomTransactionParams(): CustomTransactionParams;
     /**
-     * Override the deprecated recipient getter to handle custom transactions gracefully
-     * Custom transactions may not have traditional recipients
-     *
-     * @deprecated - use `recipients()`
+     * Override recipient getter for custom transactions
      */
     get recipient(): any;
     /**
-     * Get validated full function name with runtime format checking
-     *
-     * @returns {string} The validated full function name
-     * @throws {Error} If function name format is invalid
+     * Get validated full function name
      */
     private getValidatedFullFunctionName;
-    /**
-     * Validate ABI structure and provide helpful error messages
-     *
-     * @param {EntryFunctionABI} abi - The ABI to validate
-     * @throws {Error} If ABI format is invalid
-     */
-    private validateAbi;
 }
 //# sourceMappingURL=customTransaction.d.ts.map

package/dist/src/lib/transaction/customTransaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"customTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EACL,gBAAgB,EAEhB,mCAAmC,EAEnC,kBAAkB,EAEnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,kBAAkB,CAA4E;IACtG,OAAO,CAAC,iBAAiB,CAAmB;gBAEhC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C;;;;OAIG;IACH,0BAA0B,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAYjE;;;;OAIG;IACH,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAIhD;;;;OAIG;IACH,IAAI,gBAAgB,IAAI,MAAM,CAK7B;IAED;;;;OAIG;IACH,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IA4BpE;;;;OAIG;IACH,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IAW1E;;;;OAIG;IACH,0BAA0B,IAAI,uBAAuB;IAUrD;;;;;OAKG;IACH,IAAI,SAAS,IAAI,GAAG,CASnB;IAED;;;;;OAKG;IACH,OAAO,CAAC,4BAA4B;IAkBpC;;;;;OAKG;IACH,OAAO,CAAC,WAAW;CAapB"}
+{"version":3,"file":"customTransaction.d.ts","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EACL,gBAAgB,EAGhB,mCAAmC,EACnC,kBAAkB,EAWnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;IAChD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,kBAAkB,CAA4E;IACtG,OAAO,CAAC,iBAAiB,CAAC,CAAmB;gBAEjC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK5C;;OAEG;IACH,0BAA0B,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI;IAWjE;;OAEG;IACH,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI;IAIhD;;OAEG;IACH,IAAI,gBAAgB,IAAI,MAAM,CAK7B;IAED;;;;OAIG;IACH,SAAS,CAAC,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAkCpE;;OAEG;IACH,SAAS,CAAC,yBAAyB,IAAI,mCAAmC;IA8B1E;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAuF5B;;OAEG;IACH,0BAA0B,IAAI,uBAAuB;IAUrD;;OAEG;IACH,IAAI,SAAS,IAAI,GAAG,CAQnB;IAED;;OAEG;IACH,OAAO,CAAC,4BAA4B;CAgBrC"}

package/dist/src/lib/transaction/customTransaction.js

@@ -6,7 +6,7 @@ const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const ts_sdk_1 = require("@aptos-labs/ts-sdk");
 const validation_1 = require("../utils/validation");
 /**
- * Transaction class for custom Aptos transactions with entry function payloads.
+ * Transaction class for custom Aptos transactions.
  */
 class CustomTransaction extends transaction_1.Transaction {
     constructor(coinConfig) {
@@ -17,13 +17,10 @@ class CustomTransaction extends transaction_1.Transaction {
     }
     /**
      * Set the custom transaction parameters
-     *
-     * @param {CustomTransactionParams} params - Custom transaction parameters
      */
     setCustomTransactionParams(params) {
         (0, validation_1.validateModuleName)(params.moduleName);
         (0, validation_1.validateFunctionName)(params.functionName);
-        this.validateAbi(params.abi);
         this._moduleName = params.moduleName;
         this._functionName = params.functionName;
         this._typeArguments = params.typeArguments || [];
@@ -32,16 +29,12 @@ class CustomTransaction extends transaction_1.Transaction {
     }
     /**
      * Set the entry function ABI
-     *
-     * @param {EntryFunctionABI} abi - The ABI definition for the entry function
      */
     setEntryFunctionAbi(abi) {
         this._entryFunctionAbi = abi;
     }
     /**
-     * Get the full function name in the format moduleName::functionName
-     *
-     * @returns {string} The full function name
+     * Get the full function name
      */
     get fullFunctionName() {
         if (!this._moduleName || !this._functionName) {
@@ -56,7 +49,7 @@ class CustomTransaction extends transaction_1.Transaction {
      */
     parseTransactionPayload(payload) {
         if (!(payload instanceof ts_sdk_1.TransactionPayloadEntryFunction)) {
-            throw new Error('Expected entry function payload for custom transaction');
+            throw new sdk_core_1.InvalidTransactionError('Expected entry function payload for custom transaction');
         }
         const entryFunction = payload.entryFunction;
         // Extract function data
@@ -64,33 +57,135 @@ class CustomTransaction extends transaction_1.Transaction {
         const moduleIdentifier = entryFunction.module_name.name.identifier;
         const functionIdentifier = entryFunction.function_name.identifier;
         const moduleName = `${moduleAddress}::${moduleIdentifier}`;
-        // Validate the extracted names using our existing validation
+        // Validate
         (0, validation_1.validateModuleName)(moduleName);
         (0, validation_1.validateFunctionName)(functionIdentifier);
         this._moduleName = moduleName;
         this._functionName = functionIdentifier;
-        // Extract type arguments and function arguments
         this._typeArguments = entryFunction.type_args.map((typeArg) => typeArg.toString());
-        this._functionArguments = entryFunction.args;
+        this._functionArguments = entryFunction.args.map((arg) => {
+            if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
+                return arg;
+            }
+            if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {
+                const bytes = Array.from(arg.data);
+                return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+            }
+            return arg;
+        });
     }
     /**
-     * Generate the transaction payload data for the custom transaction
-     *
-     * @returns {InputGenerateTransactionPayloadData} The transaction payload data
+     * Generate transaction payload data
      */
     getTransactionPayloadData() {
         const functionName = this.getValidatedFullFunctionName();
+        // Convert arguments based on ABI information if available
+        const processedArguments = this._functionArguments.map((arg, index) => {
+            // Use ABI to identify the expected type for this argument
+            const paramType = this._entryFunctionAbi?.parameters?.[index];
+            if (paramType) {
+                return this.convertArgumentByABI(arg, paramType);
+            }
+            // Fallback: basic conversion for common cases
+            if (typeof arg === 'string' && arg.startsWith('0x') && arg.length === 66) {
+                try {
+                    return ts_sdk_1.AccountAddress.fromString(arg);
+                }
+                catch {
+                    return arg;
+                }
+            }
+            return arg;
+        });
         return {
             function: functionName,
             typeArguments: this._typeArguments,
-            functionArguments: this._functionArguments,
+            functionArguments: processedArguments,
             abi: this._entryFunctionAbi,
         };
     }
     /**
-     * Get the custom transaction parameters
-     *
-     * @returns {CustomTransactionParams} The custom transaction parameters
+     * Convert argument based on ABI type information
+     */
+    convertArgumentByABI(arg, paramType) {
+        // Helper function to convert bytes to hex string
+        const bytesToHex = (bytes) => {
+            return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');
+        };
+        // Helper function to try converting a hex string to an AccountAddress
+        const tryToAddress = (hexStr) => {
+            try {
+                return ts_sdk_1.AccountAddress.fromString(hexStr);
+            }
+            catch {
+                return hexStr;
+            }
+        };
+        // Handle primitive values (string, number, boolean)
+        if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {
+            // Address conversion for hex strings
+            if (paramType instanceof ts_sdk_1.TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {
+                return tryToAddress(arg);
+            }
+            // Type conversions based on parameter type
+            if (paramType instanceof ts_sdk_1.TypeTagBool)
+                return Boolean(arg);
+            if (paramType instanceof ts_sdk_1.TypeTagU8 || paramType instanceof ts_sdk_1.TypeTagU16 || paramType instanceof ts_sdk_1.TypeTagU32)
+                return Number(arg);
+            if (paramType instanceof ts_sdk_1.TypeTagU64 || paramType instanceof ts_sdk_1.TypeTagU128 || paramType instanceof ts_sdk_1.TypeTagU256)
+                return String(arg);
+            return arg;
+        }
+        // Handle BCS-encoded data with 'data' property
+        if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {
+            const bytes = Array.from(arg.data);
+            const hexString = bytesToHex(bytes);
+            return paramType instanceof ts_sdk_1.TypeTagAddress ? tryToAddress(hexString) : hexString;
+        }
+        // Handle nested BCS structures with 'value' property
+        if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {
+            // Simple value wrapper
+            if (!('value' in arg.value) || typeof arg.value.value !== 'object') {
+                return this.convertArgumentByABI(arg.value, paramType);
+            }
+            // Double nested structure with numeric keys
+            const bytesObj = arg.value.value;
+            const keys = Object.keys(bytesObj)
+                .filter((k) => !isNaN(parseInt(k, 10)))
+                .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+            if (keys.length === 0)
+                return arg;
+            const bytes = keys.map((k) => bytesObj[k]);
+            let extractedValue;
+            // Convert bytes based on parameter type
+            if (paramType instanceof ts_sdk_1.TypeTagAddress ||
+                paramType instanceof ts_sdk_1.TypeTagU64 ||
+                paramType instanceof ts_sdk_1.TypeTagU128 ||
+                paramType instanceof ts_sdk_1.TypeTagU256) {
+                extractedValue = bytesToHex(bytes);
+            }
+            else if (paramType instanceof ts_sdk_1.TypeTagBool) {
+                extractedValue = bytes[0] === 1;
+            }
+            else if (paramType instanceof ts_sdk_1.TypeTagU8 || paramType instanceof ts_sdk_1.TypeTagU16 || paramType instanceof ts_sdk_1.TypeTagU32) {
+                // Convert little-endian bytes to number using the original algorithm
+                // to ensure consistent behavior with large numbers
+                let result = 0;
+                for (let i = bytes.length - 1; i >= 0; i--) {
+                    result = result * 256 + bytes[i];
+                }
+                extractedValue = result;
+            }
+            else {
+                extractedValue = bytesToHex(bytes);
+            }
+            return this.convertArgumentByABI(extractedValue, paramType);
+        }
+        // For anything else, return as-is
+        return arg;
+    }
+    /**
+     * Get custom transaction parameters
      */
     getCustomTransactionParams() {
         return {
@@ -102,57 +197,32 @@ class CustomTransaction extends transaction_1.Transaction {
         };
     }
     /**
-     * Override the deprecated recipient getter to handle custom transactions gracefully
-     * Custom transactions may not have traditional recipients
-     *
-     * @deprecated - use `recipients()`
+     * Override recipient getter for custom transactions
      */
     get recipient() {
-        // For custom transactions, return a placeholder recipient if no recipients exist
         if (this._recipients.length === 0) {
             return {
-                address: '', // Empty address for custom transactions
+                address: '',
                 amount: '0',
             };
         }
         return this._recipients[0];
     }
     /**
-     * Get validated full function name with runtime format checking
-     *
-     * @returns {string} The validated full function name
-     * @throws {Error} If function name format is invalid
+     * Get validated full function name
      */
     getValidatedFullFunctionName() {
         if (!this._moduleName || !this._functionName) {
             throw new Error('Module name and function name must be set before building transaction');
         }
         const fullName = `${this._moduleName}::${this._functionName}`;
-        // Runtime validation of the expected format
-        // Supports both hex addresses (SHORT/LONG) and named addresses
+        // Basic validation
         const fullFunctionPattern = /^(0x[a-fA-F0-9]{1,64}|[a-zA-Z_][a-zA-Z0-9_]*)::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;
         if (!fullFunctionPattern.test(fullName)) {
             throw new Error(`Invalid full function name format: "${fullName}". Expected format: "address::module::function"`);
         }
         return fullName;
     }
-    /**
-     * Validate ABI structure and provide helpful error messages
-     *
-     * @param {EntryFunctionABI} abi - The ABI to validate
-     * @throws {Error} If ABI format is invalid
-     */
-    validateAbi(abi) {
-        if (!abi || typeof abi !== 'object') {
-            throw new Error('ABI must be a valid EntryFunctionABI object');
-        }
-        if (!Array.isArray(abi.typeParameters)) {
-            throw new Error('ABI must have a typeParameters array. Use [] if the function has no type parameters');
-        }
-        if (!Array.isArray(abi.parameters)) {
-            throw new Error('ABI must have a parameters array containing TypeTag objects for each function parameter');
-        }
-    }
 }
 exports.CustomTransaction = CustomTransaction;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customTransaction.js","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction } from './transaction';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport {\n  EntryFunctionABI,\n  EntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  SimpleEntryFunctionArgumentTypes,\n  TransactionPayload,\n  TransactionPayloadEntryFunction,\n} from '@aptos-labs/ts-sdk';\nimport { CustomTransactionParams } from '../iface';\nimport { validateModuleName, validateFunctionName } from '../utils/validation';\n\n/**\n * Transaction class for custom Aptos transactions with entry function payloads.\n */\nexport class CustomTransaction extends Transaction {\n  private _moduleName: string;\n  private _functionName: string;\n  private _typeArguments: string[] = [];\n  private _functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes> = [];\n  private _entryFunctionAbi: EntryFunctionABI;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._type = TransactionType.CustomTx;\n  }\n\n  /**\n   * Set the custom transaction parameters\n   *\n   * @param {CustomTransactionParams} params - Custom transaction parameters\n   */\n  setCustomTransactionParams(params: CustomTransactionParams): void {\n    validateModuleName(params.moduleName);\n    validateFunctionName(params.functionName);\n    this.validateAbi(params.abi);\n\n    this._moduleName = params.moduleName;\n    this._functionName = params.functionName;\n    this._typeArguments = params.typeArguments || [];\n    this._functionArguments = params.functionArguments || [];\n    this._entryFunctionAbi = params.abi;\n  }\n\n  /**\n   * Set the entry function ABI\n   *\n   * @param {EntryFunctionABI} abi - The ABI definition for the entry function\n   */\n  setEntryFunctionAbi(abi: EntryFunctionABI): void {\n    this._entryFunctionAbi = abi;\n  }\n\n  /**\n   * Get the full function name in the format moduleName::functionName\n   *\n   * @returns {string} The full function name\n   */\n  get fullFunctionName(): string {\n    if (!this._moduleName || !this._functionName) {\n      return '';\n    }\n    return `${this._moduleName}::${this._functionName}`;\n  }\n\n  /**\n   * Parse a transaction payload to extract the custom transaction data\n   *\n   * @param {TransactionPayload} payload - The transaction payload to parse\n   */\n  protected parseTransactionPayload(payload: TransactionPayload): void {\n    if (!(payload instanceof TransactionPayloadEntryFunction)) {\n      throw new Error('Expected entry function payload for custom transaction');\n    }\n\n    const entryFunction = payload.entryFunction;\n\n    // Extract function data\n    const moduleAddress = entryFunction.module_name.address.toString();\n    const moduleIdentifier = entryFunction.module_name.name.identifier;\n    const functionIdentifier = entryFunction.function_name.identifier;\n\n    const moduleName = `${moduleAddress}::${moduleIdentifier}`;\n\n    // Validate the extracted names using our existing validation\n    validateModuleName(moduleName);\n    validateFunctionName(functionIdentifier);\n\n    this._moduleName = moduleName;\n    this._functionName = functionIdentifier;\n\n    // Extract type arguments and function arguments\n    this._typeArguments = entryFunction.type_args.map((typeArg) => typeArg.toString());\n    this._functionArguments = entryFunction.args as Array<\n      EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes\n    >;\n  }\n\n  /**\n   * Generate the transaction payload data for the custom transaction\n   *\n   * @returns {InputGenerateTransactionPayloadData} The transaction payload data\n   */\n  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {\n    const functionName = this.getValidatedFullFunctionName();\n\n    return {\n      function: functionName,\n      typeArguments: this._typeArguments,\n      functionArguments: this._functionArguments,\n      abi: this._entryFunctionAbi,\n    };\n  }\n\n  /**\n   * Get the custom transaction parameters\n   *\n   * @returns {CustomTransactionParams} The custom transaction parameters\n   */\n  getCustomTransactionParams(): CustomTransactionParams {\n    return {\n      moduleName: this._moduleName || '',\n      functionName: this._functionName || '',\n      typeArguments: this._typeArguments,\n      functionArguments: this._functionArguments,\n      abi: this._entryFunctionAbi,\n    };\n  }\n\n  /**\n   * Override the deprecated recipient getter to handle custom transactions gracefully\n   * Custom transactions may not have traditional recipients\n   *\n   * @deprecated - use `recipients()`\n   */\n  get recipient(): any {\n    // For custom transactions, return a placeholder recipient if no recipients exist\n    if (this._recipients.length === 0) {\n      return {\n        address: '', // Empty address for custom transactions\n        amount: '0',\n      };\n    }\n    return this._recipients[0];\n  }\n\n  /**\n   * Get validated full function name with runtime format checking\n   *\n   * @returns {string} The validated full function name\n   * @throws {Error} If function name format is invalid\n   */\n  private getValidatedFullFunctionName(): `${string}::${string}::${string}` {\n    if (!this._moduleName || !this._functionName) {\n      throw new Error('Module name and function name must be set before building transaction');\n    }\n\n    const fullName = `${this._moduleName}::${this._functionName}`;\n\n    // Runtime validation of the expected format\n    // Supports both hex addresses (SHORT/LONG) and named addresses\n    const fullFunctionPattern =\n      /^(0x[a-fA-F0-9]{1,64}|[a-zA-Z_][a-zA-Z0-9_]*)::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;\n    if (!fullFunctionPattern.test(fullName)) {\n      throw new Error(`Invalid full function name format: \"${fullName}\". Expected format: \"address::module::function\"`);\n    }\n\n    return fullName as `${string}::${string}::${string}`;\n  }\n\n  /**\n   * Validate ABI structure and provide helpful error messages\n   *\n   * @param {EntryFunctionABI} abi - The ABI to validate\n   * @throws {Error} If ABI format is invalid\n   */\n  private validateAbi(abi: EntryFunctionABI): void {\n    if (!abi || typeof abi !== 'object') {\n      throw new Error('ABI must be a valid EntryFunctionABI object');\n    }\n\n    if (!Array.isArray(abi.typeParameters)) {\n      throw new Error('ABI must have a typeParameters array. Use [] if the function has no type parameters');\n    }\n\n    if (!Array.isArray(abi.parameters)) {\n      throw new Error('ABI must have a parameters array containing TypeTag objects for each function parameter');\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customTransaction.js","sourceRoot":"","sources":["../../../../src/lib/transaction/customTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction } from './transaction';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport {\n  EntryFunctionABI,\n  EntryFunctionArgumentTypes,\n  SimpleEntryFunctionArgumentTypes,\n  InputGenerateTransactionPayloadData,\n  TransactionPayload,\n  TransactionPayloadEntryFunction,\n  AccountAddress,\n  TypeTagAddress,\n  TypeTagBool,\n  TypeTagU8,\n  TypeTagU16,\n  TypeTagU32,\n  TypeTagU64,\n  TypeTagU128,\n  TypeTagU256,\n} from '@aptos-labs/ts-sdk';\nimport { CustomTransactionParams } from '../iface';\nimport { validateModuleName, validateFunctionName } from '../utils/validation';\n\n/**\n * Transaction class for custom Aptos transactions.\n */\nexport class CustomTransaction extends Transaction {\n  private _moduleName: string;\n  private _functionName: string;\n  private _typeArguments: string[] = [];\n  private _functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes> = [];\n  private _entryFunctionAbi?: EntryFunctionABI;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._type = TransactionType.CustomTx;\n  }\n\n  /**\n   * Set the custom transaction parameters\n   */\n  setCustomTransactionParams(params: CustomTransactionParams): void {\n    validateModuleName(params.moduleName);\n    validateFunctionName(params.functionName);\n\n    this._moduleName = params.moduleName;\n    this._functionName = params.functionName;\n    this._typeArguments = params.typeArguments || [];\n    this._functionArguments = params.functionArguments || [];\n    this._entryFunctionAbi = params.abi;\n  }\n\n  /**\n   * Set the entry function ABI\n   */\n  setEntryFunctionAbi(abi: EntryFunctionABI): void {\n    this._entryFunctionAbi = abi;\n  }\n\n  /**\n   * Get the full function name\n   */\n  get fullFunctionName(): string {\n    if (!this._moduleName || !this._functionName) {\n      return '';\n    }\n    return `${this._moduleName}::${this._functionName}`;\n  }\n\n  /**\n   * Parse a transaction payload to extract the custom transaction data\n   *\n   * @param {TransactionPayload} payload - The transaction payload to parse\n   */\n  protected parseTransactionPayload(payload: TransactionPayload): void {\n    if (!(payload instanceof TransactionPayloadEntryFunction)) {\n      throw new InvalidTransactionError('Expected entry function payload for custom transaction');\n    }\n\n    const entryFunction = payload.entryFunction;\n\n    // Extract function data\n    const moduleAddress = entryFunction.module_name.address.toString();\n    const moduleIdentifier = entryFunction.module_name.name.identifier;\n    const functionIdentifier = entryFunction.function_name.identifier;\n\n    const moduleName = `${moduleAddress}::${moduleIdentifier}`;\n\n    // Validate\n    validateModuleName(moduleName);\n    validateFunctionName(functionIdentifier);\n\n    this._moduleName = moduleName;\n    this._functionName = functionIdentifier;\n    this._typeArguments = entryFunction.type_args.map((typeArg) => typeArg.toString());\n\n    this._functionArguments = entryFunction.args.map((arg: any) => {\n      if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n        return arg;\n      }\n      if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {\n        const bytes = Array.from(arg.data) as number[];\n        return '0x' + bytes.map((b: number) => b.toString(16).padStart(2, '0')).join('');\n      }\n      return arg;\n    });\n  }\n\n  /**\n   * Generate transaction payload data\n   */\n  protected getTransactionPayloadData(): InputGenerateTransactionPayloadData {\n    const functionName = this.getValidatedFullFunctionName();\n\n    // Convert arguments based on ABI information if available\n    const processedArguments = this._functionArguments.map((arg: any, index: number) => {\n      // Use ABI to identify the expected type for this argument\n      const paramType = this._entryFunctionAbi?.parameters?.[index];\n      if (paramType) {\n        return this.convertArgumentByABI(arg, paramType);\n      }\n\n      // Fallback: basic conversion for common cases\n      if (typeof arg === 'string' && arg.startsWith('0x') && arg.length === 66) {\n        try {\n          return AccountAddress.fromString(arg);\n        } catch {\n          return arg;\n        }\n      }\n      return arg;\n    });\n\n    return {\n      function: functionName,\n      typeArguments: this._typeArguments,\n      functionArguments: processedArguments,\n      abi: this._entryFunctionAbi,\n    } as InputGenerateTransactionPayloadData;\n  }\n\n  /**\n   * Convert argument based on ABI type information\n   */\n  private convertArgumentByABI(arg: any, paramType: any): any {\n    // Helper function to convert bytes to hex string\n    const bytesToHex = (bytes: number[]): string => {\n      return '0x' + bytes.map((b) => b.toString(16).padStart(2, '0')).join('');\n    };\n\n    // Helper function to try converting a hex string to an AccountAddress\n    const tryToAddress = (hexStr: string): any => {\n      try {\n        return AccountAddress.fromString(hexStr);\n      } catch {\n        return hexStr;\n      }\n    };\n\n    // Handle primitive values (string, number, boolean)\n    if (typeof arg === 'string' || typeof arg === 'number' || typeof arg === 'boolean') {\n      // Address conversion for hex strings\n      if (paramType instanceof TypeTagAddress && typeof arg === 'string' && arg.startsWith('0x')) {\n        return tryToAddress(arg);\n      }\n\n      // Type conversions based on parameter type\n      if (paramType instanceof TypeTagBool) return Boolean(arg);\n      if (paramType instanceof TypeTagU8 || paramType instanceof TypeTagU16 || paramType instanceof TypeTagU32)\n        return Number(arg);\n      if (paramType instanceof TypeTagU64 || paramType instanceof TypeTagU128 || paramType instanceof TypeTagU256)\n        return String(arg);\n\n      return arg;\n    }\n\n    // Handle BCS-encoded data with 'data' property\n    if (arg && typeof arg === 'object' && 'data' in arg && arg.data) {\n      const bytes = Array.from(arg.data) as number[];\n      const hexString = bytesToHex(bytes);\n\n      return paramType instanceof TypeTagAddress ? tryToAddress(hexString) : hexString;\n    }\n\n    // Handle nested BCS structures with 'value' property\n    if (arg && typeof arg === 'object' && 'value' in arg && arg.value) {\n      // Simple value wrapper\n      if (!('value' in arg.value) || typeof arg.value.value !== 'object') {\n        return this.convertArgumentByABI(arg.value, paramType);\n      }\n\n      // Double nested structure with numeric keys\n      const bytesObj = arg.value.value;\n      const keys = Object.keys(bytesObj)\n        .filter((k) => !isNaN(parseInt(k, 10)))\n        .sort((a, b) => parseInt(a, 10) - parseInt(b, 10));\n\n      if (keys.length === 0) return arg;\n\n      const bytes = keys.map((k) => bytesObj[k]);\n      let extractedValue: any;\n\n      // Convert bytes based on parameter type\n      if (\n        paramType instanceof TypeTagAddress ||\n        paramType instanceof TypeTagU64 ||\n        paramType instanceof TypeTagU128 ||\n        paramType instanceof TypeTagU256\n      ) {\n        extractedValue = bytesToHex(bytes);\n      } else if (paramType instanceof TypeTagBool) {\n        extractedValue = bytes[0] === 1;\n      } else if (paramType instanceof TypeTagU8 || paramType instanceof TypeTagU16 || paramType instanceof TypeTagU32) {\n        // Convert little-endian bytes to number using the original algorithm\n        // to ensure consistent behavior with large numbers\n        let result = 0;\n        for (let i = bytes.length - 1; i >= 0; i--) {\n          result = result * 256 + bytes[i];\n        }\n        extractedValue = result;\n      } else {\n        extractedValue = bytesToHex(bytes);\n      }\n\n      return this.convertArgumentByABI(extractedValue, paramType);\n    }\n\n    // For anything else, return as-is\n    return arg;\n  }\n\n  /**\n   * Get custom transaction parameters\n   */\n  getCustomTransactionParams(): CustomTransactionParams {\n    return {\n      moduleName: this._moduleName || '',\n      functionName: this._functionName || '',\n      typeArguments: this._typeArguments,\n      functionArguments: this._functionArguments,\n      abi: this._entryFunctionAbi,\n    };\n  }\n\n  /**\n   * Override recipient getter for custom transactions\n   */\n  get recipient(): any {\n    if (this._recipients.length === 0) {\n      return {\n        address: '',\n        amount: '0',\n      };\n    }\n    return this._recipients[0];\n  }\n\n  /**\n   * Get validated full function name\n   */\n  private getValidatedFullFunctionName(): `${string}::${string}::${string}` {\n    if (!this._moduleName || !this._functionName) {\n      throw new Error('Module name and function name must be set before building transaction');\n    }\n\n    const fullName = `${this._moduleName}::${this._functionName}`;\n\n    // Basic validation\n    const fullFunctionPattern =\n      /^(0x[a-fA-F0-9]{1,64}|[a-zA-Z_][a-zA-Z0-9_]*)::[a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_]*$/;\n    if (!fullFunctionPattern.test(fullName)) {\n      throw new Error(`Invalid full function name format: \"${fullName}\". Expected format: \"address::module::function\"`);\n    }\n\n    return fullName as `${string}::${string}::${string}`;\n  }\n}\n"]}

package/dist/src/lib/transactionBuilderFactory.d.ts

@@ -10,7 +10,7 @@ import { CustomTransactionBuilder } from './transactionBuilder/customTransaction
 export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     constructor(_coinConfig: Readonly<CoinConfig>);
     /** @inheritdoc */
-    from(signedRawTxn: string): TransactionBuilder;
+    from(signedRawTxn: string, abi?: any): TransactionBuilder;
     getTransactionTypeFromSignedTxn(signedTxn: SignedTransaction): TransactionType;
     /** @inheritdoc */
     getTransferBuilder(tx?: Transaction): TransferBuilder;

package/dist/src/lib/transactionBuilderFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC/G,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAC;AAEjG,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AAE/F,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AAEzF,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,kBAAkB;IA8B9C,+BAA+B,CAAC,SAAS,EAAE,iBAAiB,GAAG,eAAe;IAK9E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,kCAAkC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,4BAA4B;IAIlF,kBAAkB;IAClB,iCAAiC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAIhF;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;IAItC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;CAM1B"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC/G,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,mDAAmD,CAAC;AAEjG,OAAO,EAAE,2BAA2B,EAAE,MAAM,kDAAkD,CAAC;AAE/F,OAAO,EAAE,wBAAwB,EAAE,MAAM,+CAA+C,CAAC;AAEzF,qBAAa,yBAA0B,SAAQ,6BAA6B;gBAC9D,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,kBAAkB;IAiCzD,+BAA+B,CAAC,SAAS,EAAE,iBAAiB,GAAG,eAAe;IAK9E,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,eAAe;IAIrD,kBAAkB;IAClB,kCAAkC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,4BAA4B;IAIlF,kBAAkB;IAClB,iCAAiC,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,2BAA2B;IAIhF;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,CAAC,EAAE,WAAW,GAAG,wBAAwB;IAIvE,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;IAItC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;CAM1B"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -20,7 +20,7 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
         super(_coinConfig);
     }
     /** @inheritdoc */
-    from(signedRawTxn) {
+    from(signedRawTxn, abi) {
         try {
             const signedTxn = transaction_1.Transaction.deserializeSignedTransaction(signedRawTxn);
             const txnType = this.getTransactionTypeFromSignedTxn(signedTxn);
@@ -39,6 +39,9 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
                     return this.getDigitalAssetTransactionBuilder(digitalAssetTransferTx);
                 case sdk_core_1.TransactionType.CustomTx:
                     const customTx = new customTransaction_1.CustomTransaction(this._coinConfig);
+                    if (abi) {
+                        customTx.setEntryFunctionAbi(abi);
+                    }
                     customTx.fromDeserializedSignedTransaction(signedTxn);
                     return this.getCustomTransactionBuilder(customTx);
                 default:
@@ -93,4 +96,4 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder/transactionBuilder';\nimport { TransferBuilder } from './transactionBuilder/transferBuilder';\nimport utils from './utils';\nimport { Transaction } from './transaction/transaction';\nimport { SignedTransaction } from '@aptos-labs/ts-sdk';\nimport { TransferTransaction } from './transaction/transferTransaction';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { FungibleAssetTransfer } from './transaction/fungibleAssetTransfer';\nimport { FungibleAssetTransferBuilder } from './transactionBuilder/fungibleAssetTransferBuilder';\nimport { DigitalAssetTransfer } from './transaction/digitalAssetTransfer';\nimport { DigitalAssetTransferBuilder } from './transactionBuilder/digitalAssetTransferBuilder';\nimport { CustomTransaction } from './transaction/customTransaction';\nimport { CustomTransactionBuilder } from './transactionBuilder/customTransactionBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  from(signedRawTxn: string): TransactionBuilder {\n    try {\n      const signedTxn = Transaction.deserializeSignedTransaction(signedRawTxn);\n      const txnType = this.getTransactionTypeFromSignedTxn(signedTxn);\n\n      switch (txnType) {\n        case TransactionType.Send:\n          const transferTx = new TransferTransaction(this._coinConfig);\n          transferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getTransferBuilder(transferTx);\n        case TransactionType.SendToken:\n          const fungibleTransferTokenTx = new FungibleAssetTransfer(this._coinConfig);\n          fungibleTransferTokenTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getFungibleAssetTransactionBuilder(fungibleTransferTokenTx);\n        case TransactionType.SendNFT:\n          const digitalAssetTransferTx = new DigitalAssetTransfer(this._coinConfig);\n          digitalAssetTransferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getDigitalAssetTransactionBuilder(digitalAssetTransferTx);\n        case TransactionType.CustomTx:\n          const customTx = new CustomTransaction(this._coinConfig);\n          customTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getCustomTransactionBuilder(customTx);\n        default:\n          throw new InvalidTransactionError('Invalid transaction');\n      }\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  getTransactionTypeFromSignedTxn(signedTxn: SignedTransaction): TransactionType {\n    const rawTxn = signedTxn.raw_txn;\n    return utils.getTransactionTypeFromTransactionPayload(rawTxn.payload);\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getFungibleAssetTransactionBuilder(tx?: Transaction): FungibleAssetTransferBuilder {\n    return this.initializeBuilder(tx, new FungibleAssetTransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getDigitalAssetTransactionBuilder(tx?: Transaction): DigitalAssetTransferBuilder {\n    return this.initializeBuilder(tx, new DigitalAssetTransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Get a custom transaction builder\n   *\n   * @param tx - Optional transaction to initialize the builder with\n   * @returns A custom transaction builder\n   */\n  getCustomTransactionBuilder(tx?: Transaction): CustomTransactionBuilder {\n    return this.initializeBuilder(tx, new CustomTransactionBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): void {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Initialize the builder with the given transaction\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @param {TransactionBuilder} builder - the builder to be initialized\n   * @returns {TransactionBuilder} the builder initialized\n   */\n  private initializeBuilder<T extends TransactionBuilder>(tx: Transaction | undefined, builder: T): T {\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransactionBuilderFactory, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilder } from './transactionBuilder/transactionBuilder';\nimport { TransferBuilder } from './transactionBuilder/transferBuilder';\nimport utils from './utils';\nimport { Transaction } from './transaction/transaction';\nimport { SignedTransaction } from '@aptos-labs/ts-sdk';\nimport { TransferTransaction } from './transaction/transferTransaction';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { FungibleAssetTransfer } from './transaction/fungibleAssetTransfer';\nimport { FungibleAssetTransferBuilder } from './transactionBuilder/fungibleAssetTransferBuilder';\nimport { DigitalAssetTransfer } from './transaction/digitalAssetTransfer';\nimport { DigitalAssetTransferBuilder } from './transactionBuilder/digitalAssetTransferBuilder';\nimport { CustomTransaction } from './transaction/customTransaction';\nimport { CustomTransactionBuilder } from './transactionBuilder/customTransactionBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  from(signedRawTxn: string, abi?: any): TransactionBuilder {\n    try {\n      const signedTxn = Transaction.deserializeSignedTransaction(signedRawTxn);\n      const txnType = this.getTransactionTypeFromSignedTxn(signedTxn);\n\n      switch (txnType) {\n        case TransactionType.Send:\n          const transferTx = new TransferTransaction(this._coinConfig);\n          transferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getTransferBuilder(transferTx);\n        case TransactionType.SendToken:\n          const fungibleTransferTokenTx = new FungibleAssetTransfer(this._coinConfig);\n          fungibleTransferTokenTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getFungibleAssetTransactionBuilder(fungibleTransferTokenTx);\n        case TransactionType.SendNFT:\n          const digitalAssetTransferTx = new DigitalAssetTransfer(this._coinConfig);\n          digitalAssetTransferTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getDigitalAssetTransactionBuilder(digitalAssetTransferTx);\n        case TransactionType.CustomTx:\n          const customTx = new CustomTransaction(this._coinConfig);\n          if (abi) {\n            customTx.setEntryFunctionAbi(abi);\n          }\n          customTx.fromDeserializedSignedTransaction(signedTxn);\n          return this.getCustomTransactionBuilder(customTx);\n        default:\n          throw new InvalidTransactionError('Invalid transaction');\n      }\n    } catch (e) {\n      throw e;\n    }\n  }\n\n  getTransactionTypeFromSignedTxn(signedTxn: SignedTransaction): TransactionType {\n    const rawTxn = signedTxn.raw_txn;\n    return utils.getTransactionTypeFromTransactionPayload(rawTxn.payload);\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(tx?: Transaction): TransferBuilder {\n    return this.initializeBuilder(tx, new TransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getFungibleAssetTransactionBuilder(tx?: Transaction): FungibleAssetTransferBuilder {\n    return this.initializeBuilder(tx, new FungibleAssetTransferBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getDigitalAssetTransactionBuilder(tx?: Transaction): DigitalAssetTransferBuilder {\n    return this.initializeBuilder(tx, new DigitalAssetTransferBuilder(this._coinConfig));\n  }\n\n  /**\n   * Get a custom transaction builder\n   *\n   * @param tx - Optional transaction to initialize the builder with\n   * @returns A custom transaction builder\n   */\n  getCustomTransactionBuilder(tx?: Transaction): CustomTransactionBuilder {\n    return this.initializeBuilder(tx, new CustomTransactionBuilder(this._coinConfig));\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): void {\n    throw new Error('Method not implemented.');\n  }\n\n  /**\n   * Initialize the builder with the given transaction\n   *\n   * @param {Transaction | undefined} tx - the transaction used to initialize the builder\n   * @param {TransactionBuilder} builder - the builder to be initialized\n   * @returns {TransactionBuilder} the builder initialized\n   */\n  private initializeBuilder<T extends TransactionBuilder>(tx: Transaction | undefined, builder: T): T {\n    if (tx) {\n      builder.initBuilder(tx);\n    }\n    return builder;\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo-beta/sdk-coin-apt",
-  "version": "1.0.0-alpha.162",
+  "version": "1.0.0-alpha.164",
   "description": "BitGo SDK coin library for APT (Aptos) coin",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -41,15 +41,15 @@
   },
   "dependencies": {
     "@aptos-labs/ts-sdk": "1.33.1",
-    "@bitgo-beta/sdk-core": "2.4.1-alpha.392",
-    "@bitgo-beta/statics": "10.0.1-alpha.392",
+    "@bitgo-beta/sdk-core": "2.4.1-alpha.394",
+    "@bitgo-beta/statics": "10.0.1-alpha.394",
     "bignumber.js": "^9.1.2",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@bitgo-beta/sdk-api": "1.6.1-alpha.392",
-    "@bitgo-beta/sdk-lib-mpc": "8.2.1-alpha.348",
+    "@bitgo-beta/sdk-api": "1.6.1-alpha.394",
+    "@bitgo-beta/sdk-lib-mpc": "8.2.1-alpha.350",
     "@bitgo-beta/sdk-test": "^9.0.9"
   },
-  "gitHead": "a4c7e4835abf6b68cdbe5360fa65216746b057e7"
+  "gitHead": "1d190dc61a8bd89f189b657ffe4991263c648805"
 }