@bitgo-beta/sdk-coin-tempo 1.0.1-beta.5 → 1.0.1-beta.50

package/dist/src/tip20Token.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @prettier
+ */
+import { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { GetSendMethodArgsOptions, SendMethodArgs } from '@bitgo-beta/abstract-eth';
+import { Tempo } from './tempo';
+/**
+ * TIP20 Token Configuration Interface
+ */
+export interface Tip20TokenConfig {
+    type: string;
+    coin: string;
+    network: 'Mainnet' | 'Testnet';
+    name: string;
+    tokenContractAddress: string;
+    decimalPlaces: number;
+}
+/**
+ * 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;
+    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 (optional)
+     */
+    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(): 'Mainnet' | 'Testnet';
+    /** Get the token contract address */
+    get tokenContractAddress(): string;
+    /** Get token decimal places */
+    get decimalPlaces(): number;
+    /** @inheritDoc */
+    getChain(): 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;AAEtG,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAEpF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,WAAW,EAAE,gBAAgB,CAAC;gBAElC,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,CAAC,YAAY,CAAC,EAAE,gBAAgB,EAAE,GAAG,oBAAoB,EAAE;IAezF,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,SAAS,GAAG,SAAS,CAEnC;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,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,198 @@
+"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 coinName = tokenConfig.network === 'Mainnet' ? 'tempo' : 'ttempo';
+        const staticsCoin = statics_1.coins.get(coinName);
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+    }
+    /**
+     * 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 (optional)
+     */
+    static createTokenConstructors(tokenConfigs) {
+        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 */
+    getFullName() {
+        return 'TIP20 Token';
+    }
+    /** @inheritDoc */
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+    /** @inheritDoc */
+    valuelessTransferAllowed() {
+        return false;
+    }
+    /** @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 } 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\n/**\n * TIP20 Token Configuration Interface\n */\nexport interface Tip20TokenConfig {\n  type: string; // Token identifier (e.g., 'tempo:usdc')\n  coin: string; // Base coin (e.g., 'tempo' or 'ttempo')\n  network: 'Mainnet' | 'Testnet';\n  name: string; // Token full name\n  tokenContractAddress: string; // Smart contract address (0x...)\n  decimalPlaces: number; // Token decimal places\n}\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\n  constructor(bitgo: BitGoBase, tokenConfig: Tip20TokenConfig) {\n    const coinName = tokenConfig.network === 'Mainnet' ? 'tempo' : 'ttempo';\n    const staticsCoin = coins.get(coinName);\n    super(bitgo, staticsCoin);\n    this.tokenConfig = tokenConfig;\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 (optional)\n   */\n  static createTokenConstructors(tokenConfigs?: Tip20TokenConfig[]): 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(): 'Mainnet' | 'Testnet' {\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  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 false;\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,2 @@
+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":""}

package/dist/test/integration/tip20.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mocha_1 = require("mocha");
+const transactionBuilder_1 = require("../../src/lib/transactionBuilder");
+const statics_1 = require("@bitgo-beta/statics");
+const mockCoinConfig = statics_1.coins.get('ttempo');
+(0, mocha_1.describe)('TIP-20 Integration Tests', () => {
+    const ALPHA_USD_TOKEN = '0x...';
+    const BETA_USD_TOKEN = '0x...';
+    const THETA_USD_TOKEN = '0x...';
+    const RECEIVER_ADDRESS = '0x...';
+    mocha_1.describe.skip('Single Transfer', () => {
+        (0, mocha_1.it)('should build single TIP-20 transfer without memo', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '1.0',
+            });
+            builder.feeToken(ALPHA_USD_TOKEN);
+            // TODO: const tx = await builder.build();
+        });
+        (0, mocha_1.it)('should build single TIP-20 transfer with memo', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '1.0',
+                memo: '12345',
+            });
+            builder.feeToken(ALPHA_USD_TOKEN);
+            // TODO: const tx = await builder.build();
+        });
+    });
+    mocha_1.describe.skip('Batch Transfer', () => {
+        (0, mocha_1.it)('should build batch transfer with multiple memos', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder
+                .addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '0.5',
+                memo: '1001',
+            })
+                .addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '0.3',
+                memo: '1002',
+            })
+                .addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '0.2',
+                memo: '1003',
+            });
+            builder.feeToken(ALPHA_USD_TOKEN);
+            // TODO: const tx = await builder.build();
+        });
+        (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: '1.5',
+                memo: '2001',
+            })
+                .addOperation({
+                token: BETA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '2.0',
+                memo: '2002',
+            })
+                .addOperation({
+                token: THETA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '0.75',
+                memo: '2003',
+            });
+            builder.feeToken(BETA_USD_TOKEN);
+            // TODO: const tx = await builder.build();
+        });
+    });
+    mocha_1.describe.skip('Transaction Signing', () => {
+        (0, mocha_1.it)('should sign and serialize transaction', async () => {
+            const builder = new transactionBuilder_1.Tip20TransactionBuilder(mockCoinConfig);
+            builder.addOperation({
+                token: ALPHA_USD_TOKEN,
+                to: RECEIVER_ADDRESS,
+                amount: '1.0',
+                memo: '9999',
+            });
+            builder.feeToken(ALPHA_USD_TOKEN);
+            // TODO: Implement signing with ethers.js Wallet
+            // TODO: const tx = await builder.build();
+            // TODO: tx.setSignature(signature);
+            // TODO: const serialized = await tx.toBroadcastFormat();
+        });
+    });
+    mocha_1.describe.skip('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.0',
+                memo: '5555',
+            });
+            builder.feeToken(BETA_USD_TOKEN);
+            // TODO: const tx = await builder.build();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tip20.js","sourceRoot":"","sources":["../../../test/integration/tip20.ts"],"names":[],"mappings":";;AAAA,iCAAqC;AACrC,yEAA2E;AAE3E,iDAA4C;AAE5C,MAAM,cAAc,GAAG,eAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAE3C,IAAA,gBAAQ,EAAC,0BAA0B,EAAE,GAAG,EAAE;IACxC,MAAM,eAAe,GAAG,OAAkB,CAAC;IAC3C,MAAM,cAAc,GAAG,OAAkB,CAAC;IAC1C,MAAM,eAAe,GAAG,OAAkB,CAAC;IAC3C,MAAM,gBAAgB,GAAG,OAAkB,CAAC;IAE5C,gBAAQ,CAAC,IAAI,CAAC,iBAAiB,EAAE,GAAG,EAAE;QACpC,IAAA,UAAE,EAAC,kDAAkD,EAAE,KAAK,IAAI,EAAE;YAChE,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO,CAAC,YAAY,CAAC;gBACnB,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;aACd,CAAC,CAAC;YACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAClC,0CAA0C;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAA,UAAE,EAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;YAC7D,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO,CAAC,YAAY,CAAC;gBACnB,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,OAAO;aACd,CAAC,CAAC;YACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAClC,0CAA0C;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,gBAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,GAAG,EAAE;QACnC,IAAA,UAAE,EAAC,iDAAiD,EAAE,KAAK,IAAI,EAAE;YAC/D,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO;iBACJ,YAAY,CAAC;gBACZ,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC;iBACD,YAAY,CAAC;gBACZ,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC;iBACD,YAAY,CAAC;gBACZ,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC,CAAC;YACL,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAClC,0CAA0C;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAA,UAAE,EAAC,yCAAyC,EAAE,KAAK,IAAI,EAAE;YACvD,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO;iBACJ,YAAY,CAAC;gBACZ,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC;iBACD,YAAY,CAAC;gBACZ,KAAK,EAAE,cAAc;gBACrB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC;iBACD,YAAY,CAAC;gBACZ,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,MAAM;gBACd,IAAI,EAAE,MAAM;aACb,CAAC,CAAC;YACL,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACjC,0CAA0C;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,gBAAQ,CAAC,IAAI,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACxC,IAAA,UAAE,EAAC,uCAAuC,EAAE,KAAK,IAAI,EAAE;YACrD,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO,CAAC,YAAY,CAAC;gBACnB,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC,CAAC;YACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;YAClC,gDAAgD;YAChD,0CAA0C;YAC1C,oCAAoC;YACpC,yDAAyD;QAC3D,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,gBAAQ,CAAC,IAAI,CAAC,qBAAqB,EAAE,GAAG,EAAE;QACxC,IAAA,UAAE,EAAC,oDAAoD,EAAE,KAAK,IAAI,EAAE;YAClE,MAAM,OAAO,GAAG,IAAI,4CAAuB,CAAC,cAAc,CAAC,CAAC;YAC5D,OAAO,CAAC,YAAY,CAAC;gBACnB,KAAK,EAAE,eAAe;gBACtB,EAAE,EAAE,gBAAgB;gBACpB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,MAAM;aACb,CAAC,CAAC;YACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACjC,0CAA0C;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { describe, it } from 'mocha';\nimport { Tip20TransactionBuilder } from '../../src/lib/transactionBuilder';\nimport { Address } from '../../src/lib/types';\nimport { coins } from '@bitgo-beta/statics';\n\nconst mockCoinConfig = coins.get('ttempo');\n\ndescribe('TIP-20 Integration Tests', () => {\n  const ALPHA_USD_TOKEN = '0x...' as Address;\n  const BETA_USD_TOKEN = '0x...' as Address;\n  const THETA_USD_TOKEN = '0x...' as Address;\n  const RECEIVER_ADDRESS = '0x...' as Address;\n\n  describe.skip('Single Transfer', () => {\n    it('should build single TIP-20 transfer without memo', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addOperation({\n        token: ALPHA_USD_TOKEN,\n        to: RECEIVER_ADDRESS,\n        amount: '1.0',\n      });\n      builder.feeToken(ALPHA_USD_TOKEN);\n      // TODO: const tx = await builder.build();\n    });\n\n    it('should build single TIP-20 transfer with memo', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addOperation({\n        token: ALPHA_USD_TOKEN,\n        to: RECEIVER_ADDRESS,\n        amount: '1.0',\n        memo: '12345',\n      });\n      builder.feeToken(ALPHA_USD_TOKEN);\n      // TODO: const tx = await builder.build();\n    });\n  });\n\n  describe.skip('Batch Transfer', () => {\n    it('should build batch transfer with multiple memos', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({\n          token: ALPHA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '0.5',\n          memo: '1001',\n        })\n        .addOperation({\n          token: ALPHA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '0.3',\n          memo: '1002',\n        })\n        .addOperation({\n          token: ALPHA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '0.2',\n          memo: '1003',\n        });\n      builder.feeToken(ALPHA_USD_TOKEN);\n      // TODO: const tx = await builder.build();\n    });\n\n    it('should build multi-token batch transfer', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder\n        .addOperation({\n          token: ALPHA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '1.5',\n          memo: '2001',\n        })\n        .addOperation({\n          token: BETA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '2.0',\n          memo: '2002',\n        })\n        .addOperation({\n          token: THETA_USD_TOKEN,\n          to: RECEIVER_ADDRESS,\n          amount: '0.75',\n          memo: '2003',\n        });\n      builder.feeToken(BETA_USD_TOKEN);\n      // TODO: const tx = await builder.build();\n    });\n  });\n\n  describe.skip('Transaction Signing', () => {\n    it('should sign and serialize transaction', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addOperation({\n        token: ALPHA_USD_TOKEN,\n        to: RECEIVER_ADDRESS,\n        amount: '1.0',\n        memo: '9999',\n      });\n      builder.feeToken(ALPHA_USD_TOKEN);\n      // TODO: Implement signing with ethers.js Wallet\n      // TODO: const tx = await builder.build();\n      // TODO: tx.setSignature(signature);\n      // TODO: const serialized = await tx.toBroadcastFormat();\n    });\n  });\n\n  describe.skip('Fee Token Selection', () => {\n    it('should pay fees with different token than transfer', async () => {\n      const builder = new Tip20TransactionBuilder(mockCoinConfig);\n      builder.addOperation({\n        token: ALPHA_USD_TOKEN,\n        to: RECEIVER_ADDRESS,\n        amount: '1.0',\n        memo: '5555',\n      });\n      builder.feeToken(BETA_USD_TOKEN);\n      // TODO: const tx = await builder.build();\n    });\n  });\n});\n"]}

package/dist/test/unit/transactionBuilder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transactionBuilder.d.ts.map

package/dist/test/unit/transactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../test/unit/transactionBuilder.ts"],"names":[],"mappings":""}