@bitgo-beta/sdk-coin-xdc 1.0.1-beta.856 → 1.0.1-beta.858

package/dist/src/xdcToken.d.ts

@@ -3,7 +3,7 @@
  */
 import { EthLikeTokenConfig } from '@bitgo-beta/statics';
 import { BitGoBase, CoinConstructor, NamedCoinConstructor, MPCAlgorithm } from '@bitgo-beta/sdk-core';
-import { CoinNames, EthLikeToken } from '@bitgo-beta/abstract-eth';
+import { CoinNames, EthLikeToken, VerifyEthTransactionOptions } from '@bitgo-beta/abstract-eth';
 import { TransactionBuilder } from './lib';
 export { EthLikeTokenConfig };
 export declare class XdcToken extends EthLikeToken {
@@ -23,5 +23,15 @@ export declare class XdcToken extends EthLikeToken {
     supportsTss(): boolean;
     /** @inheritDoc */
     getMPCAlgorithm(): MPCAlgorithm;
+    /**
+     * Verify if a tss transaction is valid
+     *
+     * @param {VerifyEthTransactionOptions} params
+     * @param {TransactionParams} params.txParams - params object passed to send
+     * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server
+     * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against
+     * @returns {boolean}
+     */
+    verifyTssTransaction(params: VerifyEthTransactionOptions): Promise<boolean>;
 }
 //# sourceMappingURL=xdcToken.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"xdcToken.d.ts","sourceRoot":"","sources":["../../src/xdcToken.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAS,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAU,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAAE,SAAS,EAAE,YAAY,EAAmC,MAAM,0BAA0B,CAAC;AAEpG,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B,qBAAa,QAAS,SAAQ,YAAY;IACxC,SAAgB,WAAW,EAAE,kBAAkB,CAAC;IAChD,MAAM,CAAC,SAAS,EAAE,SAAS,CAGzB;gBACU,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB;IAG7D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe;IAI1E,MAAM,CAAC,uBAAuB,IAAI,oBAAoB,EAAE;IAIxD,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD;;;;OAIG;IACG,+BAA+B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMtG,WAAW,IAAI,MAAM;IAIrB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;CAGhC"}
+{"version":3,"file":"xdcToken.d.ts","sourceRoot":"","sources":["../../src/xdcToken.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,kBAAkB,EAAS,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAU,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EACL,SAAS,EACT,YAAY,EAEZ,2BAA2B,EAC5B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B,qBAAa,QAAS,SAAQ,YAAY;IACxC,SAAgB,WAAW,EAAE,kBAAkB,CAAC;IAChD,MAAM,CAAC,SAAS,EAAE,SAAS,CAGzB;gBACU,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,kBAAkB;IAG7D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,GAAG,eAAe;IAI1E,MAAM,CAAC,uBAAuB,IAAI,oBAAoB,EAAE;IAIxD,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD;;;;OAIG;IACG,+BAA+B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMtG,WAAW,IAAI,MAAM;IAIrB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B;;;;;;;;OAQG;IACG,oBAAoB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,OAAO,CAAC;CAoBlF"}

package/dist/src/xdcToken.js

@@ -41,10 +41,34 @@ class XdcToken extends abstract_eth_1.EthLikeToken {
     getMPCAlgorithm() {
         return 'ecdsa';
     }
+    /**
+     * Verify if a tss transaction is valid
+     *
+     * @param {VerifyEthTransactionOptions} params
+     * @param {TransactionParams} params.txParams - params object passed to send
+     * @param {TransactionPrebuild} params.txPrebuild - prebuild object returned by server
+     * @param {Wallet} params.wallet - Wallet object to obtain keys to verify against
+     * @returns {boolean}
+     */
+    async verifyTssTransaction(params) {
+        const { txParams, txPrebuild, wallet } = params;
+        if (!txParams?.recipients &&
+            !(txParams.prebuildTx?.consolidateId ||
+                (txParams.type && ['acceleration', 'fillNonce', 'transferToken'].includes(txParams.type)))) {
+            throw new Error(`missing txParams`);
+        }
+        if (!wallet || !txPrebuild) {
+            throw new Error(`missing params`);
+        }
+        if (txParams.hop && txParams.recipients && txParams.recipients.length > 1) {
+            throw new Error(`tx cannot be both a batch and hop transaction`);
+        }
+        return true;
+    }
 }
 exports.XdcToken = XdcToken;
 XdcToken.coinNames = {
     Mainnet: 'xdc',
     Testnet: 'txdc',
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieGRjVG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMveGRjVG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDSCxpREFBZ0U7QUFDaEUsbURBQThHO0FBQzlHLDJEQUtrQztBQUVsQywrQkFBMkM7QUFHM0MsTUFBYSxRQUFTLFNBQVEsMkJBQVk7SUFNeEMsWUFBWSxLQUFnQixFQUFFLFdBQStCO1FBQzNELEtBQUssQ0FBQyxLQUFLLEVBQUUsV0FBVyxFQUFFLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBQ0QsTUFBTSxDQUFDLHNCQUFzQixDQUFDLE1BQTBCO1FBQ3RELE9BQU8sS0FBSyxDQUFDLHNCQUFzQixDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDbEUsQ0FBQztJQUVELE1BQU0sQ0FBQyx1QkFBdUI7UUFDNUIsT0FBTyxLQUFLLENBQUMsdUJBQXVCLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFFUyxxQkFBcUI7UUFDN0IsT0FBTyxJQUFJLHdCQUFrQixDQUFDLGVBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUssQ0FBQywrQkFBK0IsQ0FBQyxLQUE2QjtRQUNqRSxNQUFNLFFBQVEsR0FBRyxpQkFBTSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsbUJBQW1CLENBQUM7UUFDOUUsTUFBTSxXQUFXLEdBQUcsaUJBQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLGtCQUFrQixDQUFDO1FBQ2hGLE9BQU8sTUFBTSxJQUFBLDhDQUErQixFQUFDLEtBQUssRUFBRSxXQUFxQixFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ3ZGLENBQUM7SUFFRCxXQUFXO1FBQ1QsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztJQUVELFdBQVc7UUFDVCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFFRCxrQkFBa0I7SUFDbEIsZUFBZTtRQUNiLE9BQU8sT0FBTyxDQUFDO0lBQ2pCLENBQUM7SUFFRDs7Ozs7Ozs7T0FRRztJQUNILEtBQUssQ0FBQyxvQkFBb0IsQ0FBQyxNQUFtQztRQUM1RCxNQUFNLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsR0FBRyxNQUFNLENBQUM7UUFDaEQsSUFDRSxDQUFDLFFBQVEsRUFBRSxVQUFVO1lBQ3JCLENBQUMsQ0FDQyxRQUFRLENBQUMsVUFBVSxFQUFFLGFBQWE7Z0JBQ2xDLENBQUMsUUFBUSxDQUFDLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRSxXQUFXLEVBQUUsZUFBZSxDQUFDLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUMxRixFQUNELENBQUM7WUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFDdEMsQ0FBQztRQUNELElBQUksQ0FBQyxNQUFNLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUMzQixNQUFNLElBQUksS0FBSyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDcEMsQ0FBQztRQUNELElBQUksUUFBUSxDQUFDLEdBQUcsSUFBSSxRQUFRLENBQUMsVUFBVSxJQUFJLFFBQVEsQ0FBQyxVQUFVLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQzFFLE1BQU0sSUFBSSxLQUFLLENBQUMsK0NBQStDLENBQUMsQ0FBQztRQUNuRSxDQUFDO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDOztBQXpFSCw0QkEwRUM7QUF4RVEsa0JBQVMsR0FBYztJQUM1QixPQUFPLEVBQUUsS0FBSztJQUNkLE9BQU8sRUFBRSxNQUFNO0NBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwcmV0dGllclxuICovXG5pbXBvcnQgeyBFdGhMaWtlVG9rZW5Db25maWcsIGNvaW5zIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBCaXRHb0Jhc2UsIENvaW5Db25zdHJ1Y3RvciwgTmFtZWRDb2luQ29uc3RydWN0b3IsIGNvbW1vbiwgTVBDQWxnb3JpdGhtIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHtcbiAgQ29pbk5hbWVzLFxuICBFdGhMaWtlVG9rZW4sXG4gIHJlY292ZXJ5QmxvY2tjaGFpbkV4cGxvcmVyUXVlcnksXG4gIFZlcmlmeUV0aFRyYW5zYWN0aW9uT3B0aW9ucyxcbn0gZnJvbSAnQGJpdGdvLWJldGEvYWJzdHJhY3QtZXRoJztcblxuaW1wb3J0IHsgVHJhbnNhY3Rpb25CdWlsZGVyIH0gZnJvbSAnLi9saWInO1xuZXhwb3J0IHsgRXRoTGlrZVRva2VuQ29uZmlnIH07XG5cbmV4cG9ydCBjbGFzcyBYZGNUb2tlbiBleHRlbmRzIEV0aExpa2VUb2tlbiB7XG4gIHB1YmxpYyByZWFkb25seSB0b2tlbkNvbmZpZzogRXRoTGlrZVRva2VuQ29uZmlnO1xuICBzdGF0aWMgY29pbk5hbWVzOiBDb2luTmFtZXMgPSB7XG4gICAgTWFpbm5ldDogJ3hkYycsXG4gICAgVGVzdG5ldDogJ3R4ZGMnLFxuICB9O1xuICBjb25zdHJ1Y3RvcihiaXRnbzogQml0R29CYXNlLCB0b2tlbkNvbmZpZzogRXRoTGlrZVRva2VuQ29uZmlnKSB7XG4gICAgc3VwZXIoYml0Z28sIHRva2VuQ29uZmlnLCBYZGNUb2tlbi5jb2luTmFtZXMpO1xuICB9XG4gIHN0YXRpYyBjcmVhdGVUb2tlbkNvbnN0cnVjdG9yKGNvbmZpZzogRXRoTGlrZVRva2VuQ29uZmlnKTogQ29pbkNvbnN0cnVjdG9yIHtcbiAgICByZXR1cm4gc3VwZXIuY3JlYXRlVG9rZW5Db25zdHJ1Y3Rvcihjb25maWcsIFhkY1Rva2VuLmNvaW5OYW1lcyk7XG4gIH1cblxuICBzdGF0aWMgY3JlYXRlVG9rZW5Db25zdHJ1Y3RvcnMoKTogTmFtZWRDb2luQ29uc3RydWN0b3JbXSB7XG4gICAgcmV0dXJuIHN1cGVyLmNyZWF0ZVRva2VuQ29uc3RydWN0b3JzKFhkY1Rva2VuLmNvaW5OYW1lcyk7XG4gIH1cblxuICBwcm90ZWN0ZWQgZ2V0VHJhbnNhY3Rpb25CdWlsZGVyKCk6IFRyYW5zYWN0aW9uQnVpbGRlciB7XG4gICAgcmV0dXJuIG5ldyBUcmFuc2FjdGlvbkJ1aWxkZXIoY29pbnMuZ2V0KHRoaXMuZ2V0QmFzZUNoYWluKCkpKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBNYWtlIGEgcXVlcnkgdG8gWERDIEV0aGVyc2NhbiBmb3IgaW5mb3JtYXRpb24gc3VjaCBhcyBiYWxhbmNlLCB0b2tlbiBiYWxhbmNlLCBzb2xpZGl0eSBjYWxsc1xuICAgKiBAcGFyYW0ge09iamVjdH0gcXVlcnkga2V5LXZhbHVlIHBhaXJzIG9mIHBhcmFtZXRlcnMgdG8gYXBwZW5kIGFmdGVyIC9hcGlcbiAgICogQHJldHVybnMge1Byb21pc2U8T2JqZWN0Pn0gcmVzcG9uc2UgZnJvbSBYREMgRXRoZXJzY2FuXG4gICAqL1xuICBhc3luYyByZWNvdmVyeUJsb2NrY2hhaW5FeHBsb3JlclF1ZXJ5KHF1ZXJ5OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+KTogUHJvbWlzZTxSZWNvcmQ8c3RyaW5nLCB1bmtub3duPj4ge1xuICAgIGNvbnN0IGFwaVRva2VuID0gY29tbW9uLkVudmlyb25tZW50c1t0aGlzLmJpdGdvLmdldEVudigpXS54ZGNFeHBsb3JlckFwaVRva2VuO1xuICAgIGNvbnN0IGV4cGxvcmVyVXJsID0gY29tbW9uLkVudmlyb25tZW50c1t0aGlzLmJpdGdvLmdldEVudigpXS54ZGNFeHBsb3JlckJhc2VVcmw7XG4gICAgcmV0dXJuIGF3YWl0IHJlY292ZXJ5QmxvY2tjaGFpbkV4cGxvcmVyUXVlcnkocXVlcnksIGV4cGxvcmVyVXJsIGFzIHN0cmluZywgYXBpVG9rZW4pO1xuICB9XG5cbiAgZ2V0RnVsbE5hbWUoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gJ1hEQyBUb2tlbic7XG4gIH1cblxuICBzdXBwb3J0c1RzcygpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxuXG4gIC8qKiBAaW5oZXJpdERvYyAqL1xuICBnZXRNUENBbGdvcml0aG0oKTogTVBDQWxnb3JpdGhtIHtcbiAgICByZXR1cm4gJ2VjZHNhJztcbiAgfVxuXG4gIC8qKlxuICAgKiBWZXJpZnkgaWYgYSB0c3MgdHJhbnNhY3Rpb24gaXMgdmFsaWRcbiAgICpcbiAgICogQHBhcmFtIHtWZXJpZnlFdGhUcmFuc2FjdGlvbk9wdGlvbnN9IHBhcmFtc1xuICAgKiBAcGFyYW0ge1RyYW5zYWN0aW9uUGFyYW1zfSBwYXJhbXMudHhQYXJhbXMgLSBwYXJhbXMgb2JqZWN0IHBhc3NlZCB0byBzZW5kXG4gICAqIEBwYXJhbSB7VHJhbnNhY3Rpb25QcmVidWlsZH0gcGFyYW1zLnR4UHJlYnVpbGQgLSBwcmVidWlsZCBvYmplY3QgcmV0dXJuZWQgYnkgc2VydmVyXG4gICAqIEBwYXJhbSB7V2FsbGV0fSBwYXJhbXMud2FsbGV0IC0gV2FsbGV0IG9iamVjdCB0byBvYnRhaW4ga2V5cyB0byB2ZXJpZnkgYWdhaW5zdFxuICAgKiBAcmV0dXJucyB7Ym9vbGVhbn1cbiAgICovXG4gIGFzeW5jIHZlcmlmeVRzc1RyYW5zYWN0aW9uKHBhcmFtczogVmVyaWZ5RXRoVHJhbnNhY3Rpb25PcHRpb25zKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgY29uc3QgeyB0eFBhcmFtcywgdHhQcmVidWlsZCwgd2FsbGV0IH0gPSBwYXJhbXM7XG4gICAgaWYgKFxuICAgICAgIXR4UGFyYW1zPy5yZWNpcGllbnRzICYmXG4gICAgICAhKFxuICAgICAgICB0eFBhcmFtcy5wcmVidWlsZFR4Py5jb25zb2xpZGF0ZUlkIHx8XG4gICAgICAgICh0eFBhcmFtcy50eXBlICYmIFsnYWNjZWxlcmF0aW9uJywgJ2ZpbGxOb25jZScsICd0cmFuc2ZlclRva2VuJ10uaW5jbHVkZXModHhQYXJhbXMudHlwZSkpXG4gICAgICApXG4gICAgKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoYG1pc3NpbmcgdHhQYXJhbXNgKTtcbiAgICB9XG4gICAgaWYgKCF3YWxsZXQgfHwgIXR4UHJlYnVpbGQpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgbWlzc2luZyBwYXJhbXNgKTtcbiAgICB9XG4gICAgaWYgKHR4UGFyYW1zLmhvcCAmJiB0eFBhcmFtcy5yZWNpcGllbnRzICYmIHR4UGFyYW1zLnJlY2lwaWVudHMubGVuZ3RoID4gMSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGB0eCBjYW5ub3QgYmUgYm90aCBhIGJhdGNoIGFuZCBob3AgdHJhbnNhY3Rpb25gKTtcbiAgICB9XG5cbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxufVxuIl19

package/dist/test/resources.d.ts

@@ -10,6 +10,27 @@ export declare const mockDataUnsignedSweep: {
     getBalanceRequest: Record<string, string>;
     getBalanceResponse: Record<string, unknown>;
 };
+export declare const mockTokenTransferData: {
+    txRequestId: string;
+    walletId: string;
+    serializedTxHex: string;
+    signableHex: string;
+    tokenContractAddress: string;
+    recipientAddress: string;
+    senderAddress: string;
+    tokenAmount: string;
+    feeInfo: {
+        fee: number;
+        feeString: string;
+    };
+    txPrebuild: {
+        txHex: string;
+        recipients: {
+            address: string;
+            amount: string;
+        }[];
+    };
+};
 export declare const mockDataNonBitGoRecovery: {
     recoveryDestination: string;
     userKeyData: string;

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

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../test/resources.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,qBAAqB;;;;;;;;;;;CAajC,CAAC;AAkCF,eAAO,MAAM,wBAAwB;;;;;;;;;;CAYpC,CAAC"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../test/resources.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,qBAAqB;;;;;;;;;;;CAajC,CAAC;AAmCF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;CAyBjC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;CAYpC,CAAC"}

package/dist/test/resources.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockDataNonBitGoRecovery = exports.mockDataUnsignedSweep = void 0;
+exports.mockDataNonBitGoRecovery = exports.mockTokenTransferData = exports.mockDataUnsignedSweep = void 0;
 const getTxListRequestUnsignedSweep = {
     chainid: '51',
     module: 'account',
@@ -69,6 +69,30 @@ const getBalanceResponseNonBitGoRecovery = {
     result: '100000000000000000',
     message: 'OK',
 };
+// Mock data for txdc:tmt token transfer TSS transaction
+exports.mockTokenTransferData = {
+    txRequestId: '2475368d-f604-46e3-a743-e32f663fa350',
+    walletId: '695e1ca4fb4a739c8c6f9b49120c55c7',
+    serializedTxHex: 'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240808080',
+    signableHex: 'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240338080',
+    tokenContractAddress: '0xb283ec8dad644effc5c4c50bb7bb21442ac3c2db',
+    recipientAddress: '0x421cdf5e890070c28db0fd8e4bf87deac0cd0ffc',
+    senderAddress: '0x6aafaddf545f96772140f0008190c176a065df9a',
+    tokenAmount: '1000000',
+    feeInfo: {
+        fee: 7500000000000000,
+        feeString: '7500000000000000',
+    },
+    txPrebuild: {
+        txHex: 'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240808080',
+        recipients: [
+            {
+                address: '0x421cdf5e890070c28db0fd8e4bf87deac0cd0ffc',
+                amount: '1000000',
+            },
+        ],
+    },
+};
 exports.mockDataNonBitGoRecovery = {
     recoveryDestination: '0xd76b586901850f2c656db0cbef795c0851bbec35',
     userKeyData: '{"iv":"XeXwD5B465wYvao9WFZC7A==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"caDtzBCF3IA=","ct":"0qr0YV2DgN68F9luNpjFQhwDTIXwyTTYdQirvbgITHqIDmITmV1IMgkKIdzSZBfmLkB6bG46oVF4snVG7lXEJz2twrutI01g59xjw88ULgR5wV5ZdFrGcmNZvOQ1H5imoWGS8bVKONmeF55TBgi49r9x3dsmgWvJ/EHeApj/FrAP1BLX/Rgl57kZqnNoryl55P8L2cJtJE1weDBD+/GsggdrO/dYBmihKTWyTBVa7UBIIgV5wOd4RXbZN1Hg2Vc0bY56KrpZbY1CsdQiIwH3tkKFPdqthlHVEfS8XViaYVl0Go3C/mUMYZH7CTg/s4LMpdlWzh3iRnmGercvIFZBfcehgNVv9H/OctYZnKfUdI5mZsVGxQRIMWr8oFbmjR3pYJ94oxS8assAzl7hNI4RJi/u4N9/5VJIi//069zsMsgA+k4b3u3xvivkTjO5sscAPs/Sp0mb5QLQhP48D/sHIYwhQiThJaH+flSoUQu5LNWmucmYr08lRRiI07O7DZAY2pplLSvBfkrBtgTgi+rLN95lKkxi7PYTGWuek1Sd/XiXit6EJ5FImYH2eKEVgatYvKfj/BdNJ2iHmeaykajtjpr21lt0Iqk98iZLZfCp5w4hfHHHB4QCrBzCAeG2MEPqmrAN67z4gMxUbkI+j9lYp5SyvlFmDIm78SyQ60371Wfr+7b4+wFqPq9fumXBZ4i0xYbcWTrKjYrn5bO5o3LWiRoh7EW8mzbMIC2m/DwIwdCHodbz4g31Psnk6Yk6UqEMq5JhOoUJYuVhYthNmbRlI59UDg+rz/HO9nYnZqsUgubSKcZArqM1J4T4+EDKuHtgnCQm2hqHlsJu+/n73jU33GEm86pDdcb8udHsfPCvhEIuLw6ZyThiX8JEOCi8Ueb0GPL31MSkJ7L7cOizgp6lHgs4nZorZfUIKjDd3twcpBNXjT15KEQbrW8RQChXmVl0b5N8BAom6e9Xpz2kDRGbvbYfBOdiht5Vr5Sm7prAQVVCZTWq6/qOZFWr7LJ+Cdw1qYt64UFcBHNtaX3d5WOMNNMqesrglVTW7w2Gscu7XaxoA4cTOKvMemG1cWTag3kr8oNgtz5gXsfbSo7CJrN8vw=="}',
@@ -80,4 +104,4 @@ exports.mockDataNonBitGoRecovery = {
     getBalanceRequest: getBalanceRequestNonBitGoRecovery,
     getBalanceResponse: getBalanceResponseNonBitGoRecovery,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resources.js","sourceRoot":"","sources":["../../test/resources.ts"],"names":[],"mappings":";;;AAAA,MAAM,6BAA6B,GAA2B;IAC5D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,8BAA8B,GAA4B;IAC9D,MAAM,EAAE,GAAG;IACX,MAAM,EAAE;QACN;YACE,IAAI,EAAE,oEAAoE;YAC1E,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,4CAA4C;SACnD;KACF;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,MAAM,8BAA8B,GAA2B;IAC7D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,+BAA+B,GAA4B;IAC/D,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,oBAAoB;IAC5B,OAAO,EAAE,IAAI;CACd,CAAC;AAEW,QAAA,qBAAqB,GAAG;IACnC,OAAO,EACL,oIAAoI;IACtI,SAAS,EACP,oIAAoI;IACtI,cAAc,EAAE,KAAK;IACrB,cAAc,EAAE,EAAE;IAClB,iBAAiB,EAAE,4CAA4C;IAC/D,mBAAmB,EAAE,4CAA4C;IACjE,gBAAgB,EAAE,6BAA6B;IAC/C,iBAAiB,EAAE,8BAA8B;IACjD,iBAAiB,EAAE,8BAA8B;IACjD,kBAAkB,EAAE,+BAA+B;CACpD,CAAC;AAEF,MAAM,gCAAgC,GAA2B;IAC/D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,iCAAiC,GAA4B;IACjE,MAAM,EAAE,GAAG;IACX,MAAM,EAAE;QACN;YACE,IAAI,EAAE,oEAAoE;YAC1E,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,4CAA4C;SACnD;KACF;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,MAAM,iCAAiC,GAA2B;IAChE,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,kCAAkC,GAA4B;IAClE,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,oBAAoB;IAC5B,OAAO,EAAE,IAAI;CACd,CAAC;AAEW,QAAA,wBAAwB,GAAG;IACtC,mBAAmB,EAAE,4CAA4C;IACjE,WAAW,EACT,ouCAAouC;IACtuC,aAAa,EACX,ouCAAouC;IACtuC,gBAAgB,EAAE,iBAAiB;IACnC,iBAAiB,EAAE,4CAA4C;IAC/D,gBAAgB,EAAE,gCAAgC;IAClD,iBAAiB,EAAE,iCAAiC;IACpD,iBAAiB,EAAE,iCAAiC;IACpD,kBAAkB,EAAE,kCAAkC;CACvD,CAAC","sourcesContent":["const getTxListRequestUnsignedSweep: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'txlist',\n  address: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n};\n\nconst getTxListResponseUnsignedSweep: Record<string, unknown> = {\n  status: '1',\n  result: [\n    {\n      hash: '0xede855d43d70ea1bb75db63d4f75113dae0845f0d4bdb0b2d8bda55249c70812',\n      nonce: '23',\n      from: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n    },\n  ],\n  message: 'OK',\n};\n\nconst getBalanceRequestUnsignedSweep: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'balance',\n  address: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n};\n\nconst getBalanceResponseUnsignedSweep: Record<string, unknown> = {\n  status: '1',\n  result: '100000000000000000',\n  message: 'OK',\n};\n\nexport const mockDataUnsignedSweep = {\n  userKey:\n    '029d2ded2d39ee7cd8d8bbba8b25e4c60bb09297936fa6b223de1f495b5ee20dcaf762367f9691f7719cb5e13e59d725669a18aad1e2522dd141fa4c7fd3d25c17',\n  backupKey:\n    '029d2ded2d39ee7cd8d8bbba8b25e4c60bb09297936fa6b223de1f495b5ee20dcaf762367f9691f7719cb5e13e59d725669a18aad1e2522dd141fa4c7fd3d25c17',\n  derivationPath: 'm/0',\n  derivationSeed: '',\n  walletBaseAddress: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n  recoveryDestination: '0xd76b586901850f2c656db0cbef795c0851bbec35',\n  getTxListRequest: getTxListRequestUnsignedSweep,\n  getTxListResponse: getTxListResponseUnsignedSweep,\n  getBalanceRequest: getBalanceRequestUnsignedSweep,\n  getBalanceResponse: getBalanceResponseUnsignedSweep,\n};\n\nconst getTxListRequestNonBitGoRecovery: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'txlist',\n  address: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n};\n\nconst getTxListResponseNonBitGoRecovery: Record<string, unknown> = {\n  status: '1',\n  result: [\n    {\n      hash: '0xede855d43d70ea1bb75db63d4f75113dae0845f0d4bdb0b2d8bda55249c70812',\n      nonce: '23',\n      from: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n    },\n  ],\n  message: 'OK',\n};\n\nconst getBalanceRequestNonBitGoRecovery: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'balance',\n  address: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n};\n\nconst getBalanceResponseNonBitGoRecovery: Record<string, unknown> = {\n  status: '1',\n  result: '100000000000000000',\n  message: 'OK',\n};\n\nexport const mockDataNonBitGoRecovery = {\n  recoveryDestination: '0xd76b586901850f2c656db0cbef795c0851bbec35',\n  userKeyData:\n    '{\"iv\":\"XeXwD5B465wYvao9WFZC7A==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"caDtzBCF3IA=\",\"ct\":\"0qr0YV2DgN68F9luNpjFQhwDTIXwyTTYdQirvbgITHqIDmITmV1IMgkKIdzSZBfmLkB6bG46oVF4snVG7lXEJz2twrutI01g59xjw88ULgR5wV5ZdFrGcmNZvOQ1H5imoWGS8bVKONmeF55TBgi49r9x3dsmgWvJ/EHeApj/FrAP1BLX/Rgl57kZqnNoryl55P8L2cJtJE1weDBD+/GsggdrO/dYBmihKTWyTBVa7UBIIgV5wOd4RXbZN1Hg2Vc0bY56KrpZbY1CsdQiIwH3tkKFPdqthlHVEfS8XViaYVl0Go3C/mUMYZH7CTg/s4LMpdlWzh3iRnmGercvIFZBfcehgNVv9H/OctYZnKfUdI5mZsVGxQRIMWr8oFbmjR3pYJ94oxS8assAzl7hNI4RJi/u4N9/5VJIi//069zsMsgA+k4b3u3xvivkTjO5sscAPs/Sp0mb5QLQhP48D/sHIYwhQiThJaH+flSoUQu5LNWmucmYr08lRRiI07O7DZAY2pplLSvBfkrBtgTgi+rLN95lKkxi7PYTGWuek1Sd/XiXit6EJ5FImYH2eKEVgatYvKfj/BdNJ2iHmeaykajtjpr21lt0Iqk98iZLZfCp5w4hfHHHB4QCrBzCAeG2MEPqmrAN67z4gMxUbkI+j9lYp5SyvlFmDIm78SyQ60371Wfr+7b4+wFqPq9fumXBZ4i0xYbcWTrKjYrn5bO5o3LWiRoh7EW8mzbMIC2m/DwIwdCHodbz4g31Psnk6Yk6UqEMq5JhOoUJYuVhYthNmbRlI59UDg+rz/HO9nYnZqsUgubSKcZArqM1J4T4+EDKuHtgnCQm2hqHlsJu+/n73jU33GEm86pDdcb8udHsfPCvhEIuLw6ZyThiX8JEOCi8Ueb0GPL31MSkJ7L7cOizgp6lHgs4nZorZfUIKjDd3twcpBNXjT15KEQbrW8RQChXmVl0b5N8BAom6e9Xpz2kDRGbvbYfBOdiht5Vr5Sm7prAQVVCZTWq6/qOZFWr7LJ+Cdw1qYt64UFcBHNtaX3d5WOMNNMqesrglVTW7w2Gscu7XaxoA4cTOKvMemG1cWTag3kr8oNgtz5gXsfbSo7CJrN8vw==\"}',\n  backupKeyData:\n    '{\"iv\":\"J32VIJhO9Cbf5bqcv75Kag==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"ZQ5VsHdXM4Q=\",\"ct\":\"XTgAUy8TZALKtt/PtJGAWbHfuExH5C5yw3y8EryrcY3uZdektl3WkL4KHHGTtL9yzssCTOWUMTemoAKipd+W/3mpZuQ88p+lloIgU7Tce3RLBG+gu665bsvTUuVpfMrpZHxDXXVMzwoUVHaxwfvu2tgduDnpkD/BX2RN5qfI6P6zz5r8UuWbiDPKEaqpcAHQ+RBitBQiOxNAlRNYexnUx1pCqcK08hqrqdQvx7elXXdCI3TwepGW7QwRzWa9pxvM9d85AWESueJ2B4JrZ5bkrIzXixGJcoUAJVvGfD69zoLUH9einnMafpocETBUDQyevC/j/1FwgZUCeGcb4U9N9tQJtR0fozzgpAo91nWA5UfkD2+hzRvz2p1Dmc+4bNb6s/7vK+BIOdpe4blzI43PxMLoBGkEQHlGHYCrOUnbV7dcxlyPv0qfom8K4f6/74YEKiMPjwA3sCcntWboW8gUPHF2xx/WAgmHI9DOiXsCJZMHx4GiZmY/pR9RVe/OeFAqPLWJoT6KaizTJD3So4/G5oHKPgTQbMIPi1lYtqKdOuhycISsaEgnkG1a8Tq5CN0tk5VywSmj4kSrqqjcp7kbAW+ViaNkZLuSibomK9AvuOGkEZBqDEuyFJnS4oayQTLxnstzO1JJGhmrCskH9B/QIIrUVl1IOv/IVyPg4M7T1g0+YfHdAXduLXu9bjHkqzGaSQZu35bs5QKy0bKEhAwoj+zgYAF/gZBH0/iPzrWM2xu/HMeQKwI0KFLOiBx3cMmNYE+Fb6vCjpVXBTYYUCBOjRnrAuR/lc3AnjAefCMAD89+FQ+QW5IzZv97lrSw0Rb+DIctfXddUKK7yyBe8CcZWU1dGAYsb/hk+H5lTZJBur5M3a1vzPMi68HKnRt7XZmyBsvPA8t0JVJmlc0RejqDrcps4uKjKdMaDNOvBzmEijdVv8N5q0Ng+yHwq3BolqoYn4mVJOrMuRlZt4pODkI8uOU1Ha/VStLzhT2HFexZ+Y0JzM0DS5hsygHt4Dz6/RfZTKHYvxzuRiHNLbmNcOBvVbBOL2Lm+Dlo3fFuVD3fS08vJuafc/uAfatpRwRqgE/EzvZOpnZyHcr4lUVEhRrDYw==\"}',\n  walletPassphrase: 'prithvishet2503',\n  walletRootAddress: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n  getTxListRequest: getTxListRequestNonBitGoRecovery,\n  getTxListResponse: getTxListResponseNonBitGoRecovery,\n  getBalanceRequest: getBalanceRequestNonBitGoRecovery,\n  getBalanceResponse: getBalanceResponseNonBitGoRecovery,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resources.js","sourceRoot":"","sources":["../../test/resources.ts"],"names":[],"mappings":";;;AAAA,MAAM,6BAA6B,GAA2B;IAC5D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,8BAA8B,GAA4B;IAC9D,MAAM,EAAE,GAAG;IACX,MAAM,EAAE;QACN;YACE,IAAI,EAAE,oEAAoE;YAC1E,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,4CAA4C;SACnD;KACF;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,MAAM,8BAA8B,GAA2B;IAC7D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,+BAA+B,GAA4B;IAC/D,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,oBAAoB;IAC5B,OAAO,EAAE,IAAI;CACd,CAAC;AAEW,QAAA,qBAAqB,GAAG;IACnC,OAAO,EACL,oIAAoI;IACtI,SAAS,EACP,oIAAoI;IACtI,cAAc,EAAE,KAAK;IACrB,cAAc,EAAE,EAAE;IAClB,iBAAiB,EAAE,4CAA4C;IAC/D,mBAAmB,EAAE,4CAA4C;IACjE,gBAAgB,EAAE,6BAA6B;IAC/C,iBAAiB,EAAE,8BAA8B;IACjD,iBAAiB,EAAE,8BAA8B;IACjD,kBAAkB,EAAE,+BAA+B;CACpD,CAAC;AAEF,MAAM,gCAAgC,GAA2B;IAC/D,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,iCAAiC,GAA4B;IACjE,MAAM,EAAE,GAAG;IACX,MAAM,EAAE;QACN;YACE,IAAI,EAAE,oEAAoE;YAC1E,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,4CAA4C;SACnD;KACF;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,MAAM,iCAAiC,GAA2B;IAChE,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,SAAS;IACjB,MAAM,EAAE,SAAS;IACjB,OAAO,EAAE,4CAA4C;CACtD,CAAC;AAEF,MAAM,kCAAkC,GAA4B;IAClE,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,oBAAoB;IAC5B,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,wDAAwD;AAC3C,QAAA,qBAAqB,GAAG;IACnC,WAAW,EAAE,sCAAsC;IACnD,QAAQ,EAAE,kCAAkC;IAC5C,eAAe,EACb,0NAA0N;IAC5N,WAAW,EACT,0NAA0N;IAC5N,oBAAoB,EAAE,4CAA4C;IAClE,gBAAgB,EAAE,4CAA4C;IAC9D,aAAa,EAAE,4CAA4C;IAC3D,WAAW,EAAE,SAAS;IACtB,OAAO,EAAE;QACP,GAAG,EAAE,gBAAgB;QACrB,SAAS,EAAE,kBAAkB;KAC9B;IACD,UAAU,EAAE;QACV,KAAK,EACH,0NAA0N;QAC5N,UAAU,EAAE;YACV;gBACE,OAAO,EAAE,4CAA4C;gBACrD,MAAM,EAAE,SAAS;aAClB;SACF;KACF;CACF,CAAC;AAEW,QAAA,wBAAwB,GAAG;IACtC,mBAAmB,EAAE,4CAA4C;IACjE,WAAW,EACT,ouCAAouC;IACtuC,aAAa,EACX,ouCAAouC;IACtuC,gBAAgB,EAAE,iBAAiB;IACnC,iBAAiB,EAAE,4CAA4C;IAC/D,gBAAgB,EAAE,gCAAgC;IAClD,iBAAiB,EAAE,iCAAiC;IACpD,iBAAiB,EAAE,iCAAiC;IACpD,kBAAkB,EAAE,kCAAkC;CACvD,CAAC","sourcesContent":["const getTxListRequestUnsignedSweep: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'txlist',\n  address: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n};\n\nconst getTxListResponseUnsignedSweep: Record<string, unknown> = {\n  status: '1',\n  result: [\n    {\n      hash: '0xede855d43d70ea1bb75db63d4f75113dae0845f0d4bdb0b2d8bda55249c70812',\n      nonce: '23',\n      from: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n    },\n  ],\n  message: 'OK',\n};\n\nconst getBalanceRequestUnsignedSweep: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'balance',\n  address: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n};\n\nconst getBalanceResponseUnsignedSweep: Record<string, unknown> = {\n  status: '1',\n  result: '100000000000000000',\n  message: 'OK',\n};\n\nexport const mockDataUnsignedSweep = {\n  userKey:\n    '029d2ded2d39ee7cd8d8bbba8b25e4c60bb09297936fa6b223de1f495b5ee20dcaf762367f9691f7719cb5e13e59d725669a18aad1e2522dd141fa4c7fd3d25c17',\n  backupKey:\n    '029d2ded2d39ee7cd8d8bbba8b25e4c60bb09297936fa6b223de1f495b5ee20dcaf762367f9691f7719cb5e13e59d725669a18aad1e2522dd141fa4c7fd3d25c17',\n  derivationPath: 'm/0',\n  derivationSeed: '',\n  walletBaseAddress: '0x742838193c4169f6b2ba7b0e03f723c3ba0928e1',\n  recoveryDestination: '0xd76b586901850f2c656db0cbef795c0851bbec35',\n  getTxListRequest: getTxListRequestUnsignedSweep,\n  getTxListResponse: getTxListResponseUnsignedSweep,\n  getBalanceRequest: getBalanceRequestUnsignedSweep,\n  getBalanceResponse: getBalanceResponseUnsignedSweep,\n};\n\nconst getTxListRequestNonBitGoRecovery: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'txlist',\n  address: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n};\n\nconst getTxListResponseNonBitGoRecovery: Record<string, unknown> = {\n  status: '1',\n  result: [\n    {\n      hash: '0xede855d43d70ea1bb75db63d4f75113dae0845f0d4bdb0b2d8bda55249c70812',\n      nonce: '23',\n      from: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n    },\n  ],\n  message: 'OK',\n};\n\nconst getBalanceRequestNonBitGoRecovery: Record<string, string> = {\n  chainid: '51',\n  module: 'account',\n  action: 'balance',\n  address: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n};\n\nconst getBalanceResponseNonBitGoRecovery: Record<string, unknown> = {\n  status: '1',\n  result: '100000000000000000',\n  message: 'OK',\n};\n\n// Mock data for txdc:tmt token transfer TSS transaction\nexport const mockTokenTransferData = {\n  txRequestId: '2475368d-f604-46e3-a743-e32f663fa350',\n  walletId: '695e1ca4fb4a739c8c6f9b49120c55c7',\n  serializedTxHex:\n    'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240808080',\n  signableHex:\n    'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240338080',\n  tokenContractAddress: '0xb283ec8dad644effc5c4c50bb7bb21442ac3c2db',\n  recipientAddress: '0x421cdf5e890070c28db0fd8e4bf87deac0cd0ffc',\n  senderAddress: '0x6aafaddf545f96772140f0008190c176a065df9a',\n  tokenAmount: '1000000',\n  feeInfo: {\n    fee: 7500000000000000,\n    feeString: '7500000000000000',\n  },\n  txPrebuild: {\n    txHex:\n      'f86a0485045d964b8083061a8094b283ec8dad644effc5c4c50bb7bb21442ac3c2db80b844a9059cbb000000000000000000000000421cdf5e890070c28db0fd8e4bf87deac0cd0ffc00000000000000000000000000000000000000000000000000000000000f4240808080',\n    recipients: [\n      {\n        address: '0x421cdf5e890070c28db0fd8e4bf87deac0cd0ffc',\n        amount: '1000000',\n      },\n    ],\n  },\n};\n\nexport const mockDataNonBitGoRecovery = {\n  recoveryDestination: '0xd76b586901850f2c656db0cbef795c0851bbec35',\n  userKeyData:\n    '{\"iv\":\"XeXwD5B465wYvao9WFZC7A==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"caDtzBCF3IA=\",\"ct\":\"0qr0YV2DgN68F9luNpjFQhwDTIXwyTTYdQirvbgITHqIDmITmV1IMgkKIdzSZBfmLkB6bG46oVF4snVG7lXEJz2twrutI01g59xjw88ULgR5wV5ZdFrGcmNZvOQ1H5imoWGS8bVKONmeF55TBgi49r9x3dsmgWvJ/EHeApj/FrAP1BLX/Rgl57kZqnNoryl55P8L2cJtJE1weDBD+/GsggdrO/dYBmihKTWyTBVa7UBIIgV5wOd4RXbZN1Hg2Vc0bY56KrpZbY1CsdQiIwH3tkKFPdqthlHVEfS8XViaYVl0Go3C/mUMYZH7CTg/s4LMpdlWzh3iRnmGercvIFZBfcehgNVv9H/OctYZnKfUdI5mZsVGxQRIMWr8oFbmjR3pYJ94oxS8assAzl7hNI4RJi/u4N9/5VJIi//069zsMsgA+k4b3u3xvivkTjO5sscAPs/Sp0mb5QLQhP48D/sHIYwhQiThJaH+flSoUQu5LNWmucmYr08lRRiI07O7DZAY2pplLSvBfkrBtgTgi+rLN95lKkxi7PYTGWuek1Sd/XiXit6EJ5FImYH2eKEVgatYvKfj/BdNJ2iHmeaykajtjpr21lt0Iqk98iZLZfCp5w4hfHHHB4QCrBzCAeG2MEPqmrAN67z4gMxUbkI+j9lYp5SyvlFmDIm78SyQ60371Wfr+7b4+wFqPq9fumXBZ4i0xYbcWTrKjYrn5bO5o3LWiRoh7EW8mzbMIC2m/DwIwdCHodbz4g31Psnk6Yk6UqEMq5JhOoUJYuVhYthNmbRlI59UDg+rz/HO9nYnZqsUgubSKcZArqM1J4T4+EDKuHtgnCQm2hqHlsJu+/n73jU33GEm86pDdcb8udHsfPCvhEIuLw6ZyThiX8JEOCi8Ueb0GPL31MSkJ7L7cOizgp6lHgs4nZorZfUIKjDd3twcpBNXjT15KEQbrW8RQChXmVl0b5N8BAom6e9Xpz2kDRGbvbYfBOdiht5Vr5Sm7prAQVVCZTWq6/qOZFWr7LJ+Cdw1qYt64UFcBHNtaX3d5WOMNNMqesrglVTW7w2Gscu7XaxoA4cTOKvMemG1cWTag3kr8oNgtz5gXsfbSo7CJrN8vw==\"}',\n  backupKeyData:\n    '{\"iv\":\"J32VIJhO9Cbf5bqcv75Kag==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"ZQ5VsHdXM4Q=\",\"ct\":\"XTgAUy8TZALKtt/PtJGAWbHfuExH5C5yw3y8EryrcY3uZdektl3WkL4KHHGTtL9yzssCTOWUMTemoAKipd+W/3mpZuQ88p+lloIgU7Tce3RLBG+gu665bsvTUuVpfMrpZHxDXXVMzwoUVHaxwfvu2tgduDnpkD/BX2RN5qfI6P6zz5r8UuWbiDPKEaqpcAHQ+RBitBQiOxNAlRNYexnUx1pCqcK08hqrqdQvx7elXXdCI3TwepGW7QwRzWa9pxvM9d85AWESueJ2B4JrZ5bkrIzXixGJcoUAJVvGfD69zoLUH9einnMafpocETBUDQyevC/j/1FwgZUCeGcb4U9N9tQJtR0fozzgpAo91nWA5UfkD2+hzRvz2p1Dmc+4bNb6s/7vK+BIOdpe4blzI43PxMLoBGkEQHlGHYCrOUnbV7dcxlyPv0qfom8K4f6/74YEKiMPjwA3sCcntWboW8gUPHF2xx/WAgmHI9DOiXsCJZMHx4GiZmY/pR9RVe/OeFAqPLWJoT6KaizTJD3So4/G5oHKPgTQbMIPi1lYtqKdOuhycISsaEgnkG1a8Tq5CN0tk5VywSmj4kSrqqjcp7kbAW+ViaNkZLuSibomK9AvuOGkEZBqDEuyFJnS4oayQTLxnstzO1JJGhmrCskH9B/QIIrUVl1IOv/IVyPg4M7T1g0+YfHdAXduLXu9bjHkqzGaSQZu35bs5QKy0bKEhAwoj+zgYAF/gZBH0/iPzrWM2xu/HMeQKwI0KFLOiBx3cMmNYE+Fb6vCjpVXBTYYUCBOjRnrAuR/lc3AnjAefCMAD89+FQ+QW5IzZv97lrSw0Rb+DIctfXddUKK7yyBe8CcZWU1dGAYsb/hk+H5lTZJBur5M3a1vzPMi68HKnRt7XZmyBsvPA8t0JVJmlc0RejqDrcps4uKjKdMaDNOvBzmEijdVv8N5q0Ng+yHwq3BolqoYn4mVJOrMuRlZt4pODkI8uOU1Ha/VStLzhT2HFexZ+Y0JzM0DS5hsygHt4Dz6/RfZTKHYvxzuRiHNLbmNcOBvVbBOL2Lm+Dlo3fFuVD3fS08vJuafc/uAfatpRwRqgE/EzvZOpnZyHcr4lUVEhRrDYw==\"}',\n  walletPassphrase: 'prithvishet2503',\n  walletRootAddress: '0x4477bc3e2472b2c5580c010526dfc5614871952d',\n  getTxListRequest: getTxListRequestNonBitGoRecovery,\n  getTxListResponse: getTxListResponseNonBitGoRecovery,\n  getBalanceRequest: getBalanceRequestNonBitGoRecovery,\n  getBalanceResponse: getBalanceResponseNonBitGoRecovery,\n};\n"]}

package/dist/test/unit/xdcToken.js

@@ -4,6 +4,7 @@ require("should");
 const sdk_test_1 = require("@bitgo-beta/sdk-test");
 const sdk_api_1 = require("@bitgo-beta/sdk-api");
 const src_1 = require("../../src");
+const resources_1 = require("../resources");
 describe('XDC Token:', function () {
     let bitgo;
     let xdcTokenCoin;
@@ -25,5 +26,203 @@ describe('XDC Token:', function () {
         xdcTokenCoin.network.should.equal('Mainnet');
         xdcTokenCoin.decimalPlaces.should.equal(6);
     });
+    describe('Token Registration and TransactionBuilder', function () {
+        const mainnetTokens = ['xdc:usdc', 'xdc:lbt', 'xdc:gama', 'xdc:srx', 'xdc:weth'];
+        const testnetTokens = ['txdc:tmt'];
+        describe('Mainnet tokens', function () {
+            mainnetTokens.forEach((tokenName) => {
+                it(`${tokenName} should be registered as XdcToken`, function () {
+                    const token = bitgo.coin(tokenName);
+                    token.should.be.instanceOf(src_1.XdcToken);
+                });
+                it(`${tokenName} should create TransactionBuilder without error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    (() => token.getTransactionBuilder()).should.not.throw();
+                });
+                it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    const builder = token.getTransactionBuilder();
+                    builder.should.have.property('_common');
+                    // Verify it's using XDC's getCommon, not EVM's
+                    // XDC's TransactionBuilder should create successfully without SHARED_EVM_SDK feature
+                    builder.constructor.name.should.equal('TransactionBuilder');
+                });
+            });
+        });
+        describe('Testnet tokens', function () {
+            testnetTokens.forEach((tokenName) => {
+                it(`${tokenName} should be registered as XdcToken`, function () {
+                    const token = bitgo.coin(tokenName);
+                    token.should.be.instanceOf(src_1.XdcToken);
+                });
+                it(`${tokenName} should create TransactionBuilder without error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    (() => token.getTransactionBuilder()).should.not.throw();
+                });
+                it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {
+                    const token = bitgo.coin(tokenName);
+                    // @ts-expect-error - accessing protected method for testing
+                    const builder = token.getTransactionBuilder();
+                    builder.should.have.property('_common');
+                    builder.constructor.name.should.equal('TransactionBuilder');
+                });
+                it(`${tokenName} should have correct base chain`, function () {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const token = bitgo.coin(tokenName);
+                    token.getBaseChain().should.equal('txdc');
+                });
+                it(`${tokenName} should not throw "Cannot use common sdk module" error`, function () {
+                    const token = bitgo.coin(tokenName);
+                    let errorThrown = false;
+                    let errorMessage = '';
+                    try {
+                        // @ts-expect-error - accessing protected method for testing
+                        const builder = token.getTransactionBuilder();
+                        // Try to use the builder to ensure it's fully functional
+                        // @ts-expect-error - type expects TransactionType enum
+                        builder.type('Send');
+                    }
+                    catch (e) {
+                        errorThrown = true;
+                        errorMessage = e.message;
+                    }
+                    errorThrown.should.equal(false);
+                    errorMessage.should.not.match(/Cannot use common sdk module/);
+                });
+            });
+        });
+        it('should verify all XDC tokens use XdcToken class, not EthLikeErc20Token', function () {
+            const allTokens = [...mainnetTokens, ...testnetTokens];
+            allTokens.forEach((tokenName) => {
+                const token = bitgo.coin(tokenName);
+                token.should.be.instanceOf(src_1.XdcToken);
+                token.constructor.name.should.equal('XdcToken');
+                token.constructor.name.should.not.equal('EthLikeErc20Token');
+            });
+        });
+    });
+    describe('verifyTssTransaction', function () {
+        it('should return true for valid token transfer params', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+        it('should return true for transferToken type without recipients', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    type: 'transferToken',
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+        it('should throw error when txParams.recipients is missing and no valid type', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {},
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('missing txParams');
+        });
+        it('should throw error when wallet is missing', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: undefined,
+            })
+                .should.be.rejectedWith('missing params');
+        });
+        it('should throw error when txPrebuild is missing', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: undefined,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('missing params');
+        });
+        it('should throw error for batch + hop transaction', async function () {
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            await token
+                .verifyTssTransaction({
+                txParams: {
+                    hop: true,
+                    recipients: [
+                        { address: '0x1111111111111111111111111111111111111111', amount: '1000' },
+                        { address: '0x2222222222222222222222222222222222222222', amount: '2000' },
+                    ],
+                },
+                txPrebuild: resources_1.mockTokenTransferData.txPrebuild,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('tx cannot be both a batch and hop transaction');
+        });
+        it('should not throw EIP155 error when verifying token transaction', async function () {
+            // This test ensures that verifyTssTransaction does NOT parse the txHex
+            // which would fail with "Incompatible EIP155-based V" error
+            const token = bitgo.coin('txdc:tmt');
+            const mockWallet = {};
+            // Use the signableHex (with v=51) which would fail if parsed
+            const txPrebuildWithSignableHex = {
+                ...resources_1.mockTokenTransferData.txPrebuild,
+                txHex: resources_1.mockTokenTransferData.signableHex,
+            };
+            // This should NOT throw EIP155 error because verifyTssTransaction
+            // does not parse the transaction
+            const result = await token.verifyTssTransaction({
+                txParams: {
+                    recipients: [
+                        {
+                            address: resources_1.mockTokenTransferData.recipientAddress,
+                            amount: resources_1.mockTokenTransferData.tokenAmount,
+                        },
+                    ],
+                },
+                txPrebuild: txPrebuildWithSignableHex,
+                wallet: mockWallet,
+            });
+            result.should.equal(true);
+        });
+    });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xdcToken.js","sourceRoot":"","sources":["../../../test/unit/xdcToken.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { IWallet } from '@bitgo-beta/sdk-core';\n\nimport { register, XdcToken } from '../../src';\nimport { mockTokenTransferData } from '../resources';\n\ndescribe('XDC Token:', function () {\n  let bitgo: TestBitGoAPI;\n  let xdcTokenCoin;\n  const tokenName = 'xdc:usdc';\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'prod' });\n    register(bitgo);\n    bitgo.initializeTestVars();\n    xdcTokenCoin = bitgo.coin(tokenName);\n  });\n\n  it('should return constants', function () {\n    xdcTokenCoin.getChain().should.equal('xdc:usdc');\n    xdcTokenCoin.getBaseChain().should.equal('xdc');\n    xdcTokenCoin.getFullName().should.equal('XDC Token');\n    xdcTokenCoin.getBaseFactor().should.equal(1e6);\n    xdcTokenCoin.type.should.equal(tokenName);\n    xdcTokenCoin.name.should.equal('USD Coin');\n    xdcTokenCoin.coin.should.equal('xdc');\n    xdcTokenCoin.network.should.equal('Mainnet');\n    xdcTokenCoin.decimalPlaces.should.equal(6);\n  });\n\n  describe('Token Registration and TransactionBuilder', function () {\n    const mainnetTokens = ['xdc:usdc', 'xdc:lbt', 'xdc:gama', 'xdc:srx', 'xdc:weth'];\n    const testnetTokens = ['txdc:tmt'];\n\n    describe('Mainnet tokens', function () {\n      mainnetTokens.forEach((tokenName) => {\n        it(`${tokenName} should be registered as XdcToken`, function () {\n          const token = bitgo.coin(tokenName);\n          token.should.be.instanceOf(XdcToken);\n        });\n\n        it(`${tokenName} should create TransactionBuilder without error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          (() => token.getTransactionBuilder()).should.not.throw();\n        });\n\n        it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          const builder = token.getTransactionBuilder();\n          builder.should.have.property('_common');\n          // Verify it's using XDC's getCommon, not EVM's\n          // XDC's TransactionBuilder should create successfully without SHARED_EVM_SDK feature\n          builder.constructor.name.should.equal('TransactionBuilder');\n        });\n      });\n    });\n\n    describe('Testnet tokens', function () {\n      testnetTokens.forEach((tokenName) => {\n        it(`${tokenName} should be registered as XdcToken`, function () {\n          const token = bitgo.coin(tokenName);\n          token.should.be.instanceOf(XdcToken);\n        });\n\n        it(`${tokenName} should create TransactionBuilder without error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          (() => token.getTransactionBuilder()).should.not.throw();\n        });\n\n        it(`${tokenName} should use XDC-specific TransactionBuilder`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          // @ts-expect-error - accessing protected method for testing\n          const builder = token.getTransactionBuilder();\n          builder.should.have.property('_common');\n          builder.constructor.name.should.equal('TransactionBuilder');\n        });\n\n        it(`${tokenName} should have correct base chain`, function () {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const token: any = bitgo.coin(tokenName);\n          token.getBaseChain().should.equal('txdc');\n        });\n\n        it(`${tokenName} should not throw \"Cannot use common sdk module\" error`, function () {\n          const token = bitgo.coin(tokenName) as XdcToken;\n          let errorThrown = false;\n          let errorMessage = '';\n\n          try {\n            // @ts-expect-error - accessing protected method for testing\n            const builder = token.getTransactionBuilder();\n            // Try to use the builder to ensure it's fully functional\n            // @ts-expect-error - type expects TransactionType enum\n            builder.type('Send');\n          } catch (e) {\n            errorThrown = true;\n            errorMessage = (e as Error).message;\n          }\n\n          errorThrown.should.equal(false);\n          errorMessage.should.not.match(/Cannot use common sdk module/);\n        });\n      });\n    });\n\n    it('should verify all XDC tokens use XdcToken class, not EthLikeErc20Token', function () {\n      const allTokens = [...mainnetTokens, ...testnetTokens];\n\n      allTokens.forEach((tokenName) => {\n        const token = bitgo.coin(tokenName);\n        token.should.be.instanceOf(XdcToken);\n        token.constructor.name.should.equal('XdcToken');\n        token.constructor.name.should.not.equal('EthLikeErc20Token');\n      });\n    });\n  });\n\n  describe('verifyTssTransaction', function () {\n    it('should return true for valid token transfer params', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          recipients: [\n            {\n              address: mockTokenTransferData.recipientAddress,\n              amount: mockTokenTransferData.tokenAmount,\n            },\n          ],\n        },\n        txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n\n    it('should return true for transferToken type without recipients', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          type: 'transferToken',\n        },\n        txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n\n    it('should throw error when txParams.recipients is missing and no valid type', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {},\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('missing txParams');\n    });\n\n    it('should throw error when wallet is missing', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            recipients: [\n              {\n                address: mockTokenTransferData.recipientAddress,\n                amount: mockTokenTransferData.tokenAmount,\n              },\n            ],\n          },\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: undefined as unknown as IWallet,\n        })\n        .should.be.rejectedWith('missing params');\n    });\n\n    it('should throw error when txPrebuild is missing', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            recipients: [\n              {\n                address: mockTokenTransferData.recipientAddress,\n                amount: mockTokenTransferData.tokenAmount,\n              },\n            ],\n          },\n          txPrebuild: undefined as unknown as Parameters<typeof token.verifyTssTransaction>[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('missing params');\n    });\n\n    it('should throw error for batch + hop transaction', async function () {\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      await token\n        .verifyTssTransaction({\n          txParams: {\n            hop: true,\n            recipients: [\n              { address: '0x1111111111111111111111111111111111111111', amount: '1000' },\n              { address: '0x2222222222222222222222222222222222222222', amount: '2000' },\n            ],\n          },\n          txPrebuild: mockTokenTransferData.txPrebuild as unknown as Parameters<\n            typeof token.verifyTssTransaction\n          >[0]['txPrebuild'],\n          wallet: mockWallet,\n        })\n        .should.be.rejectedWith('tx cannot be both a batch and hop transaction');\n    });\n\n    it('should not throw EIP155 error when verifying token transaction', async function () {\n      // This test ensures that verifyTssTransaction does NOT parse the txHex\n      // which would fail with \"Incompatible EIP155-based V\" error\n      const token = bitgo.coin('txdc:tmt') as XdcToken;\n      const mockWallet = {} as unknown as IWallet;\n\n      // Use the signableHex (with v=51) which would fail if parsed\n      const txPrebuildWithSignableHex = {\n        ...mockTokenTransferData.txPrebuild,\n        txHex: mockTokenTransferData.signableHex,\n      };\n\n      // This should NOT throw EIP155 error because verifyTssTransaction\n      // does not parse the transaction\n      const result = await token.verifyTssTransaction({\n        txParams: {\n          recipients: [\n            {\n              address: mockTokenTransferData.recipientAddress,\n              amount: mockTokenTransferData.tokenAmount,\n            },\n          ],\n        },\n        txPrebuild: txPrebuildWithSignableHex as unknown as Parameters<\n          typeof token.verifyTssTransaction\n        >[0]['txPrebuild'],\n        wallet: mockWallet,\n      });\n\n      result.should.equal(true);\n    });\n  });\n});\n"]}