@bitgo-beta/sdk-coin-xdc 1.0.1-beta.886 → 1.0.1-beta.887

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/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":""}

package/dist/test/unit/transactionBuilder/uploadKyc.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getBuilder_1 = require("../getBuilder");
+const should_1 = __importDefault(require("should"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const lib_1 = require("../../../src/lib");
+describe('XDC Upload KYC Builder', () => {
+    const coinConfig = statics_1.coins.get('txdc');
+    describe('UploadKycBuilder', () => {
+        it('should build uploadKYC call with valid IPFS hash', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmRealIPFSHashExample123456789012345678901234';
+            const call = builder.ipfsHash(ipfsHash).build();
+            should_1.default.exist(call);
+            call.should.be.instanceOf(lib_1.UploadKycCall);
+            call.ipfsHash.should.equal(ipfsHash);
+            call.contractAddress.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+        });
+        it('should build uploadKYC call with custom contract address', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';
+            const customAddress = '0x1234567890123456789012345678901234567890';
+            const call = builder.ipfsHash(ipfsHash).contractAddress(customAddress).build();
+            should_1.default.exist(call);
+            call.contractAddress.should.equal(customAddress);
+        });
+        it('should accept IPFS v1 hash format (starting with "b")', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi';
+            const call = builder.ipfsHash(ipfsHash).build();
+            should_1.default.exist(call);
+            call.ipfsHash.should.equal(ipfsHash);
+        });
+        it('should throw error when IPFS hash is empty', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.ipfsHash('')).should.throw('IPFS hash cannot be empty');
+        });
+        it('should throw error when IPFS hash format is invalid', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.ipfsHash('InvalidHash123')).should.throw('Invalid IPFS hash format. Expected hash starting with "Qm" (v0) or "b" (v1)');
+        });
+        it('should throw error when contract address is empty', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.contractAddress('')).should.throw('Contract address cannot be empty');
+        });
+        it('should throw error when contract address format is invalid', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.contractAddress('InvalidAddress')).should.throw('Invalid contract address format');
+        });
+        it('should throw error when building without IPFS hash', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            (() => builder.build()).should.throw('Missing IPFS hash for uploadKYC transaction');
+        });
+        it('should normalize contract address with 0x prefix', () => {
+            const builder = new lib_1.UploadKycBuilder(coinConfig);
+            const ipfsHash = 'QmTestHash123456789012345678901234567890123';
+            const addressWithoutPrefix = '1234567890123456789012345678901234567890';
+            const call = builder.ipfsHash(ipfsHash).contractAddress(addressWithoutPrefix).build();
+            call.contractAddress.should.equal('0x' + addressWithoutPrefix);
+        });
+    });
+    describe('UploadKycCall', () => {
+        it('should serialize uploadKYC call correctly', () => {
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            const contractAddress = lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET;
+            const call = new lib_1.UploadKycCall(contractAddress, ipfsHash);
+            const serialized = call.serialize();
+            should_1.default.exist(serialized);
+            serialized.should.be.type('string');
+            // Should start with the method ID
+            serialized.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+        });
+        it('should have correct properties', () => {
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            const contractAddress = '0x0000000000000000000000000000000000000088';
+            const call = new lib_1.UploadKycCall(contractAddress, ipfsHash);
+            call.contractAddress.should.equal(contractAddress);
+            call.ipfsHash.should.equal(ipfsHash);
+        });
+    });
+    describe('TransactionBuilder integration', () => {
+        it('should build uploadKYC transaction with TransactionBuilder', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(1);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            should_1.default.exist(tx);
+            const txJson = tx.toJson();
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            txJson.value.should.equal('0');
+            should_1.default.exist(txJson.data);
+            // Data should start with uploadKYC method ID
+            txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+        });
+        it('should throw error when uploadKyc() is called on non-ContractCall transaction', () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder.type(sdk_core_1.TransactionType.Send);
+            (() => txBuilder.uploadKyc()).should.throw('uploadKYC can only be set for contract call transactions');
+        });
+        it('should build transaction with custom validator contract address', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';
+            const customAddress = '0x1234567890123456789012345678901234567890';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(1);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash).contractAddress(customAddress);
+            const tx = await txBuilder.build();
+            should_1.default.exist(tx);
+            const txJson = tx.toJson();
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(customAddress);
+        });
+        it('should build and serialize uploadKYC transaction', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmRealIPFSHashForSerialization1234567890123';
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(5);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            const serialized = tx.toBroadcastFormat();
+            should_1.default.exist(serialized);
+            serialized.should.be.type('string');
+            // Should be a valid hex string
+            serialized.should.match(/^(0x)?[0-9a-f]+$/i);
+        });
+        it('should parse uploadKYC transaction from hex', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            const ipfsHash = 'QmParseTestHash12345678901234567890123456';
+            // First build a transaction
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '10000000000',
+                gasLimit: '100000',
+            });
+            txBuilder.counter(10);
+            txBuilder.uploadKyc().ipfsHash(ipfsHash);
+            const tx = await txBuilder.build();
+            const serialized = tx.toBroadcastFormat();
+            // Now parse it back
+            const txBuilder2 = (0, getBuilder_1.getBuilder)('txdc');
+            txBuilder2.from(serialized);
+            const parsedTx = await txBuilder2.build();
+            should_1.default.exist(parsedTx);
+            const parsedJson = parsedTx.toJson();
+            should_1.default.exist(parsedJson.to);
+            parsedJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            parsedJson.nonce.should.equal(10);
+        });
+    });
+    describe('Real-world scenarios', () => {
+        it('should create transaction matching sandbox code pattern', async () => {
+            const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+            // Mock IPFS hash similar to what would be generated
+            const mockIPFSHash = 'Qm' + 'a'.repeat(44);
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.fee({
+                fee: '20000000000',
+                gasLimit: '200000',
+            });
+            txBuilder.counter(0);
+            txBuilder.uploadKyc().ipfsHash(mockIPFSHash);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            // Verify transaction structure matches expected format
+            should_1.default.exist(txJson.to);
+            txJson.to.should.equal(lib_1.XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);
+            txJson.value.should.equal('0');
+            should_1.default.exist(txJson.data);
+            txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+            should_1.default.exist(txJson.gasLimit);
+            should_1.default.exist(txJson.nonce);
+        });
+        it('should handle multiple IPFS hash formats', async () => {
+            const testHashes = [
+                'QmRealIPFSHashExample123456789012345678901234', // v0
+                'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi', // v1
+                'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // real example
+            ];
+            for (const hash of testHashes) {
+                const txBuilder = (0, getBuilder_1.getBuilder)('txdc');
+                txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+                txBuilder.fee({
+                    fee: '10000000000',
+                    gasLimit: '100000',
+                });
+                txBuilder.counter(1);
+                txBuilder.uploadKyc().ipfsHash(hash);
+                const tx = await txBuilder.build();
+                should_1.default.exist(tx);
+                const txJson = tx.toJson();
+                txJson.data.should.startWith(lib_1.UPLOAD_KYC_METHOD_ID);
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uploadKyc.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/uploadKyc.ts"],"names":[],"mappings":"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","sourcesContent":["import { getBuilder } from '../getBuilder';\nimport should from 'should';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { coins } from '@bitgo-beta/statics';\nimport {\n  UploadKycBuilder,\n  UploadKycCall,\n  XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET,\n  UPLOAD_KYC_METHOD_ID,\n} from '../../../src/lib';\n\ndescribe('XDC Upload KYC Builder', () => {\n  const coinConfig = coins.get('txdc');\n\n  describe('UploadKycBuilder', () => {\n    it('should build uploadKYC call with valid IPFS hash', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmRealIPFSHashExample123456789012345678901234';\n\n      const call = builder.ipfsHash(ipfsHash).build();\n\n      should.exist(call);\n      call.should.be.instanceOf(UploadKycCall);\n      call.ipfsHash.should.equal(ipfsHash);\n      call.contractAddress.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n    });\n\n    it('should build uploadKYC call with custom contract address', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';\n      const customAddress = '0x1234567890123456789012345678901234567890';\n\n      const call = builder.ipfsHash(ipfsHash).contractAddress(customAddress).build();\n\n      should.exist(call);\n      call.contractAddress.should.equal(customAddress);\n    });\n\n    it('should accept IPFS v1 hash format (starting with \"b\")', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi';\n\n      const call = builder.ipfsHash(ipfsHash).build();\n\n      should.exist(call);\n      call.ipfsHash.should.equal(ipfsHash);\n    });\n\n    it('should throw error when IPFS hash is empty', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.ipfsHash('')).should.throw('IPFS hash cannot be empty');\n    });\n\n    it('should throw error when IPFS hash format is invalid', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.ipfsHash('InvalidHash123')).should.throw(\n        'Invalid IPFS hash format. Expected hash starting with \"Qm\" (v0) or \"b\" (v1)'\n      );\n    });\n\n    it('should throw error when contract address is empty', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.contractAddress('')).should.throw('Contract address cannot be empty');\n    });\n\n    it('should throw error when contract address format is invalid', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.contractAddress('InvalidAddress')).should.throw('Invalid contract address format');\n    });\n\n    it('should throw error when building without IPFS hash', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n\n      (() => builder.build()).should.throw('Missing IPFS hash for uploadKYC transaction');\n    });\n\n    it('should normalize contract address with 0x prefix', () => {\n      const builder = new UploadKycBuilder(coinConfig);\n      const ipfsHash = 'QmTestHash123456789012345678901234567890123';\n      const addressWithoutPrefix = '1234567890123456789012345678901234567890';\n\n      const call = builder.ipfsHash(ipfsHash).contractAddress(addressWithoutPrefix).build();\n\n      call.contractAddress.should.equal('0x' + addressWithoutPrefix);\n    });\n  });\n\n  describe('UploadKycCall', () => {\n    it('should serialize uploadKYC call correctly', () => {\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n      const contractAddress = XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET;\n\n      const call = new UploadKycCall(contractAddress, ipfsHash);\n      const serialized = call.serialize();\n\n      should.exist(serialized);\n      serialized.should.be.type('string');\n      // Should start with the method ID\n      serialized.should.startWith(UPLOAD_KYC_METHOD_ID);\n    });\n\n    it('should have correct properties', () => {\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n      const contractAddress = '0x0000000000000000000000000000000000000088';\n\n      const call = new UploadKycCall(contractAddress, ipfsHash);\n\n      call.contractAddress.should.equal(contractAddress);\n      call.ipfsHash.should.equal(ipfsHash);\n    });\n  });\n\n  describe('TransactionBuilder integration', () => {\n    it('should build uploadKYC transaction with TransactionBuilder', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmTestIPFSHash1234567890123456789012345678';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(1);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n\n      should.exist(tx);\n      const txJson = tx.toJson();\n      should.exist(txJson.to);\n      txJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      txJson.value.should.equal('0');\n      should.exist(txJson.data);\n      // Data should start with uploadKYC method ID\n      txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n    });\n\n    it('should throw error when uploadKyc() is called on non-ContractCall transaction', () => {\n      const txBuilder = getBuilder('txdc');\n\n      txBuilder.type(TransactionType.Send);\n\n      (() => txBuilder.uploadKyc()).should.throw('uploadKYC can only be set for contract call transactions');\n    });\n\n    it('should build transaction with custom validator contract address', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmCustomIPFSHash123456789012345678901234567';\n      const customAddress = '0x1234567890123456789012345678901234567890';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(1);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash).contractAddress(customAddress);\n\n      const tx = await txBuilder.build();\n\n      should.exist(tx);\n      const txJson = tx.toJson();\n      should.exist(txJson.to);\n      txJson.to!.should.equal(customAddress);\n    });\n\n    it('should build and serialize uploadKYC transaction', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmRealIPFSHashForSerialization1234567890123';\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(5);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n      const serialized = tx.toBroadcastFormat();\n\n      should.exist(serialized);\n      serialized.should.be.type('string');\n      // Should be a valid hex string\n      serialized.should.match(/^(0x)?[0-9a-f]+$/i);\n    });\n\n    it('should parse uploadKYC transaction from hex', async () => {\n      const txBuilder = getBuilder('txdc');\n      const ipfsHash = 'QmParseTestHash12345678901234567890123456';\n\n      // First build a transaction\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '10000000000',\n        gasLimit: '100000',\n      });\n      txBuilder.counter(10);\n      txBuilder.uploadKyc().ipfsHash(ipfsHash);\n\n      const tx = await txBuilder.build();\n      const serialized = tx.toBroadcastFormat();\n\n      // Now parse it back\n      const txBuilder2 = getBuilder('txdc');\n      txBuilder2.from(serialized);\n      const parsedTx = await txBuilder2.build();\n\n      should.exist(parsedTx);\n      const parsedJson = parsedTx.toJson();\n      should.exist(parsedJson.to);\n      parsedJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      parsedJson.nonce.should.equal(10);\n    });\n  });\n\n  describe('Real-world scenarios', () => {\n    it('should create transaction matching sandbox code pattern', async () => {\n      const txBuilder = getBuilder('txdc');\n      // Mock IPFS hash similar to what would be generated\n      const mockIPFSHash = 'Qm' + 'a'.repeat(44);\n\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.fee({\n        fee: '20000000000',\n        gasLimit: '200000',\n      });\n      txBuilder.counter(0);\n      txBuilder.uploadKyc().ipfsHash(mockIPFSHash);\n\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n\n      // Verify transaction structure matches expected format\n      should.exist(txJson.to);\n      txJson.to!.should.equal(XDC_VALIDATOR_CONTRACT_ADDRESS_TESTNET);\n      txJson.value.should.equal('0');\n      should.exist(txJson.data);\n      txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n      should.exist(txJson.gasLimit);\n      should.exist(txJson.nonce);\n    });\n\n    it('should handle multiple IPFS hash formats', async () => {\n      const testHashes = [\n        'QmRealIPFSHashExample123456789012345678901234', // v0\n        'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi', // v1\n        'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG', // real example\n      ];\n\n      for (const hash of testHashes) {\n        const txBuilder = getBuilder('txdc');\n\n        txBuilder.type(TransactionType.ContractCall);\n        txBuilder.fee({\n          fee: '10000000000',\n          gasLimit: '100000',\n        });\n        txBuilder.counter(1);\n        txBuilder.uploadKyc().ipfsHash(hash);\n\n        const tx = await txBuilder.build();\n        should.exist(tx);\n\n        const txJson = tx.toJson();\n        txJson.data.should.startWith(UPLOAD_KYC_METHOD_ID);\n      }\n    });\n  });\n});\n"]}