@bitgo-beta/sdk-coin-xdc 1.0.1-beta.142 → 1.0.1-beta.1421

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/lib/xdcKycMessage.d.ts

@@ -0,0 +1,26 @@
+import { IWallet } from '@bitgo-beta/sdk-core';
+export interface XdcKycMessageParams {
+    account: string;
+    timestamp: string;
+}
+export interface XdcKycSignedMessage {
+    kycAccount: string;
+    kycMessage: string;
+    kycSignature: string;
+}
+/**
+ * Build the message string expected by the XinFin masternode IPFS API.
+ * Format: "[XDCmaster KYC <timestamp>] Upload KYC for <account>"
+ */
+export declare function buildXdcKycMessage(params: XdcKycMessageParams): string;
+/**
+ * Sign the XDC KYC message using the wallet's TSS key.
+ * Calls wallet.signMessage() which routes through WP /msgrequests TSS ceremony.
+ *
+ * @param wallet - TSS wallet (must be XDC/TXDC)
+ * @param account - wallet Ethereum address
+ * @param walletPassphrase - user's wallet passphrase for TSS signing
+ * @returns signed message object ready to send as staking-service request fields
+ */
+export declare function signXdcKycMessage(wallet: IWallet, account: string, walletPassphrase: string): Promise<XdcKycSignedMessage>;
+//# sourceMappingURL=xdcKycMessage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xdcKycMessage.d.ts","sourceRoot":"","sources":["../../../src/lib/xdcKycMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAuB,MAAM,sBAAsB,CAAC;AAEpE,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAEtE;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAiB9B"}

package/dist/src/lib/xdcKycMessage.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildXdcKycMessage = buildXdcKycMessage;
+exports.signXdcKycMessage = signXdcKycMessage;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+/**
+ * Build the message string expected by the XinFin masternode IPFS API.
+ * Format: "[XDCmaster KYC <timestamp>] Upload KYC for <account>"
+ */
+function buildXdcKycMessage(params) {
+    return `[XDCmaster KYC ${params.timestamp}] Upload KYC for ${params.account}`;
+}
+/**
+ * Sign the XDC KYC message using the wallet's TSS key.
+ * Calls wallet.signMessage() which routes through WP /msgrequests TSS ceremony.
+ *
+ * @param wallet - TSS wallet (must be XDC/TXDC)
+ * @param account - wallet Ethereum address
+ * @param walletPassphrase - user's wallet passphrase for TSS signing
+ * @returns signed message object ready to send as staking-service request fields
+ */
+async function signXdcKycMessage(wallet, account, walletPassphrase) {
+    const timestamp = new Date().toISOString();
+    const kycMessage = buildXdcKycMessage({ account, timestamp });
+    const signed = await wallet.signMessage({
+        message: {
+            messageRaw: kycMessage,
+            messageStandardType: sdk_core_1.MessageStandardType.EIP191,
+        },
+        walletPassphrase,
+    });
+    return {
+        kycAccount: account,
+        kycMessage,
+        kycSignature: signed.signature,
+    };
+}
+//# 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, 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 } from '@bitgo-beta/abstract-eth';
 import { TransactionBuilder } from './lib';
 export declare class Xdc extends AbstractEthLikeNewCoins {
     protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
@@ -12,6 +12,7 @@ export declare class Xdc extends AbstractEthLikeNewCoins {
     getDefaultMultisigType(): MultisigType;
     /** @inheritDoc */
     getMPCAlgorithm(): MPCAlgorithm;
+    protected buildUnsignedSweepTxnTSS(params: RecoverOptions): Promise<OfflineVaultTxInfo | UnsignedSweepTxMPCv2>;
     recoveryBlockchainExplorerQuery(query: Record<string, string>): Promise<Record<string, unknown>>;
 }
 //# 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,YAAY,EAAiB,MAAM,sBAAsB,CAAC;AAC9G,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,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,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,EACnB,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;CAKvG"}

package/dist/src/xdc.js

@@ -27,6 +27,9 @@ class Xdc extends abstract_eth_1.AbstractEthLikeNewCoins {
     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;
@@ -34,4 +37,4 @@ class Xdc extends abstract_eth_1.AbstractEthLikeNewCoins {
     }
 }
 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,27 @@
+/**
+ * @prettier
+ */
+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 { 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;
+}
+//# 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,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"}