@bitgo-beta/sdk-coin-xdc 1.0.1-beta.89 → 1.0.1-beta.890

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

@@ -0,0 +1,73 @@
+/**
+ * @prettier
+ */
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { ContractCall } from '@bitgo-beta/abstract-eth';
+/**
+ * Represents an XDC uploadKYC contract call
+ * This is used to submit KYC document hashes (IPFS hashes) to the XDC Validator contract
+ */
+export declare class UploadKycCall extends ContractCall {
+    readonly contractAddress: string;
+    readonly ipfsHash: string;
+    constructor(contractAddress: string, ipfsHash: string);
+}
+/**
+ * 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();
+ * ```
+ */
+export declare class UploadKycBuilder {
+    private _ipfsHash?;
+    private _contractAddress?;
+    private readonly _coinConfig;
+    constructor(coinConfig: Readonly<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: string): 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: string): this;
+    /**
+     * Build the uploadKYC contract call
+     *
+     * @returns {UploadKycCall} the constructed contract call
+     * @throws {BuildTransactionError} if required fields are missing
+     */
+    build(): UploadKycCall;
+    /**
+     * Validate that all mandatory fields are set
+     * @private
+     */
+    private validateMandatoryFields;
+    /**
+     * Get the default validator contract address for the current network
+     * @private
+     */
+    private getDefaultContractAddress;
+}
+//# sourceMappingURL=uploadKycBuilder.d.ts.map

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,qBAAqB,CAAC;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxD;;;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-beta/sdk-core");
+const abstract_eth_1 = require("@bitgo-beta/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,mDAAyF;AACzF,2DAAwD;AACxD,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-beta/statics';\nimport { BuildTransactionError, InvalidParameterValueError } from '@bitgo-beta/sdk-core';\nimport { ContractCall } from '@bitgo-beta/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/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAGzC,CAAC"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAKjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAMzC,CAAC"}

package/dist/src/register.js

@@ -3,9 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.register = void 0;
 const xdc_1 = require("./xdc");
 const txdc_1 = require("./txdc");
+const xdcToken_1 = require("./xdcToken");
 const register = (sdk) => {
     sdk.register('xdc', xdc_1.Xdc.createInstance);
     sdk.register('txdc', txdc_1.Txdc.createInstance);
+    xdcToken_1.XdcToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+        sdk.register(name, coinConstructor);
+    });
 };
 exports.register = register;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsK0JBQTRCO0FBQzVCLGlDQUE4QjtBQUV2QixNQUFNLFFBQVEsR0FBRyxDQUFDLEdBQWMsRUFBUSxFQUFFO0lBQy9DLEdBQUcsQ0FBQyxRQUFRLENBQUMsS0FBSyxFQUFFLFNBQUcsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUN4QyxHQUFHLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxXQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7QUFDNUMsQ0FBQyxDQUFDO0FBSFcsUUFBQSxRQUFRLFlBR25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgWGRjIH0gZnJvbSAnLi94ZGMnO1xuaW1wb3J0IHsgVHhkYyB9IGZyb20gJy4vdHhkYyc7XG5cbmV4cG9ydCBjb25zdCByZWdpc3RlciA9IChzZGs6IEJpdEdvQmFzZSk6IHZvaWQgPT4ge1xuICBzZGsucmVnaXN0ZXIoJ3hkYycsIFhkYy5jcmVhdGVJbnN0YW5jZSk7XG4gIHNkay5yZWdpc3RlcigndHhkYycsIFR4ZGMuY3JlYXRlSW5zdGFuY2UpO1xufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsK0JBQTRCO0FBQzVCLGlDQUE4QjtBQUM5Qix5Q0FBc0M7QUFFL0IsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFjLEVBQVEsRUFBRTtJQUMvQyxHQUFHLENBQUMsUUFBUSxDQUFDLEtBQUssRUFBRSxTQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDeEMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzFDLG1CQUFRLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQ3ZFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBTlcsUUFBQSxRQUFRLFlBTW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvLWJldGEvc2RrLWNvcmUnO1xuaW1wb3J0IHsgWGRjIH0gZnJvbSAnLi94ZGMnO1xuaW1wb3J0IHsgVHhkYyB9IGZyb20gJy4vdHhkYyc7XG5pbXBvcnQgeyBYZGNUb2tlbiB9IGZyb20gJy4veGRjVG9rZW4nO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXIgPSAoc2RrOiBCaXRHb0Jhc2UpOiB2b2lkID0+IHtcbiAgc2RrLnJlZ2lzdGVyKCd4ZGMnLCBYZGMuY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3R4ZGMnLCBUeGRjLmNyZWF0ZUluc3RhbmNlKTtcbiAgWGRjVG9rZW4uY3JlYXRlVG9rZW5Db25zdHJ1Y3RvcnMoKS5mb3JFYWNoKCh7IG5hbWUsIGNvaW5Db25zdHJ1Y3RvciB9KSA9PiB7XG4gICAgc2RrLnJlZ2lzdGVyKG5hbWUsIGNvaW5Db25zdHJ1Y3Rvcik7XG4gIH0pO1xufTtcbiJdfQ==

package/dist/src/xdc.d.ts

@@ -1,6 +1,6 @@
-import { BaseCoin, BitGoBase, MPCAlgorithm } from '@bitgo-beta/sdk-core';
+import { BaseCoin, BitGoBase, MPCAlgorithm, MultisigType } from '@bitgo-beta/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
-import { AbstractEthLikeNewCoins } from '@bitgo-beta/abstract-eth';
+import { AbstractEthLikeNewCoins, UnsignedSweepTxMPCv2, RecoverOptions, OfflineVaultTxInfo, VerifyEthTransactionOptions } from '@bitgo-beta/abstract-eth';
 import { TransactionBuilder } from './lib';
 export declare class Xdc extends AbstractEthLikeNewCoins {
     protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
@@ -8,8 +8,21 @@ export declare class Xdc extends AbstractEthLikeNewCoins {
     protected getTransactionBuilder(): TransactionBuilder;
     /** @inheritDoc */
     supportsTss(): boolean;
+    /** inherited doc */
+    getDefaultMultisigType(): MultisigType;
     /** @inheritDoc */
     getMPCAlgorithm(): MPCAlgorithm;
+    protected buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2>;
     recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>>;
+    /**
+     * 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=xdc.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"xdc.d.ts","sourceRoot":"","sources":["../../src/xdc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAU,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAmC,MAAM,0BAA0B,CAAC;AACpG,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAE3C,qBAAa,GAAI,SAAQ,uBAAuB;IAC9C,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAIzB,+BAA+B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAKvG"}
+{"version":3,"file":"xdc.d.ts","sourceRoot":"","sources":["../../src/xdc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAU,YAAY,EAAE,YAAY,EAAiB,MAAM,sBAAsB,CAAC;AAC9G,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,qBAAqB,CAAC;AACzE,OAAO,EACL,uBAAuB,EAEvB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,2BAA2B,EAC5B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAE3C,qBAAa,GAAI,SAAQ,uBAAuB;IAC9C,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;IAIrD,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,kBAAkB;IAClB,eAAe,IAAI,YAAY;cAIf,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,kBAAkB,GAAG,oBAAoB,CAAC;IAI9G,+BAA+B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAKtG;;;;;;;;OAQG;IACG,oBAAoB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,OAAO,CAAC;CAoBlF"}

package/dist/src/xdc.js

@@ -19,15 +19,46 @@ class Xdc extends abstract_eth_1.AbstractEthLikeNewCoins {
     supportsTss() {
         return true;
     }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.tss;
+    }
     /** @inheritDoc */
     getMPCAlgorithm() {
         return 'ecdsa';
     }
+    async buildUnsignedSweepTxnTSS(params) {
+        return this.buildUnsignedSweepTxnMPCv2(params);
+    }
     async recoveryBlockchainExplorerQuery(query) {
         const apiToken = sdk_core_1.common.Environments[this.bitgo.getEnv()].xdcExplorerApiToken;
         const explorerUrl = sdk_core_1.common.Environments[this.bitgo.getEnv()].xdcExplorerBaseUrl;
         return await (0, abstract_eth_1.recoveryBlockchainExplorerQuery)(query, explorerUrl, apiToken);
     }
+    /**
+     * 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.Xdc = Xdc;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/xdcToken.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @prettier
+ */
+import { EthLikeTokenConfig } from '@bitgo-beta/statics';
+import { BitGoBase, CoinConstructor, NamedCoinConstructor, MPCAlgorithm } from '@bitgo-beta/sdk-core';
+import { CoinNames, EthLikeToken, VerifyEthTransactionOptions } from '@bitgo-beta/abstract-eth';
+import { TransactionBuilder } from './lib';
+export { EthLikeTokenConfig };
+export declare class XdcToken extends EthLikeToken {
+    readonly tokenConfig: EthLikeTokenConfig;
+    static coinNames: CoinNames;
+    constructor(bitgo: BitGoBase, tokenConfig: EthLikeTokenConfig);
+    static createTokenConstructor(config: EthLikeTokenConfig): CoinConstructor;
+    static createTokenConstructors(): NamedCoinConstructor[];
+    protected getTransactionBuilder(): TransactionBuilder;
+    /**
+     * Make a query to XDC Etherscan for information such as balance, token balance, solidity calls
+     * @param {Object} query key-value pairs of parameters to append after /api
+     * @returns {Promise<Object>} response from XDC Etherscan
+     */
+    recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>>;
+    getFullName(): string;
+    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

@@ -0,0 +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,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"}