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

package/dist/src/tip20Token.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @prettier
+ */
+import { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { Tip20TokenConfig } from '@bitgo-beta/statics';
+import { GetSendMethodArgsOptions, SendMethodArgs } from '@bitgo-beta/abstract-eth';
+import { Tempo } from './tempo';
+export { Tip20TokenConfig };
+/**
+ * TIP20 Token Implementation (Skeleton)
+ *
+ * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.
+ *
+ * TODO: All methods will be implemented progressively
+ */
+export declare class Tip20Token extends Tempo {
+    readonly tokenConfig: Tip20TokenConfig;
+    readonly contractAddress: string;
+    constructor(bitgo: BitGoBase, tokenConfig: Tip20TokenConfig);
+    /**
+     * Create a coin constructor for a specific token
+     */
+    static createTokenConstructor(config: Tip20TokenConfig): CoinConstructor;
+    /**
+     * Create token constructors for all TIP20 tokens
+     * @param tokenConfigs - Array of token configurations; defaults to all TIP20 tokens from statics
+     */
+    static createTokenConstructors(tokenConfigs?: Tip20TokenConfig[]): NamedCoinConstructor[];
+    /** Get the token type */
+    get type(): string;
+    /** Get the token name */
+    get name(): string;
+    /** Get the base coin */
+    get coin(): string;
+    /** Get the network */
+    get network(): string;
+    /** Get the token contract address */
+    get tokenContractAddress(): string;
+    /** Get token decimal places */
+    get decimalPlaces(): number;
+    /** @inheritDoc */
+    getChain(): string;
+    /** @inheritDoc */
+    getBaseChain(): string;
+    /** @inheritDoc */
+    getFullName(): string;
+    /** @inheritDoc */
+    getBaseFactor(): number;
+    /** @inheritDoc */
+    valuelessTransferAllowed(): boolean;
+    /** @inheritDoc */
+    supportsTss(): boolean;
+    /** @inheritDoc */
+    getMPCAlgorithm(): MPCAlgorithm;
+    /**
+     * Verify that the transaction coin/token matches this token
+     * @param txPrebuild - Transaction prebuild object
+     * @returns true if valid, false otherwise
+     */
+    verifyCoin(txPrebuild: {
+        coin?: string;
+        token?: string;
+    }): boolean;
+    /**
+     * Get send method arguments for TIP-20 token transfer with memo
+     * @param txInfo - Transaction information including recipient and amount
+     * @returns Array of send method arguments for ABI encoding
+     */
+    getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[];
+    /**
+     * Get operation object for TIP-20 token transfer (for batch transactions)
+     * @param recipient - Recipient information with address, amount, and optional memo
+     * @param expireTime - Transaction expiration time
+     * @param contractSequenceId - Contract sequence ID
+     * @returns Operation array for ABI encoding
+     */
+    getOperation(recipient: {
+        address: string;
+        amount: string;
+        memo?: string;
+    }, expireTime: number, contractSequenceId: number): (string | Buffer)[][];
+}
+//# sourceMappingURL=tip20Token.d.ts.map

package/dist/src/tip20Token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tip20Token.d.ts","sourceRoot":"","sources":["../../src/tip20Token.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACtG,OAAO,EAAiB,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAEpF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAE5B;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,WAAW,EAAE,gBAAgB,CAAC;IAC9C,SAAgB,eAAe,EAAE,MAAM,CAAC;gBAE5B,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB;IAO3D;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe;IAIxE;;;OAGG;IACH,MAAM,CAAC,uBAAuB,CAC5B,YAAY,GAAE,gBAAgB,EAAqE,GAClG,oBAAoB,EAAE;IAezB,yBAAyB;IACzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,yBAAyB;IACzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,wBAAwB;IACxB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,sBAAsB;IACtB,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,qCAAqC;IACrC,IAAI,oBAAoB,IAAI,MAAM,CAEjC;IAED,+BAA+B;IAC/B,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,kBAAkB;IAClB,QAAQ,IAAI,MAAM;IAIlB,kBAAkB;IAClB,YAAY,IAAI,MAAM;IAItB,kBAAkB;IAClB,WAAW,IAAI,MAAM;IAIrB,kBAAkB;IAClB,aAAa,IAAI,MAAM;IAIvB,kBAAkB;IAClB,wBAAwB,IAAI,OAAO;IAInC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B;;;;OAIG;IACH,UAAU,CAAC,UAAU,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IAelE;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,cAAc,EAAE;IA+DrE;;;;;;OAMG;IACH,YAAY,CACV,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAC7D,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,GACzB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE;CA0BzB"}

package/dist/src/tip20Token.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20Token = void 0;
+const statics_1 = require("@bitgo-beta/statics");
+const tempo_1 = require("./tempo");
+const utils_1 = require("./lib/utils");
+/**
+ * TIP20 Token Implementation (Skeleton)
+ *
+ * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.
+ *
+ * TODO: All methods will be implemented progressively
+ */
+class Tip20Token extends tempo_1.Tempo {
+    constructor(bitgo, tokenConfig) {
+        const staticsCoin = tokenConfig.network === 'Mainnet' ? statics_1.coins.get('tempo') : statics_1.coins.get('ttempo');
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+        this.contractAddress = tokenConfig.tokenContractAddress;
+    }
+    /**
+     * Create a coin constructor for a specific token
+     */
+    static createTokenConstructor(config) {
+        return (bitgo) => new Tip20Token(bitgo, config);
+    }
+    /**
+     * Create token constructors for all TIP20 tokens
+     * @param tokenConfigs - Array of token configurations; defaults to all TIP20 tokens from statics
+     */
+    static createTokenConstructors(tokenConfigs = [...statics_1.tokens.bitcoin.tempo.tokens, ...statics_1.tokens.testnet.tempo.tokens]) {
+        const configs = tokenConfigs;
+        const tokensCtors = [];
+        for (const token of configs) {
+            const tokenConstructor = Tip20Token.createTokenConstructor(token);
+            // Register by token type
+            tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
+            // Also register by contract address for lookups
+            tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });
+        }
+        return tokensCtors;
+    }
+    /** Get the token type */
+    get type() {
+        return this.tokenConfig.type;
+    }
+    /** Get the token name */
+    get name() {
+        return this.tokenConfig.name;
+    }
+    /** Get the base coin */
+    get coin() {
+        return this.tokenConfig.coin;
+    }
+    /** Get the network */
+    get network() {
+        return this.tokenConfig.network;
+    }
+    /** Get the token contract address */
+    get tokenContractAddress() {
+        return this.tokenConfig.tokenContractAddress;
+    }
+    /** Get token decimal places */
+    get decimalPlaces() {
+        return this.tokenConfig.decimalPlaces;
+    }
+    /** @inheritDoc */
+    getChain() {
+        return this.tokenConfig.type;
+    }
+    /** @inheritDoc */
+    getBaseChain() {
+        return this.coin;
+    }
+    /** @inheritDoc */
+    getFullName() {
+        return 'TIP20 Token';
+    }
+    /** @inheritDoc */
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+    /** @inheritDoc */
+    valuelessTransferAllowed() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    /**
+     * Verify that the transaction coin/token matches this token
+     * @param txPrebuild - Transaction prebuild object
+     * @returns true if valid, false otherwise
+     */
+    verifyCoin(txPrebuild) {
+        if (!txPrebuild) {
+            return false;
+        }
+        // Check if the coin or token matches this token's configuration
+        const coinMatch = txPrebuild.coin === this.tokenConfig.coin || txPrebuild.coin === this.tokenConfig.type;
+        const tokenMatch = !txPrebuild.token ||
+            txPrebuild.token === this.tokenConfig.tokenContractAddress ||
+            txPrebuild.token === this.tokenConfig.type;
+        return coinMatch && tokenMatch;
+    }
+    /**
+     * Get send method arguments for TIP-20 token transfer with memo
+     * @param txInfo - Transaction information including recipient and amount
+     * @returns Array of send method arguments for ABI encoding
+     */
+    getSendMethodArgs(txInfo) {
+        const { recipient } = txInfo;
+        if (!recipient) {
+            throw new Error('Recipient is required for token transfer');
+        }
+        if (!(0, utils_1.isValidAddress)(recipient.address)) {
+            throw new Error(`Invalid recipient address: ${recipient.address}`);
+        }
+        if (!(0, utils_1.isValidTip20Amount)(recipient.amount)) {
+            throw new Error(`Invalid amount: ${recipient.amount}`);
+        }
+        const memo = recipient.memo;
+        if (memo && Buffer.byteLength(memo, 'utf-8') > 32) {
+            throw new Error('Memo too long: maximum 32 bytes');
+        }
+        const amountInUnits = (0, utils_1.amountToTip20Units)(recipient.amount);
+        const data = (0, utils_1.encodeTip20TransferWithMemo)(recipient.address, amountInUnits, memo);
+        return [
+            {
+                name: 'toAddress',
+                type: 'address',
+                value: recipient.address,
+            },
+            {
+                name: 'value',
+                type: 'uint',
+                value: recipient.amount,
+            },
+            {
+                name: 'tokenContractAddress',
+                type: 'address',
+                value: this.tokenConfig.tokenContractAddress,
+            },
+            {
+                name: 'data',
+                type: 'bytes',
+                value: Buffer.from(data.slice(2), 'hex'),
+            },
+            {
+                name: 'expireTime',
+                type: 'uint',
+                value: txInfo.expireTime,
+            },
+            {
+                name: 'sequenceId',
+                type: 'uint',
+                value: txInfo.contractSequenceId,
+            },
+            {
+                name: 'signature',
+                type: 'bytes',
+                value: Buffer.from(txInfo.signature.replace('0x', ''), 'hex'),
+            },
+        ];
+    }
+    /**
+     * Get operation object for TIP-20 token transfer (for batch transactions)
+     * @param recipient - Recipient information with address, amount, and optional memo
+     * @param expireTime - Transaction expiration time
+     * @param contractSequenceId - Contract sequence ID
+     * @returns Operation array for ABI encoding
+     */
+    getOperation(recipient, expireTime, contractSequenceId) {
+        if (!(0, utils_1.isValidAddress)(recipient.address)) {
+            throw new Error(`Invalid recipient address: ${recipient.address}`);
+        }
+        if (!(0, utils_1.isValidTip20Amount)(recipient.amount)) {
+            throw new Error(`Invalid amount: ${recipient.amount}`);
+        }
+        // Validate memo byte length (handles multi-byte UTF-8 characters)
+        if (recipient.memo !== undefined && recipient.memo !== null && recipient.memo !== '') {
+            const memoByteLength = new TextEncoder().encode(recipient.memo).length;
+            if (memoByteLength > 32) {
+                throw new Error(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);
+            }
+        }
+        const amountInUnits = (0, utils_1.amountToTip20Units)(recipient.amount);
+        const data = (0, utils_1.encodeTip20TransferWithMemo)(recipient.address, amountInUnits, recipient.memo);
+        // Return format compatible with parent class for ABI encoding
+        return [
+            ['address', 'bytes'],
+            [this.tokenConfig.tokenContractAddress, Buffer.from(data.slice(2), 'hex')],
+        ];
+    }
+}
+exports.Tip20Token = Tip20Token;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tip20Token.js","sourceRoot":"","sources":["../../src/tip20Token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';\nimport { coins, tokens, Tip20TokenConfig } from '@bitgo-beta/statics';\nimport { GetSendMethodArgsOptions, SendMethodArgs } from '@bitgo-beta/abstract-eth';\nimport { Address } from './lib/types';\nimport { Tempo } from './tempo';\nimport { encodeTip20TransferWithMemo, amountToTip20Units, isValidAddress, isValidTip20Amount } from './lib/utils';\n\nexport { Tip20TokenConfig };\n\n/**\n * TIP20 Token Implementation (Skeleton)\n *\n * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.\n *\n * TODO: All methods will be implemented progressively\n */\nexport class Tip20Token extends Tempo {\n  public readonly tokenConfig: Tip20TokenConfig;\n  public readonly contractAddress: string;\n\n  constructor(bitgo: BitGoBase, tokenConfig: Tip20TokenConfig) {\n    const staticsCoin = tokenConfig.network === 'Mainnet' ? coins.get('tempo') : coins.get('ttempo');\n    super(bitgo, staticsCoin);\n    this.tokenConfig = tokenConfig;\n    this.contractAddress = tokenConfig.tokenContractAddress;\n  }\n\n  /**\n   * Create a coin constructor for a specific token\n   */\n  static createTokenConstructor(config: Tip20TokenConfig): CoinConstructor {\n    return (bitgo: BitGoBase) => new Tip20Token(bitgo, config);\n  }\n\n  /**\n   * Create token constructors for all TIP20 tokens\n   * @param tokenConfigs - Array of token configurations; defaults to all TIP20 tokens from statics\n   */\n  static createTokenConstructors(\n    tokenConfigs: Tip20TokenConfig[] = [...tokens.bitcoin.tempo.tokens, ...tokens.testnet.tempo.tokens]\n  ): NamedCoinConstructor[] {\n    const configs = tokenConfigs;\n    const tokensCtors: NamedCoinConstructor[] = [];\n\n    for (const token of configs) {\n      const tokenConstructor = Tip20Token.createTokenConstructor(token);\n      // Register by token type\n      tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });\n      // Also register by contract address for lookups\n      tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });\n    }\n\n    return tokensCtors;\n  }\n\n  /** Get the token type */\n  get type(): string {\n    return this.tokenConfig.type;\n  }\n\n  /** Get the token name */\n  get name(): string {\n    return this.tokenConfig.name;\n  }\n\n  /** Get the base coin */\n  get coin(): string {\n    return this.tokenConfig.coin;\n  }\n\n  /** Get the network */\n  get network(): string {\n    return this.tokenConfig.network;\n  }\n\n  /** Get the token contract address */\n  get tokenContractAddress(): string {\n    return this.tokenConfig.tokenContractAddress;\n  }\n\n  /** Get token decimal places */\n  get decimalPlaces(): number {\n    return this.tokenConfig.decimalPlaces;\n  }\n\n  /** @inheritDoc */\n  getChain(): string {\n    return this.tokenConfig.type;\n  }\n\n  /** @inheritDoc */\n  getBaseChain(): string {\n    return this.coin;\n  }\n\n  /** @inheritDoc */\n  getFullName(): string {\n    return 'TIP20 Token';\n  }\n\n  /** @inheritDoc */\n  getBaseFactor(): number {\n    return Math.pow(10, this.tokenConfig.decimalPlaces);\n  }\n\n  /** @inheritDoc */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /**\n   * Verify that the transaction coin/token matches this token\n   * @param txPrebuild - Transaction prebuild object\n   * @returns true if valid, false otherwise\n   */\n  verifyCoin(txPrebuild: { coin?: string; token?: string }): boolean {\n    if (!txPrebuild) {\n      return false;\n    }\n\n    // Check if the coin or token matches this token's configuration\n    const coinMatch = txPrebuild.coin === this.tokenConfig.coin || txPrebuild.coin === this.tokenConfig.type;\n    const tokenMatch =\n      !txPrebuild.token ||\n      txPrebuild.token === this.tokenConfig.tokenContractAddress ||\n      txPrebuild.token === this.tokenConfig.type;\n\n    return coinMatch && tokenMatch;\n  }\n\n  /**\n   * Get send method arguments for TIP-20 token transfer with memo\n   * @param txInfo - Transaction information including recipient and amount\n   * @returns Array of send method arguments for ABI encoding\n   */\n  getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[] {\n    const { recipient } = txInfo;\n\n    if (!recipient) {\n      throw new Error('Recipient is required for token transfer');\n    }\n\n    if (!isValidAddress(recipient.address)) {\n      throw new Error(`Invalid recipient address: ${recipient.address}`);\n    }\n\n    if (!isValidTip20Amount(recipient.amount)) {\n      throw new Error(`Invalid amount: ${recipient.amount}`);\n    }\n\n    const memo = (recipient as { memo?: string }).memo;\n\n    if (memo && Buffer.byteLength(memo, 'utf-8') > 32) {\n      throw new Error('Memo too long: maximum 32 bytes');\n    }\n\n    const amountInUnits = amountToTip20Units(recipient.amount);\n    const data = encodeTip20TransferWithMemo(recipient.address as Address, amountInUnits, memo);\n\n    return [\n      {\n        name: 'toAddress',\n        type: 'address',\n        value: recipient.address,\n      },\n      {\n        name: 'value',\n        type: 'uint',\n        value: recipient.amount,\n      },\n      {\n        name: 'tokenContractAddress',\n        type: 'address',\n        value: this.tokenConfig.tokenContractAddress,\n      },\n      {\n        name: 'data',\n        type: 'bytes',\n        value: Buffer.from(data.slice(2), 'hex'),\n      },\n      {\n        name: 'expireTime',\n        type: 'uint',\n        value: txInfo.expireTime,\n      },\n      {\n        name: 'sequenceId',\n        type: 'uint',\n        value: txInfo.contractSequenceId,\n      },\n      {\n        name: 'signature',\n        type: 'bytes',\n        value: Buffer.from(txInfo.signature.replace('0x', ''), 'hex'),\n      },\n    ];\n  }\n\n  /**\n   * Get operation object for TIP-20 token transfer (for batch transactions)\n   * @param recipient - Recipient information with address, amount, and optional memo\n   * @param expireTime - Transaction expiration time\n   * @param contractSequenceId - Contract sequence ID\n   * @returns Operation array for ABI encoding\n   */\n  getOperation(\n    recipient: { address: string; amount: string; memo?: string },\n    expireTime: number,\n    contractSequenceId: number\n  ): (string | Buffer)[][] {\n    if (!isValidAddress(recipient.address)) {\n      throw new Error(`Invalid recipient address: ${recipient.address}`);\n    }\n\n    if (!isValidTip20Amount(recipient.amount)) {\n      throw new Error(`Invalid amount: ${recipient.amount}`);\n    }\n\n    // Validate memo byte length (handles multi-byte UTF-8 characters)\n    if (recipient.memo !== undefined && recipient.memo !== null && recipient.memo !== '') {\n      const memoByteLength = new TextEncoder().encode(recipient.memo).length;\n      if (memoByteLength > 32) {\n        throw new Error(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);\n      }\n    }\n\n    const amountInUnits = amountToTip20Units(recipient.amount);\n    const data = encodeTip20TransferWithMemo(recipient.address as Address, amountInUnits, recipient.memo);\n\n    // Return format compatible with parent class for ABI encoding\n    return [\n      ['address', 'bytes'],\n      [this.tokenConfig.tokenContractAddress, Buffer.from(data.slice(2), 'hex')],\n    ];\n  }\n}\n"]}

package/dist/test/integration/tip20.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TIP-20 Integration Tests
+ *
+ * End-to-end flows for TIP-20 token transactions on Tempo using testnet token addresses.
+ */
+export {};
+//# sourceMappingURL=tip20.d.ts.map

package/dist/test/integration/tip20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tip20.d.ts","sourceRoot":"","sources":["../../../test/integration/tip20.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/test/integration/tip20.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * TIP-20 Integration Tests
+ *
+ * End-to-end flows for TIP-20 token transactions on Tempo using testnet token addresses.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const ethers_1 = require("ethers");
+const statics_1 = require("@bitgo-beta/statics");
+const transactionBuilder_1 = require("../../src/lib/transactionBuilder");
+const transaction_1 = require("../../src/lib/transaction");
+const constants_1 = require("../../src/lib/constants");
+const tempo_1 = require("../resources/tempo");
+const mockCoinConfig = statics_1.coins.get('ttempo');
+const ALPHA_USD_TOKEN = tempo_1.TESTNET_TOKENS.alphaUSD.address;
+const BETA_USD_TOKEN = tempo_1.TESTNET_TOKENS.betaUSD.address;
+const THETA_USD_TOKEN = tempo_1.TESTNET_TOKENS.thetaUSD.address;
+const RECEIVER_ADDRESS = tempo_1.TEST_RECIPIENT_ADDRESS;
+(0, mocha_1.describe)('TIP-20 Integration Tests', () => {
+    (0, mocha_1.describe)('Single Transfer', () => {
+        (0, mocha_1.it)('should build and serialize single TIP-20 transfer', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '1',
+                memo: '1',
+            })
+                .feeToken(ALPHA_USD_TOKEN)
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.ok(tx instanceof transaction_1.Tip20Transaction);
+            assert_1.default.strictEqual(tx.getOperationCount(), 1);
+            assert_1.default.strictEqual(tx.isBatch(), false);
+            assert_1.default.strictEqual(tx.getOperations()[0].memo, '1');
+            const serialized = await tx.serialize();
+            assert_1.default.ok(serialized.startsWith(constants_1.AA_TRANSACTION_TYPE));
+        });
+    });
+    (0, mocha_1.describe)('Batch Transfer', () => {
+        (0, mocha_1.it)('should build multi-token batch transfer', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '15', memo: '1' })
+                .addOperation({ token: BETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '20', memo: '2' })
+                .addOperation({ token: THETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '7', memo: '3' })
+                .feeToken(BETA_USD_TOKEN)
+                .nonce(10)
+                .gas(400000n)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.getOperationCount(), 3);
+            assert_1.default.strictEqual(tx.isBatch(), true);
+            assert_1.default.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);
+            const operations = tx.getOperations();
+            assert_1.default.strictEqual(operations[0].token, ALPHA_USD_TOKEN);
+            assert_1.default.strictEqual(operations[1].token, BETA_USD_TOKEN);
+            assert_1.default.strictEqual(operations[2].token, THETA_USD_TOKEN);
+        });
+    });
+    (0, mocha_1.describe)('Transaction Signing', () => {
+        (0, mocha_1.it)('should produce unsigned transaction with correct RLP structure', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+                .feeToken(ALPHA_USD_TOKEN)
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            const unsignedHex = await tx.serialize();
+            assert_1.default.ok(unsignedHex.startsWith(constants_1.AA_TRANSACTION_TYPE));
+            assert_1.default.strictEqual(tx.getSignature(), undefined);
+            // Verify RLP structure (13 fields for unsigned)
+            const rlpPart = '0x' + unsignedHex.slice(4);
+            const decoded = ethers_1.ethers.utils.RLP.decode(rlpPart);
+            assert_1.default.strictEqual(decoded.length, 13);
+        });
+        (0, mocha_1.it)('should apply signature and produce broadcast format', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+                .feeToken(ALPHA_USD_TOKEN)
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            tx.setSignature(tempo_1.SIGNATURE_TEST_DATA.validSignature);
+            const signedHex = await tx.toBroadcastFormat();
+            // Verify it includes signature (14 fields)
+            assert_1.default.ok(signedHex.startsWith(constants_1.AA_TRANSACTION_TYPE));
+            const rlpPart = '0x' + signedHex.slice(4);
+            const decoded = ethers_1.ethers.utils.RLP.decode(rlpPart);
+            assert_1.default.strictEqual(decoded.length, 14);
+            const storedSig = tx.getSignature();
+            assert_1.default.ok(storedSig);
+            assert_1.default.strictEqual(storedSig?.r, tempo_1.SIGNATURE_TEST_DATA.validSignature.r);
+        });
+    });
+    (0, mocha_1.describe)('Fee Token Selection', () => {
+        (0, mocha_1.it)('should pay fees with different token than transfer', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+                .feeToken(BETA_USD_TOKEN)
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.getOperations()[0].token, ALPHA_USD_TOKEN);
+            assert_1.default.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);
+        });
+        (0, mocha_1.it)('should build transaction without explicit fee token', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.getFeeToken(), undefined);
+            const serialized = await tx.serialize();
+            assert_1.default.ok(serialized.startsWith(constants_1.AA_TRANSACTION_TYPE));
+        });
+    });
+    (0, mocha_1.describe)('Transaction JSON', () => {
+        (0, mocha_1.it)('should produce complete JSON representation', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '123456', memo: '5' })
+                .feeToken(BETA_USD_TOKEN)
+                .nonce(42)
+                .gas(150000n)
+                .maxFeePerGas(3000000000n)
+                .maxPriorityFeePerGas(1500000000n);
+            const tx = (await builder.build());
+            const json = tx.toJson();
+            assert_1.default.strictEqual(json.type, constants_1.AA_TRANSACTION_TYPE);
+            assert_1.default.strictEqual(json.chainId, constants_1.TEMPO_CHAIN_IDS.TESTNET);
+            assert_1.default.strictEqual(json.nonce, 42);
+            assert_1.default.strictEqual(json.gas, '150000');
+            assert_1.default.strictEqual(json.feeToken, BETA_USD_TOKEN);
+            const ops = json.operations;
+            assert_1.default.strictEqual(ops[0].token, ALPHA_USD_TOKEN);
+            assert_1.default.strictEqual(ops[0].amount, '123456');
+            assert_1.default.strictEqual(ops[0].memo, '5');
+        });
+    });
+    (0, mocha_1.describe)('canBroadcast Check', () => {
+        (0, mocha_1.it)('should return true for valid transaction', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })
+                .feeToken(ALPHA_USD_TOKEN)
+                .nonce(0)
+                .gas(tempo_1.TX_PARAMS.defaultGas)
+                .maxFeePerGas(tempo_1.TX_PARAMS.defaultMaxFeePerGas)
+                .maxPriorityFeePerGas(tempo_1.TX_PARAMS.defaultMaxPriorityFeePerGas);
+            const tx = (await builder.build());
+            assert_1.default.strictEqual(tx.canBroadcast(), true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tip20.js","sourceRoot":"","sources":["../../../test/integration/tip20.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TIP-20 Integration Tests\n *\n * End-to-end flows for TIP-20 token transactions on Tempo using testnet token addresses.\n */\n\nimport assert from 'assert';\nimport { describe, it } from 'mocha';\nimport { ethers } from 'ethers';\nimport { coins } from '@bitgo-beta/statics';\nimport { Tip20TransactionBuilder } from '../../src/lib/transactionBuilder';\nimport { Tip20Transaction } from '../../src/lib/transaction';\nimport { Address } from '../../src/lib/types';\nimport { AA_TRANSACTION_TYPE, TEMPO_CHAIN_IDS } from '../../src/lib/constants';\nimport { TESTNET_TOKENS, TX_PARAMS, SIGNATURE_TEST_DATA, TEST_RECIPIENT_ADDRESS } from '../resources/tempo';\n\nconst mockCoinConfig = coins.get('ttempo');\n\nconst ALPHA_USD_TOKEN = TESTNET_TOKENS.alphaUSD.address as Address;\nconst BETA_USD_TOKEN = TESTNET_TOKENS.betaUSD.address as Address;\nconst THETA_USD_TOKEN = TESTNET_TOKENS.thetaUSD.address as Address;\nconst RECEIVER_ADDRESS = TEST_RECIPIENT_ADDRESS as Address;\n\ndescribe('TIP-20 Integration Tests', () => {\n  describe('Single Transfer', () => {\n    it('should build and serialize single TIP-20 transfer', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({\n          token: ALPHA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '1',\n          memo: '1',\n        })\n        .feeToken(ALPHA_USD_TOKEN)\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.ok(tx instanceof Tip20Transaction);\n      assert.strictEqual(tx.getOperationCount(), 1);\n      assert.strictEqual(tx.isBatch(), false);\n      assert.strictEqual(tx.getOperations()[0].memo, '1');\n\n      const serialized = await tx.serialize();\n      assert.ok(serialized.startsWith(AA_TRANSACTION_TYPE));\n    });\n  });\n\n  describe('Batch Transfer', () => {\n    it('should build multi-token batch transfer', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '15', memo: '1' })\n        .addOperation({ token: BETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '20', memo: '2' })\n        .addOperation({ token: THETA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '7', memo: '3' })\n        .feeToken(BETA_USD_TOKEN)\n        .nonce(10)\n        .gas(400000n)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.strictEqual(tx.getOperationCount(), 3);\n      assert.strictEqual(tx.isBatch(), true);\n      assert.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);\n\n      const operations = tx.getOperations();\n      assert.strictEqual(operations[0].token, ALPHA_USD_TOKEN);\n      assert.strictEqual(operations[1].token, BETA_USD_TOKEN);\n      assert.strictEqual(operations[2].token, THETA_USD_TOKEN);\n    });\n  });\n\n  describe('Transaction Signing', () => {\n    it('should produce unsigned transaction with correct RLP structure', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })\n        .feeToken(ALPHA_USD_TOKEN)\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const unsignedHex = await tx.serialize();\n\n      assert.ok(unsignedHex.startsWith(AA_TRANSACTION_TYPE));\n      assert.strictEqual(tx.getSignature(), undefined);\n\n      // Verify RLP structure (13 fields for unsigned)\n      const rlpPart = '0x' + unsignedHex.slice(4);\n      const decoded = ethers.utils.RLP.decode(rlpPart);\n      assert.strictEqual(decoded.length, 13);\n    });\n\n    it('should apply signature and produce broadcast format', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })\n        .feeToken(ALPHA_USD_TOKEN)\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      tx.setSignature(SIGNATURE_TEST_DATA.validSignature);\n\n      const signedHex = await tx.toBroadcastFormat();\n\n      // Verify it includes signature (14 fields)\n      assert.ok(signedHex.startsWith(AA_TRANSACTION_TYPE));\n      const rlpPart = '0x' + signedHex.slice(4);\n      const decoded = ethers.utils.RLP.decode(rlpPart);\n      assert.strictEqual(decoded.length, 14);\n\n      const storedSig = tx.getSignature();\n      assert.ok(storedSig);\n      assert.strictEqual(storedSig?.r, SIGNATURE_TEST_DATA.validSignature.r);\n    });\n  });\n\n  describe('Fee Token Selection', () => {\n    it('should pay fees with different token than transfer', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })\n        .feeToken(BETA_USD_TOKEN)\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.strictEqual(tx.getOperations()[0].token, ALPHA_USD_TOKEN);\n      assert.strictEqual(tx.getFeeToken(), BETA_USD_TOKEN);\n    });\n\n    it('should build transaction without explicit fee token', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n\n      assert.strictEqual(tx.getFeeToken(), undefined);\n      const serialized = await tx.serialize();\n      assert.ok(serialized.startsWith(AA_TRANSACTION_TYPE));\n    });\n  });\n\n  describe('Transaction JSON', () => {\n    it('should produce complete JSON representation', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '123456', memo: '5' })\n        .feeToken(BETA_USD_TOKEN)\n        .nonce(42)\n        .gas(150000n)\n        .maxFeePerGas(3000000000n)\n        .maxPriorityFeePerGas(1500000000n);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      const json = tx.toJson();\n\n      assert.strictEqual(json.type, AA_TRANSACTION_TYPE);\n      assert.strictEqual(json.chainId, TEMPO_CHAIN_IDS.TESTNET);\n      assert.strictEqual(json.nonce, 42);\n      assert.strictEqual(json.gas, '150000');\n      assert.strictEqual(json.feeToken, BETA_USD_TOKEN);\n\n      const ops = json.operations as any[];\n      assert.strictEqual(ops[0].token, ALPHA_USD_TOKEN);\n      assert.strictEqual(ops[0].amount, '123456');\n      assert.strictEqual(ops[0].memo, '5');\n    });\n  });\n\n  describe('canBroadcast Check', () => {\n    it('should return true for valid transaction', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n\n      builder\n        .addOperation({ token: ALPHA_USD_TOKEN, to: RECEIVER_ADDRESS, amount: '1' })\n        .feeToken(ALPHA_USD_TOKEN)\n        .nonce(0)\n        .gas(TX_PARAMS.defaultGas)\n        .maxFeePerGas(TX_PARAMS.defaultMaxFeePerGas)\n        .maxPriorityFeePerGas(TX_PARAMS.defaultMaxPriorityFeePerGas);\n\n      const tx = (await builder.build()) as Tip20Transaction;\n      assert.strictEqual(tx.canBroadcast(), true);\n    });\n  });\n});\n"]}

package/dist/test/resources/tempo.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Test resources for Tempo SDK
+ */
+export declare const TESTNET_TOKENS: {
+    pathUSD: {
+        address: string;
+        name: string;
+    };
+    alphaUSD: {
+        address: string;
+        name: string;
+    };
+    betaUSD: {
+        address: string;
+        name: string;
+    };
+    thetaUSD: {
+        address: string;
+        name: string;
+    };
+    usd1: {
+        address: string;
+        name: string;
+    };
+    stgUSD1: {
+        address: string;
+        name: string;
+    };
+};
+export declare const TEST_RECIPIENT_ADDRESS = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+export declare const TX_PARAMS: {
+    defaultGas: bigint;
+    defaultMaxFeePerGas: bigint;
+    defaultMaxPriorityFeePerGas: bigint;
+};
+export declare const SIGNATURE_TEST_DATA: {
+    validSignature: {
+        r: `0x${string}`;
+        s: `0x${string}`;
+        yParity: number;
+    };
+};
+export declare const MEMO_TEST_CASES: {
+    valid: {
+        input: string;
+        description: string;
+    }[];
+    invalid: {
+        input: string;
+        description: string;
+    }[];
+};
+export declare const ERROR_MESSAGES: {
+    noOperations: RegExp;
+    missingNonce: RegExp;
+    missingGas: RegExp;
+    missingMaxFeePerGas: RegExp;
+    missingMaxPriorityFeePerGas: RegExp;
+    invalidMemo: RegExp;
+};
+//# sourceMappingURL=tempo.d.ts.map

package/dist/test/resources/tempo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tempo.d.ts","sourceRoot":"","sources":["../../../test/resources/tempo.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CAyB1B,CAAC;AAGF,eAAO,MAAM,sBAAsB,+CAA+C,CAAC;AAMnF,eAAO,MAAM,SAAS;;;;CAIrB,CAAC;AAMF,eAAO,MAAM,mBAAmB;;WAE+C,KAAK,MAAM,EAAE;WACb,KAAK,MAAM,EAAE;;;CAG3F,CAAC;AAMF,eAAO,MAAM,eAAe;;;;;;;;;CAQ3B,CAAC;AAMF,eAAO,MAAM,cAAc;;;;;;;CAO1B,CAAC"}