@bitgo/sdk-coin-xdc 1.6.0 → 1.7.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploadKycBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/uploadKycBuilder.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD;;;GAGG;AACH,qBAAa,aAAc,SAAQ,YAAY;IAC7C,SAAgB,eAAe,EAAE,MAAM,CAAC;IACxC,SAAgB,QAAQ,EAAE,MAAM,CAAC;gBAErB,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAMtD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;gBAEvC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI5C;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAgB5B;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IActC;;;;;OAKG;IACH,KAAK,IAAI,aAAa;IAOtB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAM/B;;;OAGG;IACH,OAAO,CAAC,yBAAyB;CAIlC"}

package/dist/src/lib/uploadKycBuilder.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadKycBuilder = exports.UploadKycCall = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const abstract_eth_1 = require("@bitgo/abstract-eth");
+const validatorContract_1 = require("./validatorContract");
+/**
+ * Represents an XDC uploadKYC contract call
+ * This is used to submit KYC document hashes (IPFS hashes) to the XDC Validator contract
+ */
+class UploadKycCall extends abstract_eth_1.ContractCall {
+    constructor(contractAddress, ipfsHash) {
+        // uploadKYC(string) - takes a single string parameter (the IPFS hash)
+        super(validatorContract_1.UPLOAD_KYC_METHOD_ID, ['string'], [ipfsHash]);
+        this.contractAddress = contractAddress;
+        this.ipfsHash = ipfsHash;
+    }
+}
+exports.UploadKycCall = UploadKycCall;
+/**
+ * Builder for XDC uploadKYC transactions
+ *
+ * This builder creates transactions that upload KYC document hashes to the XDC Validator contract.
+ * The flow is:
+ * 1. Upload KYC document to IPFS → get IPFS hash (e.g., "Qm...")
+ * 2. Use this builder to create a transaction that submits the hash to the validator contract
+ * 3. The transaction is signed using TSS/MPC
+ * 4. After successful upload, the address can propose a validator candidate
+ *
+ * @example
+ * ```typescript
+ * const builder = new UploadKycBuilder(coinConfig);
+ * const call = builder
+ *   .ipfsHash('QmRealIPFSHash...')
+ *   .build();
+ * ```
+ */
+class UploadKycBuilder {
+    constructor(coinConfig) {
+        this._coinConfig = coinConfig;
+    }
+    /**
+     * Set the IPFS hash of the uploaded KYC document
+     *
+     * @param {string} hash - The IPFS hash (e.g., "QmRealIPFSHash...")
+     * @returns {UploadKycBuilder} this builder instance
+     * @throws {InvalidParameterValueError} if the hash is invalid
+     */
+    ipfsHash(hash) {
+        if (!hash || hash.trim().length === 0) {
+            throw new sdk_core_1.InvalidParameterValueError('IPFS hash cannot be empty');
+        }
+        // Basic IPFS hash validation (should start with 'Qm' for v0 or 'b' for v1)
+        if (!hash.startsWith('Qm') && !hash.startsWith('b')) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid IPFS hash format. Expected hash starting with "Qm" (v0) or "b" (v1)');
+        }
+        this._ipfsHash = hash;
+        return this;
+    }
+    /**
+     * Set a custom validator contract address
+     * If not set, the default address for the network will be used
+     *
+     * @param {string} address - The validator contract address
+     * @returns {UploadKycBuilder} this builder instance
+     * @throws {InvalidParameterValueError} if the address is invalid
+     */
+    contractAddress(address) {
+        if (!address || address.trim().length === 0) {
+            throw new sdk_core_1.InvalidParameterValueError('Contract address cannot be empty');
+        }
+        // Basic Ethereum address validation
+        if (!/^(0x)?[0-9a-fA-F]{40}$/.test(address)) {
+            throw new sdk_core_1.InvalidParameterValueError('Invalid contract address format');
+        }
+        this._contractAddress = address.toLowerCase().startsWith('0x') ? address : `0x${address}`;
+        return this;
+    }
+    /**
+     * Build the uploadKYC contract call
+     *
+     * @returns {UploadKycCall} the constructed contract call
+     * @throws {BuildTransactionError} if required fields are missing
+     */
+    build() {
+        this.validateMandatoryFields();
+        const contractAddress = this._contractAddress || this.getDefaultContractAddress();
+        const ipfsHash = this._ipfsHash; // validated by validateMandatoryFields
+        return new UploadKycCall(contractAddress, ipfsHash);
+    }
+    /**
+     * Validate that all mandatory fields are set
+     * @private
+     */
+    validateMandatoryFields() {
+        if (!this._ipfsHash) {
+            throw new sdk_core_1.BuildTransactionError('Missing IPFS hash for uploadKYC transaction');
+        }
+    }
+    /**
+     * Get the default validator contract address for the current network
+     * @private
+     */
+    getDefaultContractAddress() {
+        const isTestnet = this._coinConfig.name === 'txdc';
+        return (0, validatorContract_1.getValidatorContractAddress)(isTestnet);
+    }
+}
+exports.UploadKycBuilder = UploadKycBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploadKycBuilder.js","sourceRoot":"","sources":["../../../src/lib/uploadKycBuilder.ts"],"names":[],"mappings":";;;AAIA,8CAAoF;AACpF,sDAAmD;AACnD,2DAAwF;AAExF;;;GAGG;AACH,MAAa,aAAc,SAAQ,2BAAY;IAI7C,YAAY,eAAuB,EAAE,QAAgB;QACnD,sEAAsE;QACtE,KAAK,CAAC,wCAAoB,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAVD,sCAUC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,gBAAgB;IAK3B,YAAY,UAAgC;QAC1C,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,IAAY;QACnB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,qCAA0B,CAAC,2BAA2B,CAAC,CAAC;QACpE,CAAC;QAED,2EAA2E;QAC3E,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACpD,MAAM,IAAI,qCAA0B,CAClC,6EAA6E,CAC9E,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACH,eAAe,CAAC,OAAe;QAC7B,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5C,MAAM,IAAI,qCAA0B,CAAC,kCAAkC,CAAC,CAAC;QAC3E,CAAC;QAED,oCAAoC;QACpC,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5C,MAAM,IAAI,qCAA0B,CAAC,iCAAiC,CAAC,CAAC;QAC1E,CAAC;QAED,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;QAC1F,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACH,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAC/B,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,yBAAyB,EAAE,CAAC;QAClF,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAmB,CAAC,CAAC,uCAAuC;QAClF,OAAO,IAAI,aAAa,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACK,uBAAuB;QAC7B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,MAAM,IAAI,gCAAqB,CAAC,6CAA6C,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,yBAAyB;QAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,MAAM,CAAC;QACnD,OAAO,IAAA,+CAA2B,EAAC,SAAS,CAAC,CAAC;IAChD,CAAC;CACF;AArFD,4CAqFC","sourcesContent":["/**\n * @prettier\n */\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { BuildTransactionError, InvalidParameterValueError } from '@bitgo/sdk-core';\nimport { ContractCall } from '@bitgo/abstract-eth';\nimport { UPLOAD_KYC_METHOD_ID, getValidatorContractAddress } from './validatorContract';\n\n/**\n * Represents an XDC uploadKYC contract call\n * This is used to submit KYC document hashes (IPFS hashes) to the XDC Validator contract\n */\nexport class UploadKycCall extends ContractCall {\n  public readonly contractAddress: string;\n  public readonly ipfsHash: string;\n\n  constructor(contractAddress: string, ipfsHash: string) {\n    // uploadKYC(string) - takes a single string parameter (the IPFS hash)\n    super(UPLOAD_KYC_METHOD_ID, ['string'], [ipfsHash]);\n    this.contractAddress = contractAddress;\n    this.ipfsHash = ipfsHash;\n  }\n}\n\n/**\n * Builder for XDC uploadKYC transactions\n *\n * This builder creates transactions that upload KYC document hashes to the XDC Validator contract.\n * The flow is:\n * 1. Upload KYC document to IPFS → get IPFS hash (e.g., \"Qm...\")\n * 2. Use this builder to create a transaction that submits the hash to the validator contract\n * 3. The transaction is signed using TSS/MPC\n * 4. After successful upload, the address can propose a validator candidate\n *\n * @example\n * ```typescript\n * const builder = new UploadKycBuilder(coinConfig);\n * const call = builder\n *   .ipfsHash('QmRealIPFSHash...')\n *   .build();\n * ```\n */\nexport class UploadKycBuilder {\n  private _ipfsHash?: string;\n  private _contractAddress?: string;\n  private readonly _coinConfig: Readonly<CoinConfig>;\n\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    this._coinConfig = coinConfig;\n  }\n\n  /**\n   * Set the IPFS hash of the uploaded KYC document\n   *\n   * @param {string} hash - The IPFS hash (e.g., \"QmRealIPFSHash...\")\n   * @returns {UploadKycBuilder} this builder instance\n   * @throws {InvalidParameterValueError} if the hash is invalid\n   */\n  ipfsHash(hash: string): this {\n    if (!hash || hash.trim().length === 0) {\n      throw new InvalidParameterValueError('IPFS hash cannot be empty');\n    }\n\n    // Basic IPFS hash validation (should start with 'Qm' for v0 or 'b' for v1)\n    if (!hash.startsWith('Qm') && !hash.startsWith('b')) {\n      throw new InvalidParameterValueError(\n        'Invalid IPFS hash format. Expected hash starting with \"Qm\" (v0) or \"b\" (v1)'\n      );\n    }\n\n    this._ipfsHash = hash;\n    return this;\n  }\n\n  /**\n   * Set a custom validator contract address\n   * If not set, the default address for the network will be used\n   *\n   * @param {string} address - The validator contract address\n   * @returns {UploadKycBuilder} this builder instance\n   * @throws {InvalidParameterValueError} if the address is invalid\n   */\n  contractAddress(address: string): this {\n    if (!address || address.trim().length === 0) {\n      throw new InvalidParameterValueError('Contract address cannot be empty');\n    }\n\n    // Basic Ethereum address validation\n    if (!/^(0x)?[0-9a-fA-F]{40}$/.test(address)) {\n      throw new InvalidParameterValueError('Invalid contract address format');\n    }\n\n    this._contractAddress = address.toLowerCase().startsWith('0x') ? address : `0x${address}`;\n    return this;\n  }\n\n  /**\n   * Build the uploadKYC contract call\n   *\n   * @returns {UploadKycCall} the constructed contract call\n   * @throws {BuildTransactionError} if required fields are missing\n   */\n  build(): UploadKycCall {\n    this.validateMandatoryFields();\n    const contractAddress = this._contractAddress || this.getDefaultContractAddress();\n    const ipfsHash = this._ipfsHash as string; // validated by validateMandatoryFields\n    return new UploadKycCall(contractAddress, ipfsHash);\n  }\n\n  /**\n   * Validate that all mandatory fields are set\n   * @private\n   */\n  private validateMandatoryFields(): void {\n    if (!this._ipfsHash) {\n      throw new BuildTransactionError('Missing IPFS hash for uploadKYC transaction');\n    }\n  }\n\n  /**\n   * Get the default validator contract address for the current network\n   * @private\n   */\n  private getDefaultContractAddress(): string {\n    const isTestnet = this._coinConfig.name === 'txdc';\n    return getValidatorContractAddress(isTestnet);\n  }\n}\n"]}

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

@@ -0,0 +1,136 @@
+/**
+ * XDC Validator Contract Constants and ABI
+ *
+ * This file contains the contract address and ABI for the XDC Validator contract
+ * which handles KYC uploads and validator staking operations.
+ *
+ * Contract Address: 0x0000000000000000000000000000000000000088 (System Contract)
+ * Source: XDC Network Validator Contract
+ * Reference: https://github.com/XinFinOrg/XDPoSChain
+ */
+/**
+ * XDC Validator Contract Address (Testnet)
+ * This is the deployed contract address on XDC Apothem testnet (chainId: 51)
+ */
+export declare const XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET = "0x0000000000000000000000000000000000000088";
+/**
+ * XDC Validator Contract Address (Mainnet)
+ * This is the deployed contract address on XDC mainnet (chainId: 50)
+ */
+export declare const XDC_VALIDATOR_CONTRACT_ADDRESS_MAINNET = "0x0000000000000000000000000000000000000088";
+/**
+ * uploadKYC method ID
+ * keccak256("uploadKYC(string)") = 0xf5c95125
+ */
+export declare const UPLOAD_KYC_METHOD_ID = "0xf5c95125";
+/**
+ * propose method ID
+ * keccak256("propose(address)") = 0x01267951
+ */
+export declare const PROPOSE_METHOD_ID = "0x01267951";
+/**
+ * Full XDC Validator Contract ABI
+ * Imported from JSON file for easy use with Web3/XDC3
+ */
+export declare const XDC_VALIDATOR_ABI: ({
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+})[];
+/**
+ * Get the uploadKYC function ABI
+ * Useful for encoding function calls
+ */
+export declare const UPLOAD_KYC_ABI: {
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+} | undefined;
+/**
+ * Get the propose function ABI
+ * Useful for encoding function calls
+ */
+export declare const PROPOSE_ABI: {
+    constant: boolean;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        name: string;
+        type: string;
+    }[];
+    payable: boolean;
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    constant?: undefined;
+    outputs?: undefined;
+    payable?: undefined;
+    stateMutability?: undefined;
+} | undefined;
+/**
+ * Get the validator contract address for the given network
+ * @param isTestnet - whether to use testnet or mainnet
+ * @returns the validator contract address
+ */
+export declare function getValidatorContractAddress(isTestnet: boolean): string;
+//# sourceMappingURL=validatorContract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validatorContract.d.ts","sourceRoot":"","sources":["../../../src/lib/validatorContract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;GAGG;AACH,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,sCAAsC,+CAA+C,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,eAAe,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA4D,CAAC;AAExF;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA0D,CAAC;AAEnF;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAEtE"}

package/dist/src/lib/validatorContract.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * XDC Validator Contract Constants and ABI
+ *
+ * This file contains the contract address and ABI for the XDC Validator contract
+ * which handles KYC uploads and validator staking operations.
+ *
+ * Contract Address: 0x0000000000000000000000000000000000000088 (System Contract)
+ * Source: XDC Network Validator Contract
+ * Reference: https://github.com/XinFinOrg/XDPoSChain
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPOSE_ABI = exports.UPLOAD_KYC_ABI = exports.XDC_VALIDATOR_ABI = exports.PROPOSE_METHOD_ID = exports.UPLOAD_KYC_METHOD_ID = exports.XDC_VALIDATOR_CONTRACT_ADDRESS_MAINNET = exports.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET = void 0;
+exports.getValidatorContractAddress = getValidatorContractAddress;
+const XDCValidatorABI_json_1 = __importDefault(require("./XDCValidatorABI.json"));
+/**
+ * XDC Validator Contract Address (Testnet)
+ * This is the deployed contract address on XDC Apothem testnet (chainId: 51)
+ */
+exports.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET = '0x0000000000000000000000000000000000000088';
+/**
+ * XDC Validator Contract Address (Mainnet)
+ * This is the deployed contract address on XDC mainnet (chainId: 50)
+ */
+exports.XDC_VALIDATOR_CONTRACT_ADDRESS_MAINNET = '0x0000000000000000000000000000000000000088';
+/**
+ * uploadKYC method ID
+ * keccak256("uploadKYC(string)") = 0xf5c95125
+ */
+exports.UPLOAD_KYC_METHOD_ID = '0xf5c95125';
+/**
+ * propose method ID
+ * keccak256("propose(address)") = 0x01267951
+ */
+exports.PROPOSE_METHOD_ID = '0x01267951';
+/**
+ * Full XDC Validator Contract ABI
+ * Imported from JSON file for easy use with Web3/XDC3
+ */
+exports.XDC_VALIDATOR_ABI = XDCValidatorABI_json_1.default;
+/**
+ * Get the uploadKYC function ABI
+ * Useful for encoding function calls
+ */
+exports.UPLOAD_KYC_ABI = XDCValidatorABI_json_1.default.find((item) => item.name === 'uploadKYC');
+/**
+ * Get the propose function ABI
+ * Useful for encoding function calls
+ */
+exports.PROPOSE_ABI = XDCValidatorABI_json_1.default.find((item) => item.name === 'propose');
+/**
+ * Get the validator contract address for the given network
+ * @param isTestnet - whether to use testnet or mainnet
+ * @returns the validator contract address
+ */
+function getValidatorContractAddress(isTestnet) {
+    return isTestnet ? exports.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET : exports.XDC_VALIDATOR_CONTRACT_ADDRESS_MAINNET;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/xdcToken.d.ts

@@ -3,7 +3,7 @@
  */
 import { EthLikeTokenConfig } from '@bitgo/statics';
 import { BitGoBase, CoinConstructor, NamedCoinConstructor, MPCAlgorithm } from '@bitgo/sdk-core';
-import { CoinNames, EthLikeToken } from '@bitgo/abstract-eth';
+import { CoinNames, EthLikeToken, VerifyEthTransactionOptions } from '@bitgo/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,gBAAgB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAU,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACzG,OAAO,EAAE,SAAS,EAAE,YAAY,EAAmC,MAAM,qBAAqB,CAAC;AAE/F,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,gBAAgB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAU,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACzG,OAAO,EACL,SAAS,EACT,YAAY,EAEZ,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,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,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

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/transactionBuilder/uploadKyc.d.ts

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

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

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