@bitgo/sdk-coin-flrp 1.1.0

package/dist/src/lib/validatorTxBuilder.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const delegatorTxBuilder_1 = require("./delegatorTxBuilder");
+const constants_1 = require("./constants");
+class ValidatorTxBuilder extends delegatorTxBuilder_1.DelegatorTxBuilder {
+    /**
+     * @param coinConfig
+     */
+    constructor(coinConfig) {
+        super(coinConfig);
+        this._delegationFeeRate = undefined;
+    }
+    /**
+     * get transaction type
+     * @protected
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.AddValidator;
+    }
+    /**
+     * set the delegationFeeRate
+     * @param value number
+     */
+    delegationFeeRate(value) {
+        this.validateDelegationFeeRate(value);
+        this._delegationFeeRate = value;
+        return this;
+    }
+    /**
+     * Validate that the delegation fee is at least the minDelegationFee
+     * @param delegationFeeRate number
+     */
+    validateDelegationFeeRate(delegationFeeRate) {
+        // For Flare, use a minimum delegation fee of 2% (20000 basis points)
+        const minDelegationFee = constants_1.MIN_DELEGATION_FEE_BASIS_POINTS; // 2%
+        if (delegationFeeRate < minDelegationFee) {
+            throw new sdk_core_1.BuildTransactionError(`Delegation fee cannot be less than ${minDelegationFee} basis points (2%)`);
+        }
+    }
+    /** @inheritdoc */
+    initBuilder(tx) {
+        super.initBuilder(tx);
+        // Extract delegation fee rate from transaction if available
+        const txData = tx;
+        const validatorData = txData;
+        if (validatorData.delegationFeeRate !== undefined) {
+            this._delegationFeeRate = validatorData.delegationFeeRate;
+        }
+        return this;
+    }
+    /**
+     * Verify if the transaction is an AddValidator transaction
+     * @param tx
+     */
+    static verifyTxType(tx) {
+        // FlareJS validator transaction type verification
+        try {
+            if (!tx || typeof tx !== constants_1.OBJECT_TYPE_STRING) {
+                return false;
+            }
+            const txData = tx;
+            // Check for validator transaction type markers
+            const validValidatorTypes = constants_1.VALIDATOR_TRANSACTION_TYPES;
+            // Primary type verification
+            if (txData.type && typeof txData.type === constants_1.STRING_TYPE) {
+                if (validValidatorTypes.includes(txData.type)) {
+                    return true;
+                }
+            }
+            // Secondary verification through transaction structure
+            const hasValidatorStructure = 
+            // Has delegation fee rate (unique to validators)
+            (typeof txData.delegationFeeRate === 'number' ||
+                (txData.delegation &&
+                    typeof txData.delegation.delegationFeeRate === 'number')) &&
+                // Has node ID
+                (txData.nodeID || (txData.validator && txData.validator.nodeID)) &&
+                // Has staking information
+                (txData.stakeAmount || (txData.stake && txData.stake.amount));
+            // FlareJS-specific markers
+            const hasFlareJSValidatorMarkers = txData._txType === 'addValidator' ||
+                txData._validatorType === 'primary' ||
+                (txData.validator && txData.validator._flareJSReady === true);
+            return Boolean(hasValidatorStructure || hasFlareJSValidatorMarkers);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    verifyTxType(tx) {
+        return ValidatorTxBuilder.verifyTxType(tx);
+    }
+    /**
+     * Build the validator transaction using FlareJS PVM API
+     * @protected
+     */
+    async buildFlareTransaction() {
+        // Basic validation
+        if (!this._nodeID) {
+            throw new sdk_core_1.BuildTransactionError('Node ID is required for validator transaction');
+        }
+        if (!this._startTime) {
+            throw new sdk_core_1.BuildTransactionError('Start time is required for validator transaction');
+        }
+        if (!this._endTime) {
+            throw new sdk_core_1.BuildTransactionError('End time is required for validator transaction');
+        }
+        if (!this._stakeAmount) {
+            throw new sdk_core_1.BuildTransactionError('Stake amount is required for validator transaction');
+        }
+        if (this._delegationFeeRate === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Delegation fee rate is required for validator transaction');
+        }
+        const rewardAddresses = this.transaction._rewardAddresses;
+        if (!rewardAddresses || rewardAddresses.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('Reward addresses are required for validator transaction');
+        }
+        // Validate time range (inherited from DelegatorTxBuilder logic)
+        if (this._endTime <= this._startTime) {
+            throw new sdk_core_1.BuildTransactionError('End time must be after start time');
+        }
+        try {
+            // FlareJS PVM API implementation for validator transactions
+            // This creates a structured validator transaction compatible with FlareJS patterns
+            const enhancedValidatorTx = {
+                type: 'PlatformVM.AddValidatorTx',
+                networkID: this.transaction._networkID,
+                blockchainID: this.transaction._blockchainID,
+                // Enhanced validator information structure
+                validator: {
+                    nodeID: this._nodeID,
+                    startTime: this._startTime,
+                    endTime: this._endTime,
+                    stakeAmount: this._stakeAmount,
+                    // FlareJS validator markers
+                    _validatorType: 'primary',
+                    _flareJSReady: true,
+                    _pvmCompatible: true,
+                },
+                // Enhanced delegation information
+                delegation: {
+                    delegationFeeRate: this._delegationFeeRate,
+                    rewardAddress: rewardAddresses[0],
+                    // FlareJS delegation markers
+                    _delegationType: 'validator',
+                    _feeRate: this._delegationFeeRate,
+                    _flareJSReady: true,
+                },
+                // Enhanced transaction metadata
+                stake: {
+                    assetID: this.getAssetId(),
+                    amount: this._stakeAmount,
+                    addresses: this.transaction._fromAddresses,
+                    threshold: this.transaction._threshold || 1,
+                    locktime: this.transaction._locktime || 0n,
+                    // FlareJS stake markers
+                    _stakeType: 'validator',
+                    _flareJSReady: true,
+                },
+                // Enhanced credential structure for validators
+                credentials: this.transaction._fromAddresses.map(() => ({
+                    signatures: [], // Will be populated by FlareJS signing
+                    _credentialType: 'secp256k1fx.Credential',
+                    _validatorCredential: true,
+                    _flareJSReady: true,
+                })),
+                // Transaction metadata
+                memo: Buffer.alloc(0),
+            };
+            this.transaction.setTransaction(enhancedValidatorTx);
+        }
+        catch (error) {
+            throw new sdk_core_1.BuildTransactionError(`Failed to build validator transaction: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+}
+exports.ValidatorTxBuilder = ValidatorTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validatorTxBuilder.js","sourceRoot":"","sources":["../../../src/lib/validatorTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { DelegatorTxBuilder } from './delegatorTxBuilder';\nimport { Tx } from './iface';\nimport { RawTransactionData, ValidatorExtendedTransaction, ValidatorRawTransactionData } from './types';\nimport {\n  MIN_DELEGATION_FEE_BASIS_POINTS,\n  OBJECT_TYPE_STRING,\n  STRING_TYPE,\n  VALIDATOR_TRANSACTION_TYPES,\n} from './constants';\n\nexport class ValidatorTxBuilder extends DelegatorTxBuilder {\n  protected _delegationFeeRate: number | undefined;\n\n  /**\n   * @param coinConfig\n   */\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    this._delegationFeeRate = undefined;\n  }\n\n  /**\n   * get transaction type\n   * @protected\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.AddValidator;\n  }\n\n  /**\n   * set the delegationFeeRate\n   * @param value number\n   */\n  delegationFeeRate(value: number): this {\n    this.validateDelegationFeeRate(value);\n    this._delegationFeeRate = value;\n    return this;\n  }\n\n  /**\n   * Validate that the delegation fee is at least the minDelegationFee\n   * @param delegationFeeRate number\n   */\n  validateDelegationFeeRate(delegationFeeRate: number): void {\n    // For Flare, use a minimum delegation fee of 2% (20000 basis points)\n    const minDelegationFee = MIN_DELEGATION_FEE_BASIS_POINTS; // 2%\n    if (delegationFeeRate < minDelegationFee) {\n      throw new BuildTransactionError(`Delegation fee cannot be less than ${minDelegationFee} basis points (2%)`);\n    }\n  }\n\n  /** @inheritdoc */\n  initBuilder(tx: Tx): this {\n    super.initBuilder(tx);\n\n    // Extract delegation fee rate from transaction if available\n    const txData = tx as unknown as RawTransactionData;\n    const validatorData = txData as ValidatorRawTransactionData;\n    if (validatorData.delegationFeeRate !== undefined) {\n      this._delegationFeeRate = validatorData.delegationFeeRate;\n    }\n\n    return this;\n  }\n\n  /**\n   * Verify if the transaction is an AddValidator transaction\n   * @param tx\n   */\n  static verifyTxType(tx: unknown): boolean {\n    // FlareJS validator transaction type verification\n    try {\n      if (!tx || typeof tx !== OBJECT_TYPE_STRING) {\n        return false;\n      }\n\n      const txData = tx as Record<string, unknown>;\n\n      // Check for validator transaction type markers\n      const validValidatorTypes = VALIDATOR_TRANSACTION_TYPES;\n\n      // Primary type verification\n      if (txData.type && typeof txData.type === STRING_TYPE) {\n        if (validValidatorTypes.includes(txData.type as string)) {\n          return true;\n        }\n      }\n\n      // Secondary verification through transaction structure\n      const hasValidatorStructure =\n        // Has delegation fee rate (unique to validators)\n        (typeof txData.delegationFeeRate === 'number' ||\n          (txData.delegation &&\n            typeof (txData.delegation as Record<string, unknown>).delegationFeeRate === 'number')) &&\n        // Has node ID\n        (txData.nodeID || (txData.validator && (txData.validator as Record<string, unknown>).nodeID)) &&\n        // Has staking information\n        (txData.stakeAmount || (txData.stake && (txData.stake as Record<string, unknown>).amount));\n\n      // FlareJS-specific markers\n      const hasFlareJSValidatorMarkers =\n        txData._txType === 'addValidator' ||\n        txData._validatorType === 'primary' ||\n        (txData.validator && (txData.validator as Record<string, unknown>)._flareJSReady === true);\n\n      return Boolean(hasValidatorStructure || hasFlareJSValidatorMarkers);\n    } catch (error) {\n      return false;\n    }\n  }\n\n  verifyTxType(tx: unknown): boolean {\n    return ValidatorTxBuilder.verifyTxType(tx);\n  }\n\n  /**\n   * Build the validator transaction using FlareJS PVM API\n   * @protected\n   */\n  protected async buildFlareTransaction(): Promise<void> {\n    // Basic validation\n    if (!this._nodeID) {\n      throw new BuildTransactionError('Node ID is required for validator transaction');\n    }\n    if (!this._startTime) {\n      throw new BuildTransactionError('Start time is required for validator transaction');\n    }\n    if (!this._endTime) {\n      throw new BuildTransactionError('End time is required for validator transaction');\n    }\n    if (!this._stakeAmount) {\n      throw new BuildTransactionError('Stake amount is required for validator transaction');\n    }\n    if (this._delegationFeeRate === undefined) {\n      throw new BuildTransactionError('Delegation fee rate is required for validator transaction');\n    }\n\n    const rewardAddresses = (this.transaction as unknown as ValidatorExtendedTransaction)._rewardAddresses;\n    if (!rewardAddresses || rewardAddresses.length === 0) {\n      throw new BuildTransactionError('Reward addresses are required for validator transaction');\n    }\n\n    // Validate time range (inherited from DelegatorTxBuilder logic)\n    if (this._endTime <= this._startTime) {\n      throw new BuildTransactionError('End time must be after start time');\n    }\n\n    try {\n      // FlareJS PVM API implementation for validator transactions\n      // This creates a structured validator transaction compatible with FlareJS patterns\n\n      const enhancedValidatorTx = {\n        type: 'PlatformVM.AddValidatorTx',\n        networkID: this.transaction._networkID,\n        blockchainID: this.transaction._blockchainID,\n\n        // Enhanced validator information structure\n        validator: {\n          nodeID: this._nodeID,\n          startTime: this._startTime,\n          endTime: this._endTime,\n          stakeAmount: this._stakeAmount,\n          // FlareJS validator markers\n          _validatorType: 'primary',\n          _flareJSReady: true,\n          _pvmCompatible: true,\n        },\n\n        // Enhanced delegation information\n        delegation: {\n          delegationFeeRate: this._delegationFeeRate,\n          rewardAddress: rewardAddresses[0],\n          // FlareJS delegation markers\n          _delegationType: 'validator',\n          _feeRate: this._delegationFeeRate,\n          _flareJSReady: true,\n        },\n\n        // Enhanced transaction metadata\n        stake: {\n          assetID: this.getAssetId(),\n          amount: this._stakeAmount,\n          addresses: this.transaction._fromAddresses,\n          threshold: this.transaction._threshold || 1,\n          locktime: this.transaction._locktime || 0n,\n          // FlareJS stake markers\n          _stakeType: 'validator',\n          _flareJSReady: true,\n        },\n\n        // Enhanced credential structure for validators\n        credentials: this.transaction._fromAddresses.map(() => ({\n          signatures: [], // Will be populated by FlareJS signing\n          _credentialType: 'secp256k1fx.Credential',\n          _validatorCredential: true,\n          _flareJSReady: true,\n        })),\n\n        // Transaction metadata\n        memo: Buffer.alloc(0),\n      };\n\n      this.transaction.setTransaction(enhancedValidatorTx);\n    } catch (error) {\n      throw new BuildTransactionError(\n        `Failed to build validator transaction: ${error instanceof Error ? error.message : 'Unknown error'}`\n      );\n    }\n  }\n}\n"]}

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

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

package/dist/src/register.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const flrp_1 = require("./flrp");
+const tflrp_1 = require("./tflrp");
+const register = (sdk) => {
+    sdk.register('flrp', flrp_1.Flrp.createInstance);
+    sdk.register('tflrp', tflrp_1.TflrP.createInstance);
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsaUNBQThCO0FBQzlCLG1DQUFnQztBQUV6QixNQUFNLFFBQVEsR0FBRyxDQUFDLEdBQWMsRUFBUSxFQUFFO0lBQy9DLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLFdBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUMxQyxHQUFHLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxhQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7QUFDOUMsQ0FBQyxDQUFDO0FBSFcsUUFBQSxRQUFRLFlBR25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvL3Nkay1jb3JlJztcbmltcG9ydCB7IEZscnAgfSBmcm9tICcuL2ZscnAnO1xuaW1wb3J0IHsgVGZsclAgfSBmcm9tICcuL3RmbHJwJztcblxuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyID0gKHNkazogQml0R29CYXNlKTogdm9pZCA9PiB7XG4gIHNkay5yZWdpc3RlcignZmxycCcsIEZscnAuY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3RmbHJwJywgVGZsclAuY3JlYXRlSW5zdGFuY2UpO1xufTtcbiJdfQ==

package/dist/src/tflrp.d.ts

@@ -0,0 +1,8 @@
+import { BaseCoin, BitGoBase } from '@bitgo/sdk-core';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { Flrp } from './flrp';
+export declare class TflrP extends Flrp {
+    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+}
+//# sourceMappingURL=tflrp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tflrp.d.ts","sourceRoot":"","sources":["../../src/tflrp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,qBAAa,KAAM,SAAQ,IAAI;gBACjB,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAIrE,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;CAG3F"}

package/dist/src/tflrp.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TflrP = void 0;
+const flrp_1 = require("./flrp");
+class TflrP extends flrp_1.Flrp {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new TflrP(bitgo, staticsCoin);
+    }
+}
+exports.TflrP = TflrP;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGZscnAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGZscnAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsaUNBQThCO0FBRTlCLE1BQWEsS0FBTSxTQUFRLFdBQUk7SUFDN0IsWUFBWSxLQUFnQixFQUFFLFdBQXVDO1FBQ25FLEtBQUssQ0FBQyxLQUFLLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDNUIsQ0FBQztJQUVELE1BQU0sQ0FBQyxjQUFjLENBQUMsS0FBZ0IsRUFBRSxXQUF1QztRQUM3RSxPQUFPLElBQUksS0FBSyxDQUFDLEtBQUssRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN2QyxDQUFDO0NBQ0Y7QUFSRCxzQkFRQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VDb2luLCBCaXRHb0Jhc2UgfSBmcm9tICdAYml0Z28vc2RrLWNvcmUnO1xuaW1wb3J0IHsgQmFzZUNvaW4gYXMgU3RhdGljc0Jhc2VDb2luIH0gZnJvbSAnQGJpdGdvL3N0YXRpY3MnO1xuaW1wb3J0IHsgRmxycCB9IGZyb20gJy4vZmxycCc7XG5cbmV4cG9ydCBjbGFzcyBUZmxyUCBleHRlbmRzIEZscnAge1xuICBjb25zdHJ1Y3RvcihiaXRnbzogQml0R29CYXNlLCBzdGF0aWNzQ29pbj86IFJlYWRvbmx5PFN0YXRpY3NCYXNlQ29pbj4pIHtcbiAgICBzdXBlcihiaXRnbywgc3RhdGljc0NvaW4pO1xuICB9XG5cbiAgc3RhdGljIGNyZWF0ZUluc3RhbmNlKGJpdGdvOiBCaXRHb0Jhc2UsIHN0YXRpY3NDb2luPzogUmVhZG9ubHk8U3RhdGljc0Jhc2VDb2luPik6IEJhc2VDb2luIHtcbiAgICByZXR1cm4gbmV3IFRmbHJQKGJpdGdvLCBzdGF0aWNzQ29pbik7XG4gIH1cbn1cbiJdfQ==

package/dist/test/unit/delegatorTxBuilder.test.d.ts

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

package/dist/test/unit/delegatorTxBuilder.test.d.ts.map

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

package/dist/test/unit/delegatorTxBuilder.test.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const statics_1 = require("@bitgo/statics");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const assert = __importStar(require("assert"));
+const delegatorTxBuilder_1 = require("../../src/lib/delegatorTxBuilder");
+describe('DelegatorTxBuilder', function () {
+    const coinConfig = statics_1.coins.get('tflrp');
+    let builder;
+    beforeEach(function () {
+        builder = new delegatorTxBuilder_1.DelegatorTxBuilder(coinConfig);
+    });
+    describe('Constructor', function () {
+        it('should initialize with coin config', function () {
+            assert.ok(builder);
+            assert.ok(builder instanceof delegatorTxBuilder_1.DelegatorTxBuilder);
+        });
+        it('should initialize with default values', function () {
+            assert.strictEqual(builder['_nodeID'], '');
+            assert.strictEqual(builder['_startTime'], 0n);
+            assert.strictEqual(builder['_endTime'], 0n);
+            assert.strictEqual(builder['_stakeAmount'], 0n);
+        });
+        it('should set transaction type to AddDelegator', function () {
+            assert.strictEqual(builder['transactionType'], sdk_core_1.TransactionType.AddDelegator);
+        });
+    });
+    describe('nodeID', function () {
+        it('should set node ID correctly', function () {
+            const nodeID = 'NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg';
+            const result = builder.nodeID(nodeID);
+            assert.strictEqual(builder['_nodeID'], nodeID);
+            assert.strictEqual(result, builder);
+        });
+        it('should throw error for empty node ID', function () {
+            assert.throws(() => builder.nodeID(''), sdk_core_1.BuildTransactionError);
+        });
+    });
+    describe('startTime', function () {
+        it('should set start time from number', function () {
+            const time = 1640995200;
+            const result = builder.startTime(time);
+            assert.strictEqual(builder['_startTime'], BigInt(time));
+            assert.strictEqual(result, builder);
+        });
+        it('should set start time from string', function () {
+            const time = '1640995200';
+            const result = builder.startTime(time);
+            assert.strictEqual(builder['_startTime'], BigInt(time));
+            assert.strictEqual(result, builder);
+        });
+        it('should set start time from bigint', function () {
+            const time = 1640995200n;
+            const result = builder.startTime(time);
+            assert.strictEqual(builder['_startTime'], time);
+            assert.strictEqual(result, builder);
+        });
+        it('should throw error for zero start time', function () {
+            assert.throws(() => builder.startTime(0), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error for negative start time', function () {
+            assert.throws(() => builder.startTime(-1), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error when start time is after end time', function () {
+            builder.endTime(1640995200); // Set end time first
+            assert.throws(() => builder.startTime(1672531200), sdk_core_1.BuildTransactionError); // Start time after end time
+        });
+        it('should allow start time before end time', function () {
+            builder.endTime(1672531200); // Set end time first
+            const result = builder.startTime(1640995200); // Start time before end time
+            assert.strictEqual(result, builder);
+        });
+    });
+    describe('endTime', function () {
+        it('should set end time from number', function () {
+            const time = 1672531200;
+            const result = builder.endTime(time);
+            assert.strictEqual(builder['_endTime'], BigInt(time));
+            assert.strictEqual(result, builder);
+        });
+        it('should set end time from string', function () {
+            const time = '1672531200';
+            const result = builder.endTime(time);
+            assert.strictEqual(builder['_endTime'], BigInt(time));
+            assert.strictEqual(result, builder);
+        });
+        it('should set end time from bigint', function () {
+            const time = 1672531200n;
+            const result = builder.endTime(time);
+            assert.strictEqual(builder['_endTime'], time);
+            assert.strictEqual(result, builder);
+        });
+        it('should throw error for zero end time', function () {
+            assert.throws(() => builder.endTime(0), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error for negative end time', function () {
+            assert.throws(() => builder.endTime(-1), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error when end time is before start time', function () {
+            builder.startTime(1672531200); // Set start time first
+            assert.throws(() => builder.endTime(1640995200), sdk_core_1.BuildTransactionError); // End time before start time
+        });
+        it('should allow end time after start time', function () {
+            builder.startTime(1640995200); // Set start time first
+            const result = builder.endTime(1672531200); // End time after start time
+            assert.strictEqual(result, builder);
+        });
+    });
+    describe('stakeAmount', function () {
+        it('should set stake amount from number', function () {
+            const amount = 50000000000000000000n;
+            const result = builder.stakeAmount(amount);
+            assert.strictEqual(builder['_stakeAmount'], amount);
+            assert.strictEqual(result, builder);
+        });
+        it('should set stake amount from string', function () {
+            const amount = '50000000000000000000';
+            const result = builder.stakeAmount(amount);
+            assert.strictEqual(builder['_stakeAmount'], BigInt(amount));
+            assert.strictEqual(result, builder);
+        });
+        it('should throw error for zero stake amount', function () {
+            assert.throws(() => builder.stakeAmount(0), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error for negative stake amount', function () {
+            assert.throws(() => builder.stakeAmount(-1), sdk_core_1.BuildTransactionError);
+        });
+    });
+    describe('rewardAddresses', function () {
+        it('should set reward addresses correctly', function () {
+            const addresses = ['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph'];
+            const result = builder.rewardAddresses(addresses);
+            assert.strictEqual(result, builder);
+        });
+        it('should throw error for empty addresses array', function () {
+            assert.throws(() => builder.rewardAddresses([]), sdk_core_1.BuildTransactionError);
+        });
+    });
+    describe('verifyTxType', function () {
+        it('should return true for valid delegator transaction', function () {
+            const tx = {
+                nodeID: 'NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg',
+                stakeAmount: '50000000000000000000',
+            };
+            assert.strictEqual(delegatorTxBuilder_1.DelegatorTxBuilder.verifyTxType(tx), true);
+            assert.strictEqual(builder.verifyTxType(tx), true);
+        });
+        it('should return false for invalid transaction', function () {
+            const tx = { stakeAmount: '50000000000000000000' };
+            assert.strictEqual(delegatorTxBuilder_1.DelegatorTxBuilder.verifyTxType(tx), false);
+        });
+        it('should return false for empty transaction', function () {
+            assert.strictEqual(delegatorTxBuilder_1.DelegatorTxBuilder.verifyTxType({}), false);
+        });
+    });
+    describe('buildFlareTransaction', function () {
+        beforeEach(function () {
+            builder
+                .nodeID('NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg')
+                .startTime(1640995200)
+                .endTime(1672531200)
+                .stakeAmount(50000000000000000000n)
+                .rewardAddresses(['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph']);
+        });
+        it('should throw error if nodeID is missing', async function () {
+            builder['_nodeID'] = '';
+            await assert.rejects(builder['buildFlareTransaction'](), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error if startTime is missing', async function () {
+            builder['_startTime'] = 0n;
+            await assert.rejects(builder['buildFlareTransaction'](), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error if endTime is missing', async function () {
+            builder['_endTime'] = 0n;
+            await assert.rejects(builder['buildFlareTransaction'](), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error if stakeAmount is missing', async function () {
+            builder['_stakeAmount'] = 0n;
+            await assert.rejects(builder['buildFlareTransaction'](), sdk_core_1.BuildTransactionError);
+        });
+        it('should throw error if end time is before start time', function () {
+            // This test verifies that time validation happens immediately when setting values
+            assert.throws(() => {
+                builder.startTime(1672531200).endTime(1640995200);
+            }, sdk_core_1.BuildTransactionError);
+        });
+    });
+    describe('method chaining', function () {
+        it('should support method chaining', function () {
+            const result = builder
+                .nodeID('NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg')
+                .startTime(1640995200)
+                .endTime(1672531200)
+                .stakeAmount(50000000000000000000n)
+                .rewardAddresses(['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph']);
+            assert.strictEqual(result, builder);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegatorTxBuilder.test.js","sourceRoot":"","sources":["../../../test/unit/delegatorTxBuilder.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAAuC;AACvC,8CAAyE;AACzE,+CAAiC;AACjC,yEAAsE;AAEtE,QAAQ,CAAC,oBAAoB,EAAE;IAC7B,MAAM,UAAU,GAAG,eAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACtC,IAAI,OAA2B,CAAC;IAEhC,UAAU,CAAC;QACT,OAAO,GAAG,IAAI,uCAAkB,CAAC,UAAU,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,aAAa,EAAE;QACtB,EAAE,CAAC,oCAAoC,EAAE;YACvC,MAAM,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;YACnB,MAAM,CAAC,EAAE,CAAC,OAAO,YAAY,uCAAkB,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uCAAuC,EAAE;YAC1C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAC;YAC9C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;YAC5C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE;YAChD,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,0BAAe,CAAC,YAAY,CAAC,CAAC;QAC/E,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,QAAQ,EAAE;QACjB,EAAE,CAAC,8BAA8B,EAAE;YACjC,MAAM,MAAM,GAAG,0CAA0C,CAAC;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACtC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC;YAC/C,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE;YACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,WAAW,EAAE;QACpB,EAAE,CAAC,mCAAmC,EAAE;YACtC,MAAM,IAAI,GAAG,UAAU,CAAC;YACxB,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE;YACtC,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACxD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,mCAAmC,EAAE;YACtC,MAAM,IAAI,GAAG,WAAW,CAAC;YACzB,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC,CAAC;YAChD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE;YAC3C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE;YAC/C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE;YACzD,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,qBAAqB;YAClD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,gCAAqB,CAAC,CAAC,CAAC,4BAA4B;QACzG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE;YAC5C,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,qBAAqB;YAClD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,6BAA6B;YAC3E,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,SAAS,EAAE;QAClB,EAAE,CAAC,iCAAiC,EAAE;YACpC,MAAM,IAAI,GAAG,UAAU,CAAC;YACxB,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACtD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE;YACpC,MAAM,IAAI,GAAG,YAAY,CAAC;YAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;YACtD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iCAAiC,EAAE;YACpC,MAAM,IAAI,GAAG,WAAW,CAAC;YACzB,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC;YAC9C,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sCAAsC,EAAE;YACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE;YAC7C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QAClE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,uDAAuD,EAAE;YAC1D,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,uBAAuB;YACtD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,gCAAqB,CAAC,CAAC,CAAC,6BAA6B;QACxG,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE;YAC3C,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,uBAAuB;YACtD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,4BAA4B;YACxE,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,aAAa,EAAE;QACtB,EAAE,CAAC,qCAAqC,EAAE;YACxC,MAAM,MAAM,GAAG,qBAAqB,CAAC;YACrC,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,CAAC;YACpD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAE;YACxC,MAAM,MAAM,GAAG,sBAAsB,CAAC;YACtC,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAC5D,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE;YAC7C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE;YACjD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,gCAAqB,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,EAAE,CAAC,uCAAuC,EAAE;YAC1C,MAAM,SAAS,GAAG,CAAC,sDAAsD,CAAC,CAAC;YAC3E,MAAM,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;YAClD,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE;YACjD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC,EAAE,gCAAqB,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,cAAc,EAAE;QACvB,EAAE,CAAC,oDAAoD,EAAE;YACvD,MAAM,EAAE,GAAG;gBACT,MAAM,EAAE,0CAA0C;gBAClD,WAAW,EAAE,sBAAsB;aACpC,CAAC;YACF,MAAM,CAAC,WAAW,CAAC,uCAAkB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;YAC9D,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6CAA6C,EAAE;YAChD,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,sBAAsB,EAAE,CAAC;YACnD,MAAM,CAAC,WAAW,CAAC,uCAAkB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2CAA2C,EAAE;YAC9C,MAAM,CAAC,WAAW,CAAC,uCAAkB,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QACjE,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,uBAAuB,EAAE;QAChC,UAAU,CAAC;YACT,OAAO;iBACJ,MAAM,CAAC,0CAA0C,CAAC;iBAClD,SAAS,CAAC,UAAU,CAAC;iBACrB,OAAO,CAAC,UAAU,CAAC;iBACnB,WAAW,CAAC,qBAAqB,CAAC;iBAClC,eAAe,CAAC,CAAC,sDAAsD,CAAC,CAAC,CAAC;QAC/E,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yCAAyC,EAAE,KAAK;YACjD,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC;YACxB,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,EAAE,EAAE,gCAAqB,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,4CAA4C,EAAE,KAAK;YACpD,OAAO,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;YAC3B,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,EAAE,EAAE,gCAAqB,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,KAAK;YAClD,OAAO,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;YACzB,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,EAAE,EAAE,gCAAqB,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8CAA8C,EAAE,KAAK;YACtD,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC;YAC7B,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,EAAE,EAAE,gCAAqB,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qDAAqD,EAAE;YACxD,kFAAkF;YAClF,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;gBACjB,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YACpD,CAAC,EAAE,gCAAqB,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE;QAC1B,EAAE,CAAC,gCAAgC,EAAE;YACnC,MAAM,MAAM,GAAG,OAAO;iBACnB,MAAM,CAAC,0CAA0C,CAAC;iBAClD,SAAS,CAAC,UAAU,CAAC;iBACrB,OAAO,CAAC,UAAU,CAAC;iBACnB,WAAW,CAAC,qBAAqB,CAAC;iBAClC,eAAe,CAAC,CAAC,sDAAsD,CAAC,CAAC,CAAC;YAE7E,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import { coins } from '@bitgo/statics';\nimport { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport * as assert from 'assert';\nimport { DelegatorTxBuilder } from '../../src/lib/delegatorTxBuilder';\n\ndescribe('DelegatorTxBuilder', function () {\n  const coinConfig = coins.get('tflrp');\n  let builder: DelegatorTxBuilder;\n\n  beforeEach(function () {\n    builder = new DelegatorTxBuilder(coinConfig);\n  });\n\n  describe('Constructor', function () {\n    it('should initialize with coin config', function () {\n      assert.ok(builder);\n      assert.ok(builder instanceof DelegatorTxBuilder);\n    });\n\n    it('should initialize with default values', function () {\n      assert.strictEqual(builder['_nodeID'], '');\n      assert.strictEqual(builder['_startTime'], 0n);\n      assert.strictEqual(builder['_endTime'], 0n);\n      assert.strictEqual(builder['_stakeAmount'], 0n);\n    });\n\n    it('should set transaction type to AddDelegator', function () {\n      assert.strictEqual(builder['transactionType'], TransactionType.AddDelegator);\n    });\n  });\n\n  describe('nodeID', function () {\n    it('should set node ID correctly', function () {\n      const nodeID = 'NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg';\n      const result = builder.nodeID(nodeID);\n      assert.strictEqual(builder['_nodeID'], nodeID);\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw error for empty node ID', function () {\n      assert.throws(() => builder.nodeID(''), BuildTransactionError);\n    });\n  });\n\n  describe('startTime', function () {\n    it('should set start time from number', function () {\n      const time = 1640995200;\n      const result = builder.startTime(time);\n      assert.strictEqual(builder['_startTime'], BigInt(time));\n      assert.strictEqual(result, builder);\n    });\n\n    it('should set start time from string', function () {\n      const time = '1640995200';\n      const result = builder.startTime(time);\n      assert.strictEqual(builder['_startTime'], BigInt(time));\n      assert.strictEqual(result, builder);\n    });\n\n    it('should set start time from bigint', function () {\n      const time = 1640995200n;\n      const result = builder.startTime(time);\n      assert.strictEqual(builder['_startTime'], time);\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw error for zero start time', function () {\n      assert.throws(() => builder.startTime(0), BuildTransactionError);\n    });\n\n    it('should throw error for negative start time', function () {\n      assert.throws(() => builder.startTime(-1), BuildTransactionError);\n    });\n\n    it('should throw error when start time is after end time', function () {\n      builder.endTime(1640995200); // Set end time first\n      assert.throws(() => builder.startTime(1672531200), BuildTransactionError); // Start time after end time\n    });\n\n    it('should allow start time before end time', function () {\n      builder.endTime(1672531200); // Set end time first\n      const result = builder.startTime(1640995200); // Start time before end time\n      assert.strictEqual(result, builder);\n    });\n  });\n\n  describe('endTime', function () {\n    it('should set end time from number', function () {\n      const time = 1672531200;\n      const result = builder.endTime(time);\n      assert.strictEqual(builder['_endTime'], BigInt(time));\n      assert.strictEqual(result, builder);\n    });\n\n    it('should set end time from string', function () {\n      const time = '1672531200';\n      const result = builder.endTime(time);\n      assert.strictEqual(builder['_endTime'], BigInt(time));\n      assert.strictEqual(result, builder);\n    });\n\n    it('should set end time from bigint', function () {\n      const time = 1672531200n;\n      const result = builder.endTime(time);\n      assert.strictEqual(builder['_endTime'], time);\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw error for zero end time', function () {\n      assert.throws(() => builder.endTime(0), BuildTransactionError);\n    });\n\n    it('should throw error for negative end time', function () {\n      assert.throws(() => builder.endTime(-1), BuildTransactionError);\n    });\n\n    it('should throw error when end time is before start time', function () {\n      builder.startTime(1672531200); // Set start time first\n      assert.throws(() => builder.endTime(1640995200), BuildTransactionError); // End time before start time\n    });\n\n    it('should allow end time after start time', function () {\n      builder.startTime(1640995200); // Set start time first\n      const result = builder.endTime(1672531200); // End time after start time\n      assert.strictEqual(result, builder);\n    });\n  });\n\n  describe('stakeAmount', function () {\n    it('should set stake amount from number', function () {\n      const amount = 50000000000000000000n;\n      const result = builder.stakeAmount(amount);\n      assert.strictEqual(builder['_stakeAmount'], amount);\n      assert.strictEqual(result, builder);\n    });\n\n    it('should set stake amount from string', function () {\n      const amount = '50000000000000000000';\n      const result = builder.stakeAmount(amount);\n      assert.strictEqual(builder['_stakeAmount'], BigInt(amount));\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw error for zero stake amount', function () {\n      assert.throws(() => builder.stakeAmount(0), BuildTransactionError);\n    });\n\n    it('should throw error for negative stake amount', function () {\n      assert.throws(() => builder.stakeAmount(-1), BuildTransactionError);\n    });\n  });\n\n  describe('rewardAddresses', function () {\n    it('should set reward addresses correctly', function () {\n      const addresses = ['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph'];\n      const result = builder.rewardAddresses(addresses);\n      assert.strictEqual(result, builder);\n    });\n\n    it('should throw error for empty addresses array', function () {\n      assert.throws(() => builder.rewardAddresses([]), BuildTransactionError);\n    });\n  });\n\n  describe('verifyTxType', function () {\n    it('should return true for valid delegator transaction', function () {\n      const tx = {\n        nodeID: 'NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg',\n        stakeAmount: '50000000000000000000',\n      };\n      assert.strictEqual(DelegatorTxBuilder.verifyTxType(tx), true);\n      assert.strictEqual(builder.verifyTxType(tx), true);\n    });\n\n    it('should return false for invalid transaction', function () {\n      const tx = { stakeAmount: '50000000000000000000' };\n      assert.strictEqual(DelegatorTxBuilder.verifyTxType(tx), false);\n    });\n\n    it('should return false for empty transaction', function () {\n      assert.strictEqual(DelegatorTxBuilder.verifyTxType({}), false);\n    });\n  });\n\n  describe('buildFlareTransaction', function () {\n    beforeEach(function () {\n      builder\n        .nodeID('NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg')\n        .startTime(1640995200)\n        .endTime(1672531200)\n        .stakeAmount(50000000000000000000n)\n        .rewardAddresses(['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph']);\n    });\n\n    it('should throw error if nodeID is missing', async function () {\n      builder['_nodeID'] = '';\n      await assert.rejects(builder['buildFlareTransaction'](), BuildTransactionError);\n    });\n\n    it('should throw error if startTime is missing', async function () {\n      builder['_startTime'] = 0n;\n      await assert.rejects(builder['buildFlareTransaction'](), BuildTransactionError);\n    });\n\n    it('should throw error if endTime is missing', async function () {\n      builder['_endTime'] = 0n;\n      await assert.rejects(builder['buildFlareTransaction'](), BuildTransactionError);\n    });\n\n    it('should throw error if stakeAmount is missing', async function () {\n      builder['_stakeAmount'] = 0n;\n      await assert.rejects(builder['buildFlareTransaction'](), BuildTransactionError);\n    });\n\n    it('should throw error if end time is before start time', function () {\n      // This test verifies that time validation happens immediately when setting values\n      assert.throws(() => {\n        builder.startTime(1672531200).endTime(1640995200);\n      }, BuildTransactionError);\n    });\n  });\n\n  describe('method chaining', function () {\n    it('should support method chaining', function () {\n      const result = builder\n        .nodeID('NodeID-7Xhw2mDxuDS44j42TCB6U5579esbSt3Lg')\n        .startTime(1640995200)\n        .endTime(1672531200)\n        .stakeAmount(50000000000000000000n)\n        .rewardAddresses(['P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqpk7kph']);\n\n      assert.strictEqual(result, builder);\n    });\n  });\n});\n"]}

package/dist/test/unit/flrp.d.ts

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

package/dist/test/unit/flrp.d.ts.map

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