@bitgo-beta/sdk-coin-tempo 1.0.1-beta.31 → 1.0.1-beta.310

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,408 @@
+"use strict";
+/**
+ * TIP-20 Transaction Builder
+ *
+ * Unified builder for TIP-20 transactions supporting:
+ * - Single or batch operations
+ * - Per-operation memos for tracking
+ * - Custom fee token selection
+ * - EIP-7702 Account Abstraction (type 0x76)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20TransactionBuilder = void 0;
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ethers_1 = require("ethers");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const tip20Abi_1 = require("./tip20Abi");
+const constants_1 = require("./constants");
+/**
+ * Transaction Builder for TIP-20 tokens on Tempo blockchain
+ * Extends abstract-eth TransactionBuilder with Tempo-specific features
+ */
+class Tip20TransactionBuilder extends abstract_eth_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.operations = [];
+        this.rawCalls = [];
+    }
+    /**
+     * Implement the transfer method from abstract class
+     * Note: For TIP-20 transactions, use addOperation() instead
+     */
+    transfer(data, isFirstSigner) {
+        const transferBuilder = new abstract_eth_1.TransferBuilder(undefined, isFirstSigner);
+        if (data) {
+            transferBuilder.data(data);
+        }
+        this._transfer = transferBuilder;
+        return transferBuilder;
+    }
+    /**
+     * Validate the transaction has all required fields for Tempo AA transactions.
+     * Overrides parent class validation since AA transactions use a different model
+     * (operations-based rather than single contract address).
+     *
+     * @throws BuildTransactionError if validation fails
+     */
+    validateTransaction() {
+        if (this.operations.length === 0 && this.rawCalls.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('At least one operation or raw call is required to build a transaction');
+        }
+        if (this._nonce === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Nonce is required to build a transaction');
+        }
+        if (this._gas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Gas limit is required to build a transaction');
+        }
+        if (this._maxFeePerGas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('maxFeePerGas is required to build a transaction');
+        }
+        if (this._maxPriorityFeePerGas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('maxPriorityFeePerGas is required to build a transaction');
+        }
+    }
+    /** @inheritdoc */
+    validateRawTransaction(rawTransaction) {
+        if (typeof rawTransaction === 'string' && (0, utils_1.isTip20Transaction)(rawTransaction)) {
+            try {
+                ethers_1.ethers.utils.RLP.decode('0x' + rawTransaction.slice(4));
+                return;
+            }
+            catch (e) {
+                throw new sdk_core_1.ParseTransactionError(`Failed to RLP decode TIP-20 transaction: ${e}`);
+            }
+        }
+        super.validateRawTransaction(rawTransaction);
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction, isFirstSigner) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Raw transaction is empty');
+        }
+        if ((0, utils_1.isTip20Transaction)(rawTransaction)) {
+            return this.fromTip20Transaction(rawTransaction);
+        }
+        return super.fromImplementation(rawTransaction, isFirstSigner);
+    }
+    /**
+     * Deserialize a type 0x76 transaction and restore builder state.
+     * RLP field layout mirrors buildBaseRlpData() in transaction.ts.
+     */
+    fromTip20Transaction(rawTransaction) {
+        try {
+            const rlpHex = '0x' + rawTransaction.slice(4);
+            const decoded = ethers_1.ethers.utils.RLP.decode(rlpHex);
+            if (!Array.isArray(decoded) || decoded.length < 13) {
+                throw new sdk_core_1.ParseTransactionError('Invalid TIP-20 transaction: unexpected RLP structure');
+            }
+            const parseBigInt = (hex) => (!hex || hex === '0x' ? 0n : BigInt(hex));
+            const parseHexInt = (hex) => (!hex || hex === '0x' ? 0 : parseInt(hex, 16));
+            const chainId = parseHexInt(decoded[0]);
+            const maxPriorityFeePerGas = parseBigInt(decoded[1]);
+            const maxFeePerGas = parseBigInt(decoded[2]);
+            const gas = parseBigInt(decoded[3]);
+            const callsTuples = decoded[4];
+            const nonce = parseHexInt(decoded[7]);
+            const feeTokenRaw = decoded[10];
+            const calls = callsTuples.map((tuple) => ({
+                to: tuple[0],
+                value: parseBigInt(tuple[1]),
+                data: tuple[2],
+            }));
+            const operations = [];
+            const decodedRawCalls = [];
+            for (const call of calls) {
+                const op = this.decodeCallToOperation(call);
+                if (op !== null) {
+                    operations.push(op);
+                }
+                else {
+                    decodedRawCalls.push({ to: call.to, data: call.data, value: call.value.toString() });
+                }
+            }
+            let signature;
+            if (decoded.length >= 14 && decoded[13] && decoded[13].length > 2) {
+                const sigBytes = ethers_1.ethers.utils.arrayify(decoded[13]);
+                if (sigBytes.length === 65) {
+                    const r = ethers_1.ethers.utils.hexlify(sigBytes.slice(0, 32));
+                    const s = ethers_1.ethers.utils.hexlify(sigBytes.slice(32, 64));
+                    const v = sigBytes[64];
+                    const yParity = v > 1 ? v - 27 : v;
+                    signature = { r, s, yParity };
+                }
+            }
+            const feeToken = feeTokenRaw && feeTokenRaw !== '0x' ? feeTokenRaw : undefined;
+            const txRequest = {
+                type: constants_1.AA_TRANSACTION_TYPE,
+                chainId,
+                nonce,
+                maxFeePerGas,
+                maxPriorityFeePerGas,
+                gas,
+                calls,
+                accessList: [],
+                feeToken,
+            };
+            this._nonce = nonce;
+            this._gas = gas;
+            this._maxFeePerGas = maxFeePerGas;
+            this._maxPriorityFeePerGas = maxPriorityFeePerGas;
+            this._feeToken = feeToken;
+            this.operations = operations;
+            this.rawCalls = decodedRawCalls;
+            this._restoredSignature = signature;
+            const tx = new transaction_1.Tip20Transaction(this._coinConfig, txRequest, operations, decodedRawCalls);
+            if (signature) {
+                tx.setSignature(signature);
+            }
+            return tx;
+        }
+        catch (e) {
+            if (e instanceof sdk_core_1.ParseTransactionError)
+                throw e;
+            throw new sdk_core_1.ParseTransactionError(`Failed to deserialize TIP-20 transaction: ${e}`);
+        }
+    }
+    /**
+     * Decode a single AA call's data back into a Tip20Operation.
+     * Returns null if the call is not a transferWithMemo — it will be stored as a RawContractCall instead.
+     * This preserves calldata fidelity for arbitrary smart contract interactions.
+     */
+    decodeCallToOperation(call) {
+        const iface = new ethers_1.ethers.utils.Interface(tip20Abi_1.TIP20_TRANSFER_WITH_MEMO_ABI);
+        try {
+            const decoded = iface.decodeFunctionData('transferWithMemo', call.data);
+            const toAddress = decoded[0];
+            const amountUnits = BigInt(decoded[1].toString());
+            const memoBytes32 = decoded[2];
+            const amount = (0, utils_1.tip20UnitsToAmount)(amountUnits);
+            const stripped = ethers_1.ethers.utils.stripZeros(memoBytes32);
+            const memo = stripped.length > 0 ? ethers_1.ethers.utils.toUtf8String(stripped) : undefined;
+            return { token: call.to, to: toAddress, amount, memo };
+        }
+        catch {
+            // Not a transferWithMemo call — caller will store as RawContractCall
+            return null;
+        }
+    }
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters.
+     * Signs with _sourceKeyPair if it has been set via sign({ key }).
+     */
+    async buildImplementation() {
+        if (this._nonce === undefined ||
+            this._gas === undefined ||
+            this._maxFeePerGas === undefined ||
+            this._maxPriorityFeePerGas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Transaction validation failed: missing required fields');
+        }
+        this.fee({
+            fee: this._maxFeePerGas.toString(),
+            gasLimit: this._gas.toString(),
+            eip1559: {
+                maxFeePerGas: this._maxFeePerGas.toString(),
+                maxPriorityFeePerGas: this._maxPriorityFeePerGas.toString(),
+            },
+        });
+        const calls = this.operations.map((op) => this.operationToCall(op));
+        for (const rawCall of this.rawCalls) {
+            calls.push({
+                to: rawCall.to,
+                data: rawCall.data,
+                value: rawCall.value ? BigInt(rawCall.value) : 0n,
+            });
+        }
+        const txRequest = {
+            type: constants_1.AA_TRANSACTION_TYPE,
+            chainId: this._common.chainIdBN().toNumber(),
+            nonce: this._nonce,
+            maxFeePerGas: this._maxFeePerGas,
+            maxPriorityFeePerGas: this._maxPriorityFeePerGas,
+            gas: this._gas,
+            calls,
+            accessList: [],
+            feeToken: this._feeToken,
+        };
+        const tx = new transaction_1.Tip20Transaction(this._coinConfig, txRequest, this.operations, this.rawCalls);
+        if (this._sourceKeyPair && this._sourceKeyPair.getKeys().prv) {
+            const prv = this._sourceKeyPair.getKeys().prv;
+            const unsignedHex = await tx.serialize();
+            const msgHash = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.arrayify(unsignedHex));
+            const signingKey = new ethers_1.ethers.utils.SigningKey('0x' + prv);
+            const sig = signingKey.signDigest(ethers_1.ethers.utils.arrayify(msgHash));
+            tx.setSignature({
+                r: sig.r,
+                s: sig.s,
+                yParity: sig.recoveryParam ?? 0,
+            });
+        }
+        else if (this._restoredSignature) {
+            tx.setSignature(this._restoredSignature);
+        }
+        return tx;
+    }
+    /**
+     * Add a single operation to the transaction
+     * Can be called multiple times to create batch transactions
+     *
+     * @param operation - TIP-20 operation with token, recipient, amount, and optional memo
+     * @returns this builder instance for chaining
+     */
+    addOperation(operation) {
+        this.validateOperation(operation);
+        this.operations.push(operation);
+        return this;
+    }
+    /**
+     * Add a raw smart contract call with pre-encoded calldata
+     * Use this for arbitrary contract interactions where the UI provides ABI-encoded calldata
+     *
+     * @param call - Raw contract call with target address and pre-encoded calldata
+     * @returns this builder instance for chaining
+     */
+    addRawCall(call) {
+        if (!(0, utils_1.isValidAddress)(call.to)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid contract address: ${call.to}`);
+        }
+        if (!(0, utils_1.isValidHexData)(call.data)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid calldata: must be a non-empty 0x-prefixed hex string with even length`);
+        }
+        if (call.value !== undefined) {
+            try {
+                const v = BigInt(call.value);
+                if (v < 0n)
+                    throw new Error();
+            }
+            catch {
+                throw new sdk_core_1.BuildTransactionError(`Invalid value: must be a non-negative integer string`);
+            }
+        }
+        this.rawCalls.push(call);
+        return this;
+    }
+    /**
+     * Get all raw contract calls in this transaction
+     * @returns Array of raw contract calls
+     */
+    getRawCalls() {
+        return [...this.rawCalls];
+    }
+    /**
+     * Set which TIP-20 token will be used to pay transaction fees
+     * This is a global setting for the entire transaction
+     *
+     * @param tokenAddress - Address of the TIP-20 token to use for fees
+     * @returns this builder instance for chaining
+     */
+    feeToken(tokenAddress) {
+        if (!(0, utils_1.isValidAddress)(tokenAddress)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid fee token address: ${tokenAddress}`);
+        }
+        this._feeToken = tokenAddress;
+        return this;
+    }
+    /**
+     * Set the transaction nonce
+     *
+     * @param nonce - Transaction nonce
+     * @returns this builder instance for chaining
+     */
+    nonce(nonce) {
+        if (nonce < 0) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid nonce: ${nonce}`);
+        }
+        this._nonce = nonce;
+        return this;
+    }
+    /**
+     * Set the gas limit for the transaction
+     *
+     * @param gas - Gas limit
+     * @returns this builder instance for chaining
+     */
+    gas(gas) {
+        const gasValue = typeof gas === 'string' ? BigInt(gas) : gas;
+        if (gasValue <= 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid gas limit: ${gas}`);
+        }
+        this._gas = gasValue;
+        return this;
+    }
+    /**
+     * Set the maximum fee per gas (EIP-1559)
+     *
+     * @param maxFeePerGas - Maximum fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxFeePerGas(maxFeePerGas) {
+        const feeValue = typeof maxFeePerGas === 'string' ? BigInt(maxFeePerGas) : maxFeePerGas;
+        if (feeValue < 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid maxFeePerGas: ${maxFeePerGas}`);
+        }
+        this._maxFeePerGas = feeValue;
+        return this;
+    }
+    /**
+     * Set the maximum priority fee per gas (EIP-1559)
+     *
+     * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxPriorityFeePerGas(maxPriorityFeePerGas) {
+        const feeValue = typeof maxPriorityFeePerGas === 'string' ? BigInt(maxPriorityFeePerGas) : maxPriorityFeePerGas;
+        if (feeValue < 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid maxPriorityFeePerGas: ${maxPriorityFeePerGas}`);
+        }
+        this._maxPriorityFeePerGas = feeValue;
+        return this;
+    }
+    /**
+     * Get all operations in this transaction
+     * @returns Array of TIP-20 operations
+     */
+    getOperations() {
+        return [...this.operations];
+    }
+    /**
+     * Get the fee token address if set
+     * @returns Fee token address or undefined
+     */
+    getFeeToken() {
+        return this._feeToken;
+    }
+    /**
+     * Validate a single operation
+     * @param operation - Operation to validate
+     * @throws BuildTransactionError if invalid
+     */
+    validateOperation(operation) {
+        if (!(0, utils_1.isValidAddress)(operation.token)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid token address: ${operation.token}`);
+        }
+        if (!(0, utils_1.isValidAddress)(operation.to)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid recipient address: ${operation.to}`);
+        }
+        if (!(0, utils_1.isValidTip20Amount)(operation.amount)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid amount: ${operation.amount}`);
+        }
+        if (operation.memo !== undefined && !(0, utils_1.isValidMemoId)(operation.memo)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid memo: must be a non-negative integer`);
+        }
+    }
+    /**
+     * Convert a TIP-20 operation to an AA call
+     */
+    operationToCall(op) {
+        const amountInUnits = (0, utils_1.amountToTip20Units)(op.amount);
+        const data = (0, utils_1.encodeTip20TransferWithMemo)(op.to, amountInUnits, op.memo);
+        return {
+            to: op.token,
+            data,
+            value: 0n,
+        };
+    }
+}
+exports.Tip20TransactionBuilder = Tip20TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TIP-20 Transaction Builder\n *\n * Unified builder for TIP-20 transactions supporting:\n * - Single or batch operations\n * - Per-operation memos for tracking\n * - Custom fee token selection\n * - EIP-7702 Account Abstraction (type 0x76)\n */\n\nimport {\n  Transaction as EthTransaction,\n  TransactionBuilder as AbstractTransactionBuilder,\n  TransferBuilder,\n} from '@bitgo-beta/abstract-eth';\nimport {\n  BaseTransaction,\n  BuildTransactionError,\n  InvalidTransactionError,\n  ParseTransactionError,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { ethers } from 'ethers';\nimport { Address, Hex, RawContractCall, Tip20Operation } from './types';\nimport { Tip20Transaction, Tip20TransactionRequest } from './transaction';\nimport {\n  amountToTip20Units,\n  encodeTip20TransferWithMemo,\n  isTip20Transaction,\n  isValidAddress,\n  isValidHexData,\n  isValidMemoId,\n  isValidTip20Amount,\n  tip20UnitsToAmount,\n} from './utils';\nimport { TIP20_TRANSFER_WITH_MEMO_ABI } from './tip20Abi';\nimport { AA_TRANSACTION_TYPE } from './constants';\n\n/**\n * Transaction Builder for TIP-20 tokens on Tempo blockchain\n * Extends abstract-eth TransactionBuilder with Tempo-specific features\n */\nexport class Tip20TransactionBuilder extends AbstractTransactionBuilder {\n  private operations: Tip20Operation[] = [];\n  private rawCalls: RawContractCall[] = [];\n  private _feeToken?: Address;\n  private _nonce?: number;\n  private _gas?: bigint;\n  private _maxFeePerGas?: bigint;\n  private _maxPriorityFeePerGas?: bigint;\n  private _restoredSignature?: { r: Hex; s: Hex; yParity: number };\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Implement the transfer method from abstract class\n   * Note: For TIP-20 transactions, use addOperation() instead\n   */\n  transfer(data?: string, isFirstSigner?: boolean): TransferBuilder {\n    const transferBuilder = new TransferBuilder(undefined, isFirstSigner);\n    if (data) {\n      transferBuilder.data(data);\n    }\n    this._transfer = transferBuilder;\n    return transferBuilder;\n  }\n\n  /**\n   * Validate the transaction has all required fields for Tempo AA transactions.\n   * Overrides parent class validation since AA transactions use a different model\n   * (operations-based rather than single contract address).\n   *\n   * @throws BuildTransactionError if validation fails\n   */\n  validateTransaction(): void {\n    if (this.operations.length === 0 && this.rawCalls.length === 0) {\n      throw new BuildTransactionError('At least one operation or raw call is required to build a transaction');\n    }\n\n    if (this._nonce === undefined) {\n      throw new BuildTransactionError('Nonce is required to build a transaction');\n    }\n\n    if (this._gas === undefined) {\n      throw new BuildTransactionError('Gas limit is required to build a transaction');\n    }\n\n    if (this._maxFeePerGas === undefined) {\n      throw new BuildTransactionError('maxFeePerGas is required to build a transaction');\n    }\n\n    if (this._maxPriorityFeePerGas === undefined) {\n      throw new BuildTransactionError('maxPriorityFeePerGas is required to build a transaction');\n    }\n  }\n\n  /** @inheritdoc */\n  validateRawTransaction(rawTransaction: any): void {\n    if (typeof rawTransaction === 'string' && isTip20Transaction(rawTransaction)) {\n      try {\n        ethers.utils.RLP.decode('0x' + rawTransaction.slice(4));\n        return;\n      } catch (e) {\n        throw new ParseTransactionError(`Failed to RLP decode TIP-20 transaction: ${e}`);\n      }\n    }\n    super.validateRawTransaction(rawTransaction);\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string, isFirstSigner?: boolean): EthTransaction {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Raw transaction is empty');\n    }\n    if (isTip20Transaction(rawTransaction)) {\n      return this.fromTip20Transaction(rawTransaction) as unknown as EthTransaction;\n    }\n    return super.fromImplementation(rawTransaction, isFirstSigner);\n  }\n\n  /**\n   * Deserialize a type 0x76 transaction and restore builder state.\n   * RLP field layout mirrors buildBaseRlpData() in transaction.ts.\n   */\n  private fromTip20Transaction(rawTransaction: string): Tip20Transaction {\n    try {\n      const rlpHex = '0x' + rawTransaction.slice(4);\n      const decoded = ethers.utils.RLP.decode(rlpHex) as any[];\n\n      if (!Array.isArray(decoded) || decoded.length < 13) {\n        throw new ParseTransactionError('Invalid TIP-20 transaction: unexpected RLP structure');\n      }\n\n      const parseBigInt = (hex: string): bigint => (!hex || hex === '0x' ? 0n : BigInt(hex));\n      const parseHexInt = (hex: string): number => (!hex || hex === '0x' ? 0 : parseInt(hex, 16));\n\n      const chainId = parseHexInt(decoded[0] as string);\n      const maxPriorityFeePerGas = parseBigInt(decoded[1] as string);\n      const maxFeePerGas = parseBigInt(decoded[2] as string);\n      const gas = parseBigInt(decoded[3] as string);\n      const callsTuples = decoded[4] as string[][];\n      const nonce = parseHexInt(decoded[7] as string);\n      const feeTokenRaw = decoded[10] as string;\n\n      const calls: { to: Address; data: Hex; value: bigint }[] = callsTuples.map((tuple) => ({\n        to: tuple[0] as Address,\n        value: parseBigInt(tuple[1] as string),\n        data: tuple[2] as Hex,\n      }));\n\n      const operations: Tip20Operation[] = [];\n      const decodedRawCalls: RawContractCall[] = [];\n      for (const call of calls) {\n        const op = this.decodeCallToOperation(call);\n        if (op !== null) {\n          operations.push(op);\n        } else {\n          decodedRawCalls.push({ to: call.to, data: call.data, value: call.value.toString() });\n        }\n      }\n\n      let signature: { r: Hex; s: Hex; yParity: number } | undefined;\n      if (decoded.length >= 14 && decoded[13] && (decoded[13] as string).length > 2) {\n        const sigBytes = ethers.utils.arrayify(decoded[13] as string);\n        if (sigBytes.length === 65) {\n          const r = ethers.utils.hexlify(sigBytes.slice(0, 32)) as Hex;\n          const s = ethers.utils.hexlify(sigBytes.slice(32, 64)) as Hex;\n          const v = sigBytes[64];\n          const yParity = v > 1 ? v - 27 : v;\n          signature = { r, s, yParity };\n        }\n      }\n\n      const feeToken = feeTokenRaw && feeTokenRaw !== '0x' ? (feeTokenRaw as Address) : undefined;\n\n      const txRequest: Tip20TransactionRequest = {\n        type: AA_TRANSACTION_TYPE,\n        chainId,\n        nonce,\n        maxFeePerGas,\n        maxPriorityFeePerGas,\n        gas,\n        calls,\n        accessList: [],\n        feeToken,\n      };\n\n      this._nonce = nonce;\n      this._gas = gas;\n      this._maxFeePerGas = maxFeePerGas;\n      this._maxPriorityFeePerGas = maxPriorityFeePerGas;\n      this._feeToken = feeToken;\n      this.operations = operations;\n      this.rawCalls = decodedRawCalls;\n      this._restoredSignature = signature;\n\n      const tx = new Tip20Transaction(this._coinConfig, txRequest, operations, decodedRawCalls);\n      if (signature) {\n        tx.setSignature(signature);\n      }\n      return tx;\n    } catch (e) {\n      if (e instanceof ParseTransactionError) throw e;\n      throw new ParseTransactionError(`Failed to deserialize TIP-20 transaction: ${e}`);\n    }\n  }\n\n  /**\n   * Decode a single AA call's data back into a Tip20Operation.\n   * Returns null if the call is not a transferWithMemo — it will be stored as a RawContractCall instead.\n   * This preserves calldata fidelity for arbitrary smart contract interactions.\n   */\n  private decodeCallToOperation(call: { to: Address; data: Hex; value: bigint }): Tip20Operation | null {\n    const iface = new ethers.utils.Interface(TIP20_TRANSFER_WITH_MEMO_ABI);\n    try {\n      const decoded = iface.decodeFunctionData('transferWithMemo', call.data);\n      const toAddress = decoded[0] as string;\n      const amountUnits = BigInt(decoded[1].toString());\n      const memoBytes32 = decoded[2] as string;\n\n      const amount = tip20UnitsToAmount(amountUnits);\n\n      const stripped = ethers.utils.stripZeros(memoBytes32);\n      const memo = stripped.length > 0 ? ethers.utils.toUtf8String(stripped) : undefined;\n\n      return { token: call.to, to: toAddress, amount, memo };\n    } catch {\n      // Not a transferWithMemo call — caller will store as RawContractCall\n      return null;\n    }\n  }\n\n  /**\n   * Build the transaction from configured TIP-20 operations and transaction parameters.\n   * Signs with _sourceKeyPair if it has been set via sign({ key }).\n   */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    if (\n      this._nonce === undefined ||\n      this._gas === undefined ||\n      this._maxFeePerGas === undefined ||\n      this._maxPriorityFeePerGas === undefined\n    ) {\n      throw new BuildTransactionError('Transaction validation failed: missing required fields');\n    }\n\n    this.fee({\n      fee: this._maxFeePerGas.toString(),\n      gasLimit: this._gas.toString(),\n      eip1559: {\n        maxFeePerGas: this._maxFeePerGas.toString(),\n        maxPriorityFeePerGas: this._maxPriorityFeePerGas.toString(),\n      },\n    });\n\n    const calls = this.operations.map((op) => this.operationToCall(op));\n\n    for (const rawCall of this.rawCalls) {\n      calls.push({\n        to: rawCall.to as Address,\n        data: rawCall.data as Hex,\n        value: rawCall.value ? BigInt(rawCall.value) : 0n,\n      });\n    }\n\n    const txRequest: Tip20TransactionRequest = {\n      type: AA_TRANSACTION_TYPE,\n      chainId: this._common.chainIdBN().toNumber(),\n      nonce: this._nonce,\n      maxFeePerGas: this._maxFeePerGas,\n      maxPriorityFeePerGas: this._maxPriorityFeePerGas,\n      gas: this._gas,\n      calls,\n      accessList: [],\n      feeToken: this._feeToken,\n    };\n\n    const tx = new Tip20Transaction(this._coinConfig, txRequest, this.operations, this.rawCalls);\n\n    if (this._sourceKeyPair && this._sourceKeyPair.getKeys().prv) {\n      const prv = this._sourceKeyPair.getKeys().prv!;\n      const unsignedHex = await tx.serialize();\n      const msgHash = ethers.utils.keccak256(ethers.utils.arrayify(unsignedHex));\n      const signingKey = new ethers.utils.SigningKey('0x' + prv);\n      const sig = signingKey.signDigest(ethers.utils.arrayify(msgHash));\n      tx.setSignature({\n        r: sig.r as Hex,\n        s: sig.s as Hex,\n        yParity: sig.recoveryParam ?? 0,\n      });\n    } else if (this._restoredSignature) {\n      tx.setSignature(this._restoredSignature);\n    }\n\n    return tx;\n  }\n\n  /**\n   * Add a single operation to the transaction\n   * Can be called multiple times to create batch transactions\n   *\n   * @param operation - TIP-20 operation with token, recipient, amount, and optional memo\n   * @returns this builder instance for chaining\n   */\n  addOperation(operation: Tip20Operation): this {\n    this.validateOperation(operation);\n    this.operations.push(operation);\n    return this;\n  }\n\n  /**\n   * Add a raw smart contract call with pre-encoded calldata\n   * Use this for arbitrary contract interactions where the UI provides ABI-encoded calldata\n   *\n   * @param call - Raw contract call with target address and pre-encoded calldata\n   * @returns this builder instance for chaining\n   */\n  addRawCall(call: RawContractCall): this {\n    if (!isValidAddress(call.to)) {\n      throw new BuildTransactionError(`Invalid contract address: ${call.to}`);\n    }\n    if (!isValidHexData(call.data)) {\n      throw new BuildTransactionError(`Invalid calldata: must be a non-empty 0x-prefixed hex string with even length`);\n    }\n    if (call.value !== undefined) {\n      try {\n        const v = BigInt(call.value);\n        if (v < 0n) throw new Error();\n      } catch {\n        throw new BuildTransactionError(`Invalid value: must be a non-negative integer string`);\n      }\n    }\n    this.rawCalls.push(call);\n    return this;\n  }\n\n  /**\n   * Get all raw contract calls in this transaction\n   * @returns Array of raw contract calls\n   */\n  getRawCalls(): RawContractCall[] {\n    return [...this.rawCalls];\n  }\n\n  /**\n   * Set which TIP-20 token will be used to pay transaction fees\n   * This is a global setting for the entire transaction\n   *\n   * @param tokenAddress - Address of the TIP-20 token to use for fees\n   * @returns this builder instance for chaining\n   */\n  feeToken(tokenAddress: string): this {\n    if (!isValidAddress(tokenAddress)) {\n      throw new BuildTransactionError(`Invalid fee token address: ${tokenAddress}`);\n    }\n    this._feeToken = tokenAddress as Address;\n    return this;\n  }\n\n  /**\n   * Set the transaction nonce\n   *\n   * @param nonce - Transaction nonce\n   * @returns this builder instance for chaining\n   */\n  nonce(nonce: number): this {\n    if (nonce < 0) {\n      throw new BuildTransactionError(`Invalid nonce: ${nonce}`);\n    }\n    this._nonce = nonce;\n    return this;\n  }\n\n  /**\n   * Set the gas limit for the transaction\n   *\n   * @param gas - Gas limit\n   * @returns this builder instance for chaining\n   */\n  gas(gas: string | bigint): this {\n    const gasValue = typeof gas === 'string' ? BigInt(gas) : gas;\n    if (gasValue <= 0n) {\n      throw new BuildTransactionError(`Invalid gas limit: ${gas}`);\n    }\n    this._gas = gasValue;\n    return this;\n  }\n\n  /**\n   * Set the maximum fee per gas (EIP-1559)\n   *\n   * @param maxFeePerGas - Maximum fee per gas in wei\n   * @returns this builder instance for chaining\n   */\n  maxFeePerGas(maxFeePerGas: string | bigint): this {\n    const feeValue = typeof maxFeePerGas === 'string' ? BigInt(maxFeePerGas) : maxFeePerGas;\n    if (feeValue < 0n) {\n      throw new BuildTransactionError(`Invalid maxFeePerGas: ${maxFeePerGas}`);\n    }\n    this._maxFeePerGas = feeValue;\n    return this;\n  }\n\n  /**\n   * Set the maximum priority fee per gas (EIP-1559)\n   *\n   * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei\n   * @returns this builder instance for chaining\n   */\n  maxPriorityFeePerGas(maxPriorityFeePerGas: string | bigint): this {\n    const feeValue = typeof maxPriorityFeePerGas === 'string' ? BigInt(maxPriorityFeePerGas) : maxPriorityFeePerGas;\n    if (feeValue < 0n) {\n      throw new BuildTransactionError(`Invalid maxPriorityFeePerGas: ${maxPriorityFeePerGas}`);\n    }\n    this._maxPriorityFeePerGas = feeValue;\n    return this;\n  }\n\n  /**\n   * Get all operations in this transaction\n   * @returns Array of TIP-20 operations\n   */\n  getOperations(): Tip20Operation[] {\n    return [...this.operations];\n  }\n\n  /**\n   * Get the fee token address if set\n   * @returns Fee token address or undefined\n   */\n  getFeeToken(): Address | undefined {\n    return this._feeToken;\n  }\n\n  /**\n   * Validate a single operation\n   * @param operation - Operation to validate\n   * @throws BuildTransactionError if invalid\n   */\n  private validateOperation(operation: Tip20Operation): void {\n    if (!isValidAddress(operation.token)) {\n      throw new BuildTransactionError(`Invalid token address: ${operation.token}`);\n    }\n\n    if (!isValidAddress(operation.to)) {\n      throw new BuildTransactionError(`Invalid recipient address: ${operation.to}`);\n    }\n\n    if (!isValidTip20Amount(operation.amount)) {\n      throw new BuildTransactionError(`Invalid amount: ${operation.amount}`);\n    }\n\n    if (operation.memo !== undefined && !isValidMemoId(operation.memo)) {\n      throw new BuildTransactionError(`Invalid memo: must be a non-negative integer`);\n    }\n  }\n\n  /**\n   * Convert a TIP-20 operation to an AA call\n   */\n  private operationToCall(op: Tip20Operation): { to: Address; data: Hex; value: bigint } {\n    const amountInUnits = amountToTip20Units(op.amount);\n    const data = encodeTip20TransferWithMemo(op.to, amountInUnits, op.memo);\n\n    return {\n      to: op.token,\n      data,\n      value: 0n,\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,27 @@
+/**
+ * Type aliases for Ethereum addresses and hex strings
+ */
+export type Address = string;
+export type Hex = string;
+export type TransactionSerializedEIP7702 = string;
+/**
+ * TIP-20 Operation with optional memo
+ * Represents a single transfer operation in a transaction
+ */
+export interface Tip20Operation {
+    token: Address;
+    to: Address;
+    amount: string;
+    memo?: string;
+}
+/**
+ * Raw smart contract call with pre-encoded calldata
+ * Used for arbitrary contract interactions (e.g., mint(), approve())
+ * where the caller provides the full ABI-encoded calldata
+ */
+export interface RawContractCall {
+    to: Address;
+    data: Hex;
+    value?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAC7B,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AACzB,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB"}

package/dist/src/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFR5cGUgYWxpYXNlcyBmb3IgRXRoZXJldW0gYWRkcmVzc2VzIGFuZCBoZXggc3RyaW5nc1xuICovXG5leHBvcnQgdHlwZSBBZGRyZXNzID0gc3RyaW5nO1xuZXhwb3J0IHR5cGUgSGV4ID0gc3RyaW5nO1xuZXhwb3J0IHR5cGUgVHJhbnNhY3Rpb25TZXJpYWxpemVkRUlQNzcwMiA9IHN0cmluZztcblxuLyoqXG4gKiBUSVAtMjAgT3BlcmF0aW9uIHdpdGggb3B0aW9uYWwgbWVtb1xuICogUmVwcmVzZW50cyBhIHNpbmdsZSB0cmFuc2ZlciBvcGVyYXRpb24gaW4gYSB0cmFuc2FjdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIFRpcDIwT3BlcmF0aW9uIHtcbiAgdG9rZW46IEFkZHJlc3M7XG4gIHRvOiBBZGRyZXNzO1xuICBhbW91bnQ6IHN0cmluZztcbiAgbWVtbz86IHN0cmluZztcbn1cblxuLyoqXG4gKiBSYXcgc21hcnQgY29udHJhY3QgY2FsbCB3aXRoIHByZS1lbmNvZGVkIGNhbGxkYXRhXG4gKiBVc2VkIGZvciBhcmJpdHJhcnkgY29udHJhY3QgaW50ZXJhY3Rpb25zIChlLmcuLCBtaW50KCksIGFwcHJvdmUoKSlcbiAqIHdoZXJlIHRoZSBjYWxsZXIgcHJvdmlkZXMgdGhlIGZ1bGwgQUJJLWVuY29kZWQgY2FsbGRhdGFcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBSYXdDb250cmFjdENhbGwge1xuICB0bzogQWRkcmVzcztcbiAgZGF0YTogSGV4O1xuICB2YWx1ZT86IHN0cmluZztcbn1cbiJdfQ==

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

@@ -1,25 +1,88 @@
 /**
- * Utility functions for Tempo
+ * Tempo Utility Functions
+ *
+ * Since Tempo is EVM-compatible, we can reuse Ethereum utilities
  */
+type Address = string;
+type Hex = string;
 /**
- * Check if the address is valid
- * @param address
+ * Check if address is valid Ethereum-style address
+ * Uses ethers.js isAddress for proper validation including checksum
  */
 export declare function isValidAddress(address: string): boolean;
 /**
- * Check if the public key is valid
- * @param publicKey
+ * Check if public key is valid (BIP32 xpub format)
+ * TODO: Replace with ETH utils when implementing
  */
 export declare function isValidPublicKey(publicKey: string): boolean;
 /**
- * Check if the private key is valid
- * @param privateKey
+ * Check if private key is valid (BIP32 xprv format)
+ * TODO: Replace with ETH utils when implementing
  */
 export declare function isValidPrivateKey(privateKey: string): boolean;
+/**
+ * TIP-20 Utility Functions
+ */
+/**
+ * Convert human-readable amount to TIP-20 units (6 decimals)
+ * @param amount - Human-readable amount (e.g., "1.5")
+ * @returns Amount in TIP-20 smallest units as bigint
+ * @example amountToTip20Units("1.5") => 1500000n
+ */
+export declare function amountToTip20Units(amount: string): bigint;
+/**
+ * Convert TIP-20 units (6 decimals) to human-readable amount
+ * @param units - Amount in TIP-20 smallest units
+ * @returns Human-readable amount string
+ * @example tip20UnitsToAmount(1500000n) => "1.5"
+ */
+export declare function tip20UnitsToAmount(units: bigint): string;
+/**
+ * Convert string to bytes32 for memo field
+ * @param memo - Memo string to encode
+ * @returns Hex-encoded bytes32 value
+ * @example stringToBytes32("INVOICE-001") => "0x494e564f4943452d30303100..."
+ */
+export declare function stringToBytes32(memo: string): Hex;
+/**
+ * Encode TIP-20 transferWithMemo function call using ethers.js
+ * @param to - Recipient address
+ * @param amount - Amount in TIP-20 units (bigint)
+ * @param memo - Optional memo string
+ * @returns Encoded function call data
+ */
+export declare function encodeTip20TransferWithMemo(to: Address, amount: bigint, memo?: string): Hex;
+/**
+ * Validate TIP-20 amount format
+ * @param amount - Amount string to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidTip20Amount(amount: string): boolean;
+/**
+ * Check if a raw transaction string is a Tempo AA transaction (type 0x76)
+ */
+export declare function isTip20Transaction(raw: string): boolean;
+/**
+ * Validate that a memoId is a valid non-negative integer string
+ */
+export declare function isValidMemoId(memoId: string): boolean;
+/**
+ * Validate that a string is a non-empty 0x-prefixed hex string
+ * Used to validate pre-encoded calldata for raw contract calls
+ */
+export declare function isValidHexData(data: string): boolean;
 declare const utils: {
     isValidAddress: typeof isValidAddress;
     isValidPublicKey: typeof isValidPublicKey;
     isValidPrivateKey: typeof isValidPrivateKey;
+    amountToTip20Units: typeof amountToTip20Units;
+    tip20UnitsToAmount: typeof tip20UnitsToAmount;
+    stringToBytes32: typeof stringToBytes32;
+    encodeTip20TransferWithMemo: typeof encodeTip20TransferWithMemo;
+    isValidTip20Amount: typeof isValidTip20Amount;
+    isTip20Transaction: typeof isTip20Transaction;
+    isValidMemoId: typeof isValidMemoId;
+    isValidHexData: typeof isValidHexData;
 };
 export default utils;
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAG3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED,QAAA,MAAM,KAAK;;;;CAIV,CAAC;AAEF,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,KAAK,OAAO,GAAG,MAAM,CAAC;AACtB,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAKvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAU3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAU7D;AAED;;GAEG;AAEH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAOjD;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,GAAG,CAK3F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,QAAA,MAAM,KAAK;;;;;;;;;;;;CAYV,CAAC;AAEF,eAAe,KAAK,CAAC"}