@bitgo-beta/sdk-coin-tempo 1.0.1-beta.8 → 1.0.1-beta.81

package/dist/src/lib/transaction.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * TIP-20 Transaction
+ *
+ * Represents a Tempo Account Abstraction (AA) transaction (type 0x76)
+ * Supports single or batch TIP-20 token transfers with memos
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20Transaction = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const ethers_1 = require("ethers");
+class Tip20Transaction extends sdk_core_1.BaseTransaction {
+    constructor(_coinConfig, request, operations = []) {
+        super(_coinConfig);
+        this.txRequest = request;
+        this._operations = operations;
+    }
+    get type() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    canSign() {
+        return true;
+    }
+    async serialize(signature) {
+        const sig = signature || this._signature;
+        return this.serializeTransaction(sig);
+    }
+    /**
+     * Encode calls as RLP tuples for atomic batch execution
+     * @returns Array of [to, value, data] tuples
+     * @private
+     */
+    encodeCallsAsTuples() {
+        return this.txRequest.calls.map((call) => [
+            call.to,
+            call.value ? ethers_1.ethers.utils.hexlify(call.value) : '0x',
+            call.data,
+        ]);
+    }
+    /**
+     * Encode EIP-2930 access list as RLP tuples
+     * @returns Array of [address, storageKeys[]] tuples
+     * @private
+     */
+    encodeAccessList() {
+        return (this.txRequest.accessList ?? []).map((item) => [item.address, item.storageKeys || []]);
+    }
+    /**
+     * Build base RLP data array per Tempo EIP-7702 specification
+     * @param callsTuples Encoded calls
+     * @param accessTuples Encoded access list
+     * @returns RLP-ready array of transaction fields
+     * @private
+     */
+    buildBaseRlpData(callsTuples, accessTuples) {
+        return [
+            ethers_1.ethers.utils.hexlify(this.txRequest.chainId),
+            this.txRequest.maxPriorityFeePerGas ? ethers_1.ethers.utils.hexlify(this.txRequest.maxPriorityFeePerGas.toString()) : '0x',
+            ethers_1.ethers.utils.hexlify(this.txRequest.maxFeePerGas.toString()),
+            ethers_1.ethers.utils.hexlify(this.txRequest.gas.toString()),
+            callsTuples,
+            accessTuples,
+            '0x', // nonceKey (reserved for 2D nonce system)
+            ethers_1.ethers.utils.hexlify(this.txRequest.nonce),
+            '0x', // validBefore (reserved for time bounds)
+            '0x', // validAfter (reserved for time bounds)
+            this.txRequest.feeToken || '0x',
+            '0x', // feePayerSignature (reserved for sponsorship)
+            [], // authorizationList (EIP-7702)
+        ];
+    }
+    /**
+     * Encode secp256k1 signature as 65-byte envelope
+     * @param signature ECDSA signature components
+     * @returns Hex string of concatenated r (32) + s (32) + v (1) bytes
+     * @private
+     */
+    encodeSignature(signature) {
+        const v = signature.yParity + 27;
+        const signatureBytes = ethers_1.ethers.utils.concat([
+            ethers_1.ethers.utils.zeroPad(signature.r, 32),
+            ethers_1.ethers.utils.zeroPad(signature.s, 32),
+            ethers_1.ethers.utils.hexlify(v),
+        ]);
+        return ethers_1.ethers.utils.hexlify(signatureBytes);
+    }
+    /**
+     * RLP encode and prepend transaction type byte
+     * @param rlpData Transaction fields array
+     * @returns Hex string with 0x76 prefix
+     * @private
+     */
+    rlpEncodeWithTypePrefix(rlpData) {
+        try {
+            const encoded = ethers_1.ethers.utils.RLP.encode(rlpData);
+            return ('0x76' + encoded.slice(2));
+        }
+        catch (error) {
+            throw new sdk_core_1.ParseTransactionError(`Failed to RLP encode transaction: ${error}`);
+        }
+    }
+    /**
+     * Serialize Tempo AA transaction (type 0x76) per EIP-7702 specification
+     * Format: 0x76 || RLP([chainId, fees, gas, calls, accessList, nonce fields, feeToken, sponsorship, authList, signature?])
+     * @param signature Optional ECDSA signature (omit for unsigned transactions)
+     * @returns RLP-encoded transaction hex string
+     * @private
+     */
+    serializeTransaction(signature) {
+        const callsTuples = this.encodeCallsAsTuples();
+        const accessTuples = this.encodeAccessList();
+        const rlpData = this.buildBaseRlpData(callsTuples, accessTuples);
+        if (signature) {
+            rlpData.push(this.encodeSignature(signature));
+        }
+        return this.rlpEncodeWithTypePrefix(rlpData);
+    }
+    getOperations() {
+        return [...this._operations];
+    }
+    getFeeToken() {
+        return this.txRequest.feeToken;
+    }
+    getOperationCount() {
+        return this.txRequest.calls.length;
+    }
+    isBatch() {
+        return this.txRequest.calls.length > 1;
+    }
+    setSignature(signature) {
+        this._signature = signature;
+    }
+    getSignature() {
+        return this._signature;
+    }
+    toJson() {
+        return {
+            type: this.txRequest.type,
+            chainId: this.txRequest.chainId,
+            nonce: this.txRequest.nonce,
+            maxFeePerGas: this.txRequest.maxFeePerGas.toString(),
+            maxPriorityFeePerGas: this.txRequest.maxPriorityFeePerGas.toString(),
+            gas: this.txRequest.gas.toString(),
+            callCount: this.txRequest.calls.length,
+            feeToken: this.txRequest.feeToken,
+            operations: this._operations,
+            signature: this._signature,
+        };
+    }
+    async toBroadcastFormat() {
+        return await this.serialize(this._signature);
+    }
+    get id() {
+        return 'pending';
+    }
+    toString() {
+        return JSON.stringify(this.toJson(), null, 2);
+    }
+    canBroadcast() {
+        return this.txRequest.calls.length > 0 && this.txRequest.chainId > 0;
+    }
+}
+exports.Tip20Transaction = Tip20Transaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TIP-20 Transaction\n *\n * Represents a Tempo Account Abstraction (AA) transaction (type 0x76)\n * Supports single or batch TIP-20 token transfers with memos\n */\n\nimport { BaseTransaction, ParseTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { ethers } from 'ethers';\nimport { Address, Hex, Tip20Operation } from './types';\n\n/**\n * TIP-20 Transaction Request Structure\n * Represents the raw transaction data for Tempo Account Abstraction (EIP-7702)\n */\nexport interface Tip20TransactionRequest {\n  /** Transaction type (0x76 for Tempo AA) */\n  type: number | string;\n  /** Chain ID for the Tempo network */\n  chainId: number;\n  /** Transaction nonce */\n  nonce: number;\n  /** Maximum fee per gas (EIP-1559) */\n  maxFeePerGas: bigint;\n  /** Maximum priority fee per gas (EIP-1559) */\n  maxPriorityFeePerGas: bigint;\n  /** Gas limit for the transaction */\n  gas: bigint;\n  /** Array of calls to execute in this transaction */\n  calls: { to: Address; data: Hex; value: bigint }[];\n  /** Access list (optional, typically empty for TIP-20) */\n  accessList?: unknown[];\n  /** Optional TIP-20 token to use for paying fees */\n  feeToken?: Address;\n}\n\nexport class Tip20Transaction extends BaseTransaction {\n  private txRequest: Tip20TransactionRequest;\n  private _operations: Tip20Operation[];\n  private _signature?: { r: Hex; s: Hex; yParity: number };\n\n  constructor(_coinConfig: Readonly<CoinConfig>, request: Tip20TransactionRequest, operations: Tip20Operation[] = []) {\n    super(_coinConfig);\n    this.txRequest = request;\n    this._operations = operations;\n  }\n\n  get type(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  canSign(): boolean {\n    return true;\n  }\n\n  async serialize(signature?: { r: Hex; s: Hex; yParity: number }): Promise<Hex> {\n    const sig = signature || this._signature;\n    return this.serializeTransaction(sig);\n  }\n\n  /**\n   * Encode calls as RLP tuples for atomic batch execution\n   * @returns Array of [to, value, data] tuples\n   * @private\n   */\n  private encodeCallsAsTuples(): any[] {\n    return this.txRequest.calls.map((call) => [\n      call.to,\n      call.value ? ethers.utils.hexlify(call.value) : '0x',\n      call.data,\n    ]);\n  }\n\n  /**\n   * Encode EIP-2930 access list as RLP tuples\n   * @returns Array of [address, storageKeys[]] tuples\n   * @private\n   */\n  private encodeAccessList(): any[] {\n    return (this.txRequest.accessList ?? []).map((item: any) => [item.address, item.storageKeys || []]);\n  }\n\n  /**\n   * Build base RLP data array per Tempo EIP-7702 specification\n   * @param callsTuples Encoded calls\n   * @param accessTuples Encoded access list\n   * @returns RLP-ready array of transaction fields\n   * @private\n   */\n  private buildBaseRlpData(callsTuples: any[], accessTuples: any[]): any[] {\n    return [\n      ethers.utils.hexlify(this.txRequest.chainId),\n      this.txRequest.maxPriorityFeePerGas ? ethers.utils.hexlify(this.txRequest.maxPriorityFeePerGas.toString()) : '0x',\n      ethers.utils.hexlify(this.txRequest.maxFeePerGas.toString()),\n      ethers.utils.hexlify(this.txRequest.gas.toString()),\n      callsTuples,\n      accessTuples,\n      '0x', // nonceKey (reserved for 2D nonce system)\n      ethers.utils.hexlify(this.txRequest.nonce),\n      '0x', // validBefore (reserved for time bounds)\n      '0x', // validAfter (reserved for time bounds)\n      this.txRequest.feeToken || '0x',\n      '0x', // feePayerSignature (reserved for sponsorship)\n      [], // authorizationList (EIP-7702)\n    ];\n  }\n\n  /**\n   * Encode secp256k1 signature as 65-byte envelope\n   * @param signature ECDSA signature components\n   * @returns Hex string of concatenated r (32) + s (32) + v (1) bytes\n   * @private\n   */\n  private encodeSignature(signature: { r: Hex; s: Hex; yParity: number }): string {\n    const v = signature.yParity + 27;\n    const signatureBytes = ethers.utils.concat([\n      ethers.utils.zeroPad(signature.r, 32),\n      ethers.utils.zeroPad(signature.s, 32),\n      ethers.utils.hexlify(v),\n    ]);\n    return ethers.utils.hexlify(signatureBytes);\n  }\n\n  /**\n   * RLP encode and prepend transaction type byte\n   * @param rlpData Transaction fields array\n   * @returns Hex string with 0x76 prefix\n   * @private\n   */\n  private rlpEncodeWithTypePrefix(rlpData: any[]): Hex {\n    try {\n      const encoded = ethers.utils.RLP.encode(rlpData);\n      return ('0x76' + encoded.slice(2)) as Hex;\n    } catch (error) {\n      throw new ParseTransactionError(`Failed to RLP encode transaction: ${error}`);\n    }\n  }\n\n  /**\n   * Serialize Tempo AA transaction (type 0x76) per EIP-7702 specification\n   * Format: 0x76 || RLP([chainId, fees, gas, calls, accessList, nonce fields, feeToken, sponsorship, authList, signature?])\n   * @param signature Optional ECDSA signature (omit for unsigned transactions)\n   * @returns RLP-encoded transaction hex string\n   * @private\n   */\n  private serializeTransaction(signature?: { r: Hex; s: Hex; yParity: number }): Hex {\n    const callsTuples = this.encodeCallsAsTuples();\n    const accessTuples = this.encodeAccessList();\n    const rlpData = this.buildBaseRlpData(callsTuples, accessTuples);\n\n    if (signature) {\n      rlpData.push(this.encodeSignature(signature));\n    }\n\n    return this.rlpEncodeWithTypePrefix(rlpData);\n  }\n\n  getOperations(): Tip20Operation[] {\n    return [...this._operations];\n  }\n\n  getFeeToken(): Address | undefined {\n    return this.txRequest.feeToken;\n  }\n\n  getOperationCount(): number {\n    return this.txRequest.calls.length;\n  }\n\n  isBatch(): boolean {\n    return this.txRequest.calls.length > 1;\n  }\n\n  setSignature(signature: { r: Hex; s: Hex; yParity: number }): void {\n    this._signature = signature;\n  }\n\n  getSignature(): { r: Hex; s: Hex; yParity: number } | undefined {\n    return this._signature;\n  }\n\n  toJson(): Record<string, unknown> {\n    return {\n      type: this.txRequest.type,\n      chainId: this.txRequest.chainId,\n      nonce: this.txRequest.nonce,\n      maxFeePerGas: this.txRequest.maxFeePerGas.toString(),\n      maxPriorityFeePerGas: this.txRequest.maxPriorityFeePerGas.toString(),\n      gas: this.txRequest.gas.toString(),\n      callCount: this.txRequest.calls.length,\n      feeToken: this.txRequest.feeToken,\n      operations: this._operations,\n      signature: this._signature,\n    };\n  }\n\n  async toBroadcastFormat(): Promise<string> {\n    return await this.serialize(this._signature);\n  }\n\n  get id(): string {\n    return 'pending';\n  }\n\n  toString(): string {\n    return JSON.stringify(this.toJson(), null, 2);\n  }\n\n  canBroadcast(): boolean {\n    return this.txRequest.calls.length > 0 && this.txRequest.chainId > 0;\n  }\n}\n"]}

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

@@ -0,0 +1,100 @@
+/**
+ * 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)
+ */
+import { TransactionBuilder as AbstractTransactionBuilder, TransferBuilder } from '@bitgo-beta/abstract-eth';
+import { BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Address, Tip20Operation } from './types';
+/**
+ * Transaction Builder for TIP-20 tokens on Tempo blockchain
+ * Extends abstract-eth TransactionBuilder with Tempo-specific features
+ */
+export declare class Tip20TransactionBuilder extends AbstractTransactionBuilder {
+    private operations;
+    private _feeToken?;
+    private _nonce?;
+    private _gas?;
+    private _maxFeePerGas?;
+    private _maxPriorityFeePerGas?;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Implement the transfer method from abstract class
+     * Note: For TIP-20 transactions, use addOperation() instead
+     */
+    transfer(data?: string, isFirstSigner?: boolean): TransferBuilder;
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters
+     */
+    protected buildImplementation(): Promise<BaseTransaction>;
+    /**
+     * 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: Tip20Operation): this;
+    /**
+     * 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: string): this;
+    /**
+     * Set the transaction nonce
+     *
+     * @param nonce - Transaction nonce
+     * @returns this builder instance for chaining
+     */
+    nonce(nonce: number): this;
+    /**
+     * Set the gas limit for the transaction
+     *
+     * @param gas - Gas limit
+     * @returns this builder instance for chaining
+     */
+    gas(gas: string | bigint): 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: string | bigint): 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: string | bigint): this;
+    /**
+     * Get all operations in this transaction
+     * @returns Array of TIP-20 operations
+     */
+    getOperations(): Tip20Operation[];
+    /**
+     * Get the fee token address if set
+     * @returns Fee token address or undefined
+     */
+    getFeeToken(): Address | undefined;
+    /**
+     * Validate a single operation
+     * @param operation - Operation to validate
+     * @throws BuildTransactionError if invalid
+     */
+    private validateOperation;
+    /**
+     * Convert a TIP-20 operation to an AA call
+     */
+    private operationToCall;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,kBAAkB,IAAI,0BAA0B,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC7G,OAAO,EAAE,eAAe,EAAyB,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAO,cAAc,EAAE,MAAM,SAAS,CAAC;AAKvD;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,0BAA0B;IACrE,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAE3B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,eAAe;IASjE;;OAEG;cACa,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IAsC/D;;;;;;OAMG;IACH,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAM7C;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAQpC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ1B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAS/B;;;;;OAKG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjD;;;;;OAKG;IACH,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjE;;;OAGG;IACH,aAAa,IAAI,cAAc,EAAE;IAIjC;;;OAGG;IACH,WAAW,IAAI,OAAO,GAAG,SAAS;IAIlC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAUxB"}

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,204 @@
+"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 transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+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 = [];
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters
+     */
+    async buildImplementation() {
+        if (this.operations.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('At least one operation 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');
+        }
+        const calls = this.operations.map((op) => this.operationToCall(op));
+        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,
+        };
+        return new transaction_1.Tip20Transaction(this._coinConfig, txRequest, this.operations);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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}`);
+        }
+        // Validate memo byte length (handles multi-byte UTF-8 characters)
+        if (operation.memo) {
+            const memoByteLength = new TextEncoder().encode(operation.memo).length;
+            if (memoByteLength > 32) {
+                throw new sdk_core_1.BuildTransactionError(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);
+            }
+        }
+    }
+    /**
+     * 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":";AAAA;;;;;;;;GAQG;;;AAEH,2DAA6G;AAC7G,mDAA8E;AAG9E,+CAA0E;AAC1E,mCAA8G;AAC9G,2CAAkD;AAElD;;;GAGG;AACH,MAAa,uBAAwB,SAAQ,iCAA0B;IAQrE,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;QARb,eAAU,GAAqB,EAAE,CAAC;IAS1C,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,IAAa,EAAE,aAAuB;QAC7C,MAAM,eAAe,GAAG,IAAI,8BAAe,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QACtE,IAAI,IAAI,EAAE,CAAC;YACT,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,eAAe,CAAC;QACjC,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;OAEG;IACO,KAAK,CAAC,mBAAmB;QACjC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,gCAAqB,CAAC,2DAA2D,CAAC,CAAC;QAC/F,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,gCAAqB,CAAC,0CAA0C,CAAC,CAAC;QAC9E,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,gCAAqB,CAAC,8CAA8C,CAAC,CAAC;QAClF,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,IAAI,gCAAqB,CAAC,iDAAiD,CAAC,CAAC;QACrF,CAAC;QAED,IAAI,IAAI,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;YAC7C,MAAM,IAAI,gCAAqB,CAAC,yDAAyD,CAAC,CAAC;QAC7F,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC;QAEpE,MAAM,SAAS,GAA4B;YACzC,IAAI,EAAE,+BAAmB;YACzB,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE;YAC5C,KAAK,EAAE,IAAI,CAAC,MAAM;YAClB,YAAY,EAAE,IAAI,CAAC,aAAa;YAChC,oBAAoB,EAAE,IAAI,CAAC,qBAAqB;YAChD,GAAG,EAAE,IAAI,CAAC,IAAI;YACd,KAAK;YACL,UAAU,EAAE,EAAE;YACd,QAAQ,EAAE,IAAI,CAAC,SAAS;SACzB,CAAC;QAEF,OAAO,IAAI,8BAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5E,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CAAC,SAAyB;QACpC,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;QAClC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,YAAoB;QAC3B,IAAI,CAAC,IAAA,sBAAc,EAAC,YAAY,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,gCAAqB,CAAC,8BAA8B,YAAY,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,YAAuB,CAAC;QACzC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAa;QACjB,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,MAAM,IAAI,gCAAqB,CAAC,kBAAkB,KAAK,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,GAAoB;QACtB,MAAM,QAAQ,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;QAC7D,IAAI,QAAQ,IAAI,EAAE,EAAE,CAAC;YACnB,MAAM,IAAI,gCAAqB,CAAC,sBAAsB,GAAG,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,YAA6B;QACxC,MAAM,QAAQ,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;QACxF,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;YAClB,MAAM,IAAI,gCAAqB,CAAC,yBAAyB,YAAY,EAAE,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,oBAAoB,CAAC,oBAAqC;QACxD,MAAM,QAAQ,GAAG,OAAO,oBAAoB,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC;QAChH,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;YAClB,MAAM,IAAI,gCAAqB,CAAC,iCAAiC,oBAAoB,EAAE,CAAC,CAAC;QAC3F,CAAC;QACD,IAAI,CAAC,qBAAqB,GAAG,QAAQ,CAAC;QACtC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,aAAa;QACX,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACK,iBAAiB,CAAC,SAAyB;QACjD,IAAI,CAAC,IAAA,sBAAc,EAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,gCAAqB,CAAC,0BAA0B,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/E,CAAC;QAED,IAAI,CAAC,IAAA,sBAAc,EAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,gCAAqB,CAAC,8BAA8B,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;QAChF,CAAC;QAED,IAAI,CAAC,IAAA,0BAAkB,EAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,gCAAqB,CAAC,mBAAmB,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QACzE,CAAC;QAED,kEAAkE;QAClE,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC;YACnB,MAAM,cAAc,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;YACvE,IAAI,cAAc,GAAG,EAAE,EAAE,CAAC;gBACxB,MAAM,IAAI,gCAAqB,CAAC,kBAAkB,cAAc,2BAA2B,CAAC,CAAC;YAC/F,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,eAAe,CAAC,EAAkB;QACxC,MAAM,aAAa,GAAG,IAAA,0BAAkB,EAAC,EAAE,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,IAAA,mCAA2B,EAAC,EAAE,CAAC,EAAE,EAAE,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QAExE,OAAO;YACL,EAAE,EAAE,EAAE,CAAC,KAAK;YACZ,IAAI;YACJ,KAAK,EAAE,EAAE;SACV,CAAC;IACJ,CAAC;CACF;AAjND,0DAiNC","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 { TransactionBuilder as AbstractTransactionBuilder, TransferBuilder } from '@bitgo-beta/abstract-eth';\nimport { BaseTransaction, BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Address, Hex, Tip20Operation } from './types';\nimport { Tip20Transaction, Tip20TransactionRequest } from './transaction';\nimport { amountToTip20Units, encodeTip20TransferWithMemo, isValidAddress, isValidTip20Amount } from './utils';\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 _feeToken?: Address;\n  private _nonce?: number;\n  private _gas?: bigint;\n  private _maxFeePerGas?: bigint;\n  private _maxPriorityFeePerGas?: bigint;\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   * Build the transaction from configured TIP-20 operations and transaction parameters\n   */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    if (this.operations.length === 0) {\n      throw new BuildTransactionError('At least one operation 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    const calls = this.operations.map((op) => this.operationToCall(op));\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    return new Tip20Transaction(this._coinConfig, txRequest, this.operations);\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   * 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    // Validate memo byte length (handles multi-byte UTF-8 characters)\n    if (operation.memo) {\n      const memoByteLength = new TextEncoder().encode(operation.memo).length;\n      if (memoByteLength > 32) {\n        throw new BuildTransactionError(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);\n      }\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,17 @@
+/**
+ * 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;
+}
+//# 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"}

package/dist/src/lib/types.js

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

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

@@ -1,25 +1,72 @@
 /**
- * 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;
 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;
 };
 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;AAOH,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,QAAA,MAAM,KAAK;;;;;;;;;CASV,CAAC;AAEF,eAAe,KAAK,CAAC"}