@bitgo-beta/sdk-coin-vet 1.0.1-beta.66 → 1.0.1-beta.661

package/dist/test/unit/keyPair.js

@@ -0,0 +1,181 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nacl = __importStar(require("tweetnacl"));
+const assert_1 = __importDefault(require("assert"));
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../../src");
+describe('VeChain KeyPair', function () {
+    // these are all encodings of the same key so the test suite will show that they we can interchange between them
+    const xprv = 'xprv9s21ZrQH143K3D8TXfvAJgHVfTEeQNW5Ys9wZtnUZkqPzFzSjbEJrWC1vZ4GnXCvR7rQL2UFX3RSuYeU9MrERm1XBvACow7c36vnz5iYyj2';
+    const xpub = 'xpub661MyMwAqRbcFhCvdhTAfpEEDV58oqDvv65YNHC686NNs4KbH8YZQJWVmrfbve7aAVHzxw8bKFxA7MLeDK6BbLfkE3bqkvHLPgaGHHtYGeY';
+    const prv = '82A34E3867EA7EA4E67E27865D500AE84E98D07AB1BAB06526F0A5A5FDCC3EBA';
+    const pub = '03D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A8275';
+    const uncompressedPub = '04D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A827503E948A2FDBF74A981D4E0054F10EDA7042C2D469F44473D3C7791E0E326E355';
+    const address = '0xeb317b9f2e0891d66c061ddc3f5ee7ed42d70a44';
+    const invalidPrivateKeyErrorMessage = 'Unsupported private key';
+    describe('should create a KeyPair', function () {
+        it('from an xpub', () => {
+            const keyPair = new src_1.KeyPair({ pub: xpub });
+            const defaultKeys = keyPair.getKeys();
+            should_1.default.not.exist(defaultKeys.prv);
+            defaultKeys.pub.should.equal('03D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A8275');
+            const extendedKeys = keyPair.getExtendedKeys();
+            should_1.default.not.exist(extendedKeys.xprv);
+            extendedKeys.xpub.should.equal(xpub);
+        });
+        it('from an xprv', () => {
+            const keyPair = new src_1.KeyPair({ prv: xprv });
+            const defaultKeys = keyPair.getKeys();
+            (0, assert_1.default)(defaultKeys.prv);
+            defaultKeys.prv.should.equal(prv);
+            defaultKeys.pub.should.equal(pub);
+            const extendedKeys = keyPair.getExtendedKeys();
+            (0, assert_1.default)(extendedKeys.xprv);
+            extendedKeys.xprv.should.equal(xprv);
+            extendedKeys.xpub.should.equal(xpub);
+        });
+        it('from an uncompressed public key', () => {
+            const keyPair = new src_1.KeyPair({ pub: uncompressedPub });
+            const defaultKeys = keyPair.getKeys();
+            should_1.default.not.exist(defaultKeys.prv);
+            defaultKeys.pub.should.equal(uncompressedPub);
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+        it('from a compressed public key', () => {
+            const keyPair = new src_1.KeyPair({ pub });
+            const defaultKeys = keyPair.getKeys();
+            should_1.default.not.exist(defaultKeys.prv);
+            defaultKeys.pub.should.equal(uncompressedPub);
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+        it('from a raw private key', () => {
+            const keyPair = new src_1.KeyPair({ prv });
+            const defaultKeys = keyPair.getKeys();
+            (0, assert_1.default)(defaultKeys.prv);
+            defaultKeys.prv.should.equal(prv);
+            defaultKeys.pub.should.equal(uncompressedPub);
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+        it('from an empty value', () => {
+            const keyPair = new src_1.KeyPair();
+            should_1.default.exists(keyPair.getKeys().prv);
+            should_1.default.exists(keyPair.getKeys().pub);
+            const keys = keyPair.getKeys();
+            (0, assert_1.default)(keys.prv);
+            should_1.default.equal(keys.prv.length, 64);
+            should_1.default.equal(keys.pub.length, 66);
+        });
+        it('from seed', () => {
+            const seed = nacl.randomBytes(64);
+            const keyPair = new src_1.KeyPair({ seed: Buffer.from(seed) });
+            keyPair.getKeys().should.have.property('pub');
+            keyPair.getKeys().should.have.property('prv');
+        });
+    });
+    describe('should fail to create a KeyPair', function () {
+        it('from an invalid public key', () => {
+            const source = {
+                pub: '01D63D',
+            };
+            assert_1.default.throws(() => new src_1.KeyPair(source));
+        });
+        it('from an invalid private key', () => {
+            const source = {
+                prv: '82A34E',
+            };
+            assert_1.default.throws(() => new src_1.KeyPair(source));
+            assert_1.default.throws(() => new src_1.KeyPair({ prv: prv + pub }), (e) => e.message === invalidPrivateKeyErrorMessage);
+        });
+    });
+    describe('getAddress', function () {
+        it('should get an address from xprv', () => {
+            const keyPair = new src_1.KeyPair({ prv: xprv });
+            const calculatedAddress = keyPair.getAddress();
+            calculatedAddress.should.equal(address);
+        });
+        it('should get an address from xpub', () => {
+            const keyPair = new src_1.KeyPair({ pub: xpub });
+            const calculatedAddress = keyPair.getAddress();
+            calculatedAddress.should.equal(address);
+        });
+        it('should get an address from prv', () => {
+            const keyPair = new src_1.KeyPair({ prv });
+            const calculatedAddress = keyPair.getAddress();
+            calculatedAddress.should.equal(address);
+        });
+        it('should get an address from pub', () => {
+            const keyPair = new src_1.KeyPair({ pub });
+            const calculatedAddress = keyPair.getAddress();
+            calculatedAddress.should.equal(address);
+        });
+        it('should get an address from uncompressed pub', () => {
+            const keyPair = new src_1.KeyPair({ pub: uncompressedPub });
+            const calculatedAddress = keyPair.getAddress();
+            calculatedAddress.should.equal(address);
+        });
+    });
+    describe('getExtendedKeys', function () {
+        it('should get the keys in extended format from xprv', () => {
+            const keyPair = new src_1.KeyPair({ prv: xprv });
+            const { xprv: calculatedXprv, xpub: calculatedXpub } = keyPair.getExtendedKeys();
+            (0, assert_1.default)(calculatedXprv);
+            calculatedXprv.should.equal(xprv);
+            calculatedXpub.should.equal(xpub);
+        });
+        it('should get the keys in extended format from xpub', () => {
+            const keyPair = new src_1.KeyPair({ pub: xpub });
+            const { xprv: calculatedXprv, xpub: calculatedXpub } = keyPair.getExtendedKeys();
+            should_1.default.not.exist(calculatedXprv);
+            calculatedXpub.should.equal(xpub);
+        });
+        it('should not be able to get keys from prv', () => {
+            const keyPair = new src_1.KeyPair({ prv });
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+        it('should get the keys in extended format from pub', () => {
+            const keyPair = new src_1.KeyPair({ pub });
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+        it('should get the keys in extended format from uncompressed pub', () => {
+            const keyPair = new src_1.KeyPair({ pub: uncompressedPub });
+            assert_1.default.throws(() => keyPair.getExtendedKeys());
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPair.js","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import * as nacl from 'tweetnacl';\nimport assert from 'assert';\nimport should from 'should';\n\nimport { KeyPair } from '../../src';\n\ndescribe('VeChain KeyPair', function () {\n  // these are all encodings of the same key so the test suite will show that they we can interchange between them\n  const xprv =\n    'xprv9s21ZrQH143K3D8TXfvAJgHVfTEeQNW5Ys9wZtnUZkqPzFzSjbEJrWC1vZ4GnXCvR7rQL2UFX3RSuYeU9MrERm1XBvACow7c36vnz5iYyj2';\n  const xpub =\n    'xpub661MyMwAqRbcFhCvdhTAfpEEDV58oqDvv65YNHC686NNs4KbH8YZQJWVmrfbve7aAVHzxw8bKFxA7MLeDK6BbLfkE3bqkvHLPgaGHHtYGeY';\n  const prv = '82A34E3867EA7EA4E67E27865D500AE84E98D07AB1BAB06526F0A5A5FDCC3EBA';\n  const pub = '03D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A8275';\n  const uncompressedPub =\n    '04D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A827503E948A2FDBF74A981D4E0054F10EDA7042C2D469F44473D3C7791E0E326E355';\n  const address = '0xeb317b9f2e0891d66c061ddc3f5ee7ed42d70a44';\n  const invalidPrivateKeyErrorMessage = 'Unsupported private key';\n\n  describe('should create a KeyPair', function () {\n    it('from an xpub', () => {\n      const keyPair = new KeyPair({ pub: xpub });\n      const defaultKeys = keyPair.getKeys();\n      should.not.exist(defaultKeys.prv);\n      defaultKeys.pub.should.equal('03D63D9FD9FD772A989C5B90EDB37716406356E98273E5F98FE07652247A3A8275');\n\n      const extendedKeys = keyPair.getExtendedKeys();\n      should.not.exist(extendedKeys.xprv);\n      extendedKeys.xpub.should.equal(xpub);\n    });\n\n    it('from an xprv', () => {\n      const keyPair = new KeyPair({ prv: xprv });\n      const defaultKeys = keyPair.getKeys();\n      assert(defaultKeys.prv);\n      defaultKeys.prv.should.equal(prv);\n      defaultKeys.pub.should.equal(pub);\n\n      const extendedKeys = keyPair.getExtendedKeys();\n      assert(extendedKeys.xprv);\n      extendedKeys.xprv.should.equal(xprv);\n      extendedKeys.xpub.should.equal(xpub);\n    });\n\n    it('from an uncompressed public key', () => {\n      const keyPair = new KeyPair({ pub: uncompressedPub });\n      const defaultKeys = keyPair.getKeys();\n      should.not.exist(defaultKeys.prv);\n      defaultKeys.pub.should.equal(uncompressedPub);\n\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n\n    it('from a compressed public key', () => {\n      const keyPair = new KeyPair({ pub });\n      const defaultKeys = keyPair.getKeys();\n      should.not.exist(defaultKeys.prv);\n      defaultKeys.pub.should.equal(uncompressedPub);\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n\n    it('from a raw private key', () => {\n      const keyPair = new KeyPair({ prv });\n      const defaultKeys = keyPair.getKeys();\n      assert(defaultKeys.prv);\n      defaultKeys.prv.should.equal(prv);\n      defaultKeys.pub.should.equal(uncompressedPub);\n\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n\n    it('from an empty value', () => {\n      const keyPair = new KeyPair();\n      should.exists(keyPair.getKeys().prv);\n      should.exists(keyPair.getKeys().pub);\n      const keys = keyPair.getKeys();\n      assert(keys.prv);\n      should.equal(keys.prv.length, 64);\n      should.equal(keys.pub.length, 66);\n    });\n\n    it('from seed', () => {\n      const seed = nacl.randomBytes(64);\n      const keyPair = new KeyPair({ seed: Buffer.from(seed) });\n      keyPair.getKeys().should.have.property('pub');\n      keyPair.getKeys().should.have.property('prv');\n    });\n  });\n\n  describe('should fail to create a KeyPair', function () {\n    it('from an invalid public key', () => {\n      const source = {\n        pub: '01D63D',\n      };\n      assert.throws(() => new KeyPair(source));\n    });\n\n    it('from an invalid private key', () => {\n      const source = {\n        prv: '82A34E',\n      };\n      assert.throws(() => new KeyPair(source));\n      assert.throws(\n        () => new KeyPair({ prv: prv + pub }),\n        (e: any) => e.message === invalidPrivateKeyErrorMessage\n      );\n    });\n  });\n\n  describe('getAddress', function () {\n    it('should get an address from xprv', () => {\n      const keyPair = new KeyPair({ prv: xprv });\n      const calculatedAddress = keyPair.getAddress();\n      calculatedAddress.should.equal(address);\n    });\n\n    it('should get an address from xpub', () => {\n      const keyPair = new KeyPair({ pub: xpub });\n      const calculatedAddress = keyPair.getAddress();\n      calculatedAddress.should.equal(address);\n    });\n\n    it('should get an address from prv', () => {\n      const keyPair = new KeyPair({ prv });\n      const calculatedAddress = keyPair.getAddress();\n      calculatedAddress.should.equal(address);\n    });\n\n    it('should get an address from pub', () => {\n      const keyPair = new KeyPair({ pub });\n      const calculatedAddress = keyPair.getAddress();\n      calculatedAddress.should.equal(address);\n    });\n\n    it('should get an address from uncompressed pub', () => {\n      const keyPair = new KeyPair({ pub: uncompressedPub });\n      const calculatedAddress = keyPair.getAddress();\n      calculatedAddress.should.equal(address);\n    });\n  });\n\n  describe('getExtendedKeys', function () {\n    it('should get the keys in extended format from xprv', () => {\n      const keyPair = new KeyPair({ prv: xprv });\n      const { xprv: calculatedXprv, xpub: calculatedXpub } = keyPair.getExtendedKeys();\n      assert(calculatedXprv);\n      calculatedXprv.should.equal(xprv);\n      calculatedXpub.should.equal(xpub);\n    });\n\n    it('should get the keys in extended format from xpub', () => {\n      const keyPair = new KeyPair({ pub: xpub });\n      const { xprv: calculatedXprv, xpub: calculatedXpub } = keyPair.getExtendedKeys();\n      should.not.exist(calculatedXprv);\n      calculatedXpub.should.equal(xpub);\n    });\n\n    it('should not be able to get keys from prv', () => {\n      const keyPair = new KeyPair({ prv });\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n\n    it('should get the keys in extended format from pub', () => {\n      const keyPair = new KeyPair({ pub });\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n\n    it('should get the keys in extended format from uncompressed pub', () => {\n      const keyPair = new KeyPair({ pub: uncompressedPub });\n      assert.throws(() => keyPair.getExtendedKeys());\n    });\n  });\n});\n"]}

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

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

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

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

package/dist/test/unit/stakingFlowE2E.js

@@ -0,0 +1,292 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const statics_1 = require("@bitgo-beta/statics");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const lib_1 = require("../../src/lib");
+const testData = __importStar(require("../resources/vet"));
+describe('VET Staking Flow - End-to-End Test', function () {
+    const coinConfig = statics_1.coins.get('tvet');
+    const factory = new lib_1.TransactionBuilderFactory(coinConfig);
+    // Test data
+    const stakingContractAddress = testData.STAKING_CONTRACT_ADDRESS;
+    const builtInStakerContractAddress = testData.BUILT_IN_STAKER_CONTRACT_ADDRESS;
+    const amountToStake = '1000000000000000000'; // 1 VET in wei
+    const amountToStakeForValidatorRegistration = '25000000000000000000000000'; // 25M VET in wei
+    const stakingPeriod = 60480;
+    const validatorAddress = '0x9a7afcacc88c106f3bbd6b213cd0821d9224d945';
+    const levelId = testData.STAKING_LEVEL_ID;
+    const senderAddress = '0x9378c12BD7502A11F770a5C1F223c959B2805dA9';
+    const feePayerAddress = '0xdc9fef0b84a0ccf3f1bd4b84e41743e3e051a083';
+    // Mock signatures for testing (these would come from actual signing in real scenario)
+    const mockSenderSignature = Buffer.from(testData.senderSig, 'hex');
+    const mockFeePayerSignature = Buffer.from(testData.feePayerSig, 'hex');
+    describe('Complete Staking Transaction Flow', function () {
+        it('should build, sign, and serialize a complete staking transaction with fee delegation', async function () {
+            // Step 1: Build the staking transaction
+            const stakingBuilder = factory.getStakingActivateBuilder();
+            stakingBuilder
+                .stakingContractAddress(stakingContractAddress)
+                .amountToStake(amountToStake)
+                .levelId(levelId)
+                .sender(senderAddress)
+                .chainTag(0x27) // Testnet chain tag
+                .blockRef('0x014ead140e77bbc1')
+                .expiration(64)
+                .gas(100000)
+                .gasPriceCoef(128)
+                .nonce('12345');
+            stakingBuilder.addFeePayerAddress(feePayerAddress);
+            const unsignedTx = await stakingBuilder.build();
+            should_1.default.exist(unsignedTx);
+            unsignedTx.should.be.instanceof(lib_1.StakeClauseTransaction);
+            const stakingTx = unsignedTx;
+            // Verify transaction structure
+            stakingTx.type.should.equal(sdk_core_1.TransactionType.StakingActivate);
+            stakingTx.stakingContractAddress.should.equal(stakingContractAddress);
+            stakingTx.amountToStake.should.equal(amountToStake);
+            stakingTx.levelId.should.equal(levelId);
+            should_1.default.exist(stakingTx.rawTransaction);
+            should_1.default.exist(stakingTx.rawTransaction.body);
+            // This is the critical test - ensure reserved.features = 1 for ContractCall type
+            should_1.default.exist(stakingTx.rawTransaction.body.reserved);
+            stakingTx.rawTransaction.body.reserved.should.have.property('features', 1);
+            // Step 3: Add sender signature
+            stakingTx.addSenderSignature(mockSenderSignature);
+            should_1.default.exist(stakingTx.senderSignature);
+            Buffer.from(stakingTx.senderSignature).should.eql(mockSenderSignature);
+            // Step 4: Add fee payer signature
+            stakingTx.addFeePayerSignature(mockFeePayerSignature);
+            should_1.default.exist(stakingTx.feePayerSignature);
+            Buffer.from(stakingTx.feePayerSignature).should.eql(mockFeePayerSignature);
+            // Step 5: Generate transaction ID
+            // This should NOT throw "not signed transaction: id unavailable" error anymore
+            const transactionId = stakingTx.id;
+            should_1.default.exist(transactionId);
+            transactionId.should.not.equal('UNAVAILABLE');
+            // Step 6: Serialize the fully signed transaction
+            const serializedTx = stakingTx.toBroadcastFormat();
+            should_1.default.exist(serializedTx);
+            serializedTx.should.be.type('string');
+            serializedTx.should.startWith('0x');
+            // Step 7: Verify transaction can be deserialized
+            const deserializedBuilder = factory.from(serializedTx);
+            const deserializedTx = deserializedBuilder.transaction;
+            deserializedTx.should.be.instanceof(lib_1.StakeClauseTransaction);
+            deserializedTx.stakingContractAddress.should.equal(stakingContractAddress);
+            deserializedTx.amountToStake.should.equal(amountToStake);
+            deserializedTx.levelId.should.equal(levelId);
+            // Step 8: Verify toJson output
+            const jsonOutput = stakingTx.toJson();
+            should_1.default.exist(jsonOutput);
+            jsonOutput.should.have.property('id', transactionId);
+            jsonOutput.should.have.property('stakingContractAddress', stakingContractAddress);
+            // JSON output keeps decimal format for amounts
+            jsonOutput.should.have.property('amountToStake', amountToStake);
+            jsonOutput.should.have.property('levelId', levelId);
+        });
+        it('should build, sign, and serialize a complete validator registration transaction with fee delegation', async function () {
+            // Step 1: Build the staking transaction
+            const validatorRegistrationBuilder = factory.getValidatorRegistrationBuilder();
+            validatorRegistrationBuilder
+                .stakingContractAddress(builtInStakerContractAddress)
+                .stakingPeriod(60480)
+                .validator(validatorAddress)
+                .amountToStake(amountToStakeForValidatorRegistration)
+                .sender(senderAddress)
+                .chainTag(0x27) // Testnet chain tag
+                .blockRef('0x014ead140e77bbc1')
+                .expiration(64)
+                .gas(100000)
+                .gasPriceCoef(128)
+                .nonce('12345');
+            validatorRegistrationBuilder.addFeePayerAddress(feePayerAddress);
+            const unsignedTx = await validatorRegistrationBuilder.build();
+            should_1.default.exist(unsignedTx);
+            unsignedTx.should.be.instanceof(lib_1.ValidatorRegistrationTransaction);
+            const validatorRegistrationTx = unsignedTx;
+            // Verify transaction structure
+            validatorRegistrationTx.type.should.equal(sdk_core_1.TransactionType.StakingLock);
+            validatorRegistrationTx.stakingContractAddress.should.equal(builtInStakerContractAddress);
+            validatorRegistrationTx.stakingPeriod.should.equal(stakingPeriod);
+            validatorRegistrationTx.validator.should.equal(validatorAddress);
+            validatorRegistrationTx.amountToStake.should.equal(amountToStakeForValidatorRegistration);
+            should_1.default.exist(validatorRegistrationTx.rawTransaction);
+            should_1.default.exist(validatorRegistrationTx.rawTransaction.body);
+            // This is the critical test - ensure reserved.features = 1
+            should_1.default.exist(validatorRegistrationTx.rawTransaction.body.reserved);
+            validatorRegistrationTx.rawTransaction.body.reserved.should.have.property('features', 1);
+            // Step 3: Add sender signature
+            validatorRegistrationTx.addSenderSignature(mockSenderSignature);
+            should_1.default.exist(validatorRegistrationTx.senderSignature);
+            Buffer.from(validatorRegistrationTx.senderSignature).should.eql(mockSenderSignature);
+            // Step 4: Add fee payer signature
+            validatorRegistrationTx.addFeePayerSignature(mockFeePayerSignature);
+            should_1.default.exist(validatorRegistrationTx.feePayerSignature);
+            Buffer.from(validatorRegistrationTx.feePayerSignature).should.eql(mockFeePayerSignature);
+            // Step 5: Generate transaction ID
+            // This should NOT throw "not signed transaction: id unavailable" error anymore
+            const transactionId = validatorRegistrationTx.id;
+            should_1.default.exist(transactionId);
+            transactionId.should.not.equal('UNAVAILABLE');
+            // Step 6: Serialize the fully signed transaction
+            const serializedTx = validatorRegistrationTx.toBroadcastFormat();
+            should_1.default.exist(serializedTx);
+            serializedTx.should.be.type('string');
+            serializedTx.should.startWith('0x');
+            // Step 7: Verify transaction can be deserialized
+            const deserializedBuilder = factory.from(serializedTx);
+            const deserializedTx = deserializedBuilder.transaction;
+            deserializedTx.should.be.instanceof(lib_1.ValidatorRegistrationTransaction);
+            deserializedTx.stakingContractAddress.should.equal(builtInStakerContractAddress);
+            deserializedTx.stakingPeriod.should.equal(stakingPeriod);
+            deserializedTx.validator.should.equal(validatorAddress);
+            deserializedTx.amountToStake.should.equal(amountToStakeForValidatorRegistration);
+            // Step 8: Verify toJson output
+            const jsonOutput = validatorRegistrationTx.toJson();
+            should_1.default.exist(jsonOutput);
+            jsonOutput.should.have.property('id', transactionId);
+            jsonOutput.should.have.property('stakingContractAddress', builtInStakerContractAddress);
+            jsonOutput.should.have.property('stakingPeriod', stakingPeriod);
+            jsonOutput.should.have.property('validatorAddress', validatorAddress);
+            jsonOutput.should.have.property('amountToStake', amountToStakeForValidatorRegistration);
+        });
+        it('should handle signature combination in the correct order', async function () {
+            // This test specifically validates the signature combination flow that was failing
+            const stakingBuilder = factory.getStakingActivateBuilder();
+            stakingBuilder
+                .stakingContractAddress(stakingContractAddress)
+                .amountToStake(amountToStake)
+                .levelId(levelId)
+                .sender(senderAddress)
+                .chainTag(0x27)
+                .blockRef('0x014ead140e77bbc1')
+                .expiration(64)
+                .gas(100000)
+                .gasPriceCoef(128)
+                .nonce('12345');
+            stakingBuilder.addFeePayerAddress(feePayerAddress);
+            const tx = (await stakingBuilder.build());
+            // Test 1: Only sender signature - should generate half-signed transaction
+            tx.addSenderSignature(mockSenderSignature);
+            // Test 2: Add fee payer signature - should generate fully signed transaction
+            tx.addFeePayerSignature(mockFeePayerSignature);
+            // Should be able to get transaction ID with both signatures
+            const fullSignedId = tx.id;
+            should_1.default.exist(fullSignedId);
+            fullSignedId.should.not.equal('UNAVAILABLE');
+            // The ID should be consistent
+            fullSignedId.should.be.type('string');
+            fullSignedId.length.should.be.greaterThan(10);
+        });
+        it('should properly set transaction type for fee delegation validation', async function () {
+            // This test ensures our fix for TransactionType.ContractCall is working
+            const stakingBuilder = factory.getStakingActivateBuilder();
+            stakingBuilder
+                .stakingContractAddress(stakingContractAddress)
+                .amountToStake(amountToStake)
+                .levelId(levelId)
+                .sender(senderAddress)
+                .chainTag(0x27)
+                .blockRef('0x014ead140e77bbc1')
+                .expiration(64)
+                .gas(100000)
+                .gasPriceCoef(128)
+                .nonce('12345');
+            stakingBuilder.addFeePayerAddress(feePayerAddress);
+            const tx = (await stakingBuilder.build());
+            // Verify the transaction type is ContractCall
+            tx.type.should.equal(sdk_core_1.TransactionType.StakingActivate);
+            // Verify fee delegation is enabled via reserved.features = 1
+            const rawTxBody = tx.rawTransaction.body;
+            should_1.default.exist(rawTxBody.reserved);
+            rawTxBody.reserved.should.have.property('features', 1);
+            // This proves that ContractCall transactions now get fee delegation support
+        });
+        it('should work with pre-built signed transaction from test data', async function () {
+            // Test using the actual signed transaction from our test data
+            const txBuilder = factory.from(testData.STAKING_TRANSACTION);
+            const tx = txBuilder.transaction;
+            // Should be able to get ID without throwing errors
+            const txId = tx.id;
+            should_1.default.exist(txId);
+            txId.should.not.equal('UNAVAILABLE');
+            // Verify all staking properties are preserved
+            // Note: The test data uses a different contract address in the transaction
+            // The actual contract address from the parsed transaction is 0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7
+            tx.stakingContractAddress.should.equal('0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7');
+            tx.levelId.should.equal(testData.STAKING_LEVEL_ID);
+        });
+    });
+    describe('Fee Delegation Flag Tests', function () {
+        it('should set fee delegation for all staking-related transaction types', async function () {
+            const testTypes = [
+                { type: sdk_core_1.TransactionType.ContractCall, name: 'Staking' },
+                { type: sdk_core_1.TransactionType.StakingUnlock, name: 'Exit Delegation' },
+                { type: sdk_core_1.TransactionType.StakingWithdraw, name: 'Burn NFT' },
+                { type: sdk_core_1.TransactionType.StakingClaim, name: 'Claim Rewards' },
+            ];
+            for (const testCase of testTypes) {
+                const stakingBuilder = factory.getStakingActivateBuilder();
+                stakingBuilder
+                    .stakingContractAddress(stakingContractAddress)
+                    .amountToStake(amountToStake)
+                    .levelId(levelId)
+                    .sender(senderAddress)
+                    .chainTag(0x27)
+                    .blockRef('0x014ead140e77bbc1')
+                    .expiration(64)
+                    .gas(100000)
+                    .gasPriceCoef(128)
+                    .nonce('12345');
+                stakingBuilder.addFeePayerAddress(feePayerAddress);
+                // Manually set the transaction type to test different types
+                const tx = (await stakingBuilder.build());
+                tx._type = testCase.type;
+                // Rebuild the raw transaction to test fee delegation flag
+                await tx.buildRawTransaction();
+                // Verify fee delegation is set for all types
+                const rawTxBody = tx.rawTransaction.body;
+                should_1.default.exist(rawTxBody.reserved);
+                rawTxBody.reserved.should.have.property('features', 1);
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingFlowE2E.js","sourceRoot":"","sources":["../../../test/unit/stakingFlowE2E.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { coins } from '@bitgo-beta/statics';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { TransactionBuilderFactory, StakeClauseTransaction, ValidatorRegistrationTransaction } from '../../src/lib';\nimport * as testData from '../resources/vet';\n\ndescribe('VET Staking Flow - End-to-End Test', function () {\n  const coinConfig = coins.get('tvet');\n  const factory = new TransactionBuilderFactory(coinConfig);\n\n  // Test data\n  const stakingContractAddress = testData.STAKING_CONTRACT_ADDRESS;\n  const builtInStakerContractAddress = testData.BUILT_IN_STAKER_CONTRACT_ADDRESS;\n  const amountToStake = '1000000000000000000'; // 1 VET in wei\n  const amountToStakeForValidatorRegistration = '25000000000000000000000000'; // 25M VET in wei\n  const stakingPeriod = 60480;\n  const validatorAddress = '0x9a7afcacc88c106f3bbd6b213cd0821d9224d945';\n  const levelId = testData.STAKING_LEVEL_ID;\n  const senderAddress = '0x9378c12BD7502A11F770a5C1F223c959B2805dA9';\n  const feePayerAddress = '0xdc9fef0b84a0ccf3f1bd4b84e41743e3e051a083';\n\n  // Mock signatures for testing (these would come from actual signing in real scenario)\n  const mockSenderSignature = Buffer.from(testData.senderSig, 'hex');\n  const mockFeePayerSignature = Buffer.from(testData.feePayerSig, 'hex');\n\n  describe('Complete Staking Transaction Flow', function () {\n    it('should build, sign, and serialize a complete staking transaction with fee delegation', async function () {\n      // Step 1: Build the staking transaction\n      const stakingBuilder = factory.getStakingActivateBuilder();\n\n      stakingBuilder\n        .stakingContractAddress(stakingContractAddress)\n        .amountToStake(amountToStake)\n        .levelId(levelId)\n        .sender(senderAddress)\n        .chainTag(0x27) // Testnet chain tag\n        .blockRef('0x014ead140e77bbc1')\n        .expiration(64)\n        .gas(100000)\n        .gasPriceCoef(128)\n        .nonce('12345');\n\n      stakingBuilder.addFeePayerAddress(feePayerAddress);\n\n      const unsignedTx = await stakingBuilder.build();\n      should.exist(unsignedTx);\n      unsignedTx.should.be.instanceof(StakeClauseTransaction);\n\n      const stakingTx = unsignedTx as StakeClauseTransaction;\n\n      // Verify transaction structure\n      stakingTx.type.should.equal(TransactionType.StakingActivate);\n      stakingTx.stakingContractAddress.should.equal(stakingContractAddress);\n      stakingTx.amountToStake.should.equal(amountToStake);\n      stakingTx.levelId.should.equal(levelId);\n\n      should.exist(stakingTx.rawTransaction);\n      should.exist(stakingTx.rawTransaction.body);\n\n      // This is the critical test - ensure reserved.features = 1 for ContractCall type\n      should.exist(stakingTx.rawTransaction.body.reserved);\n      stakingTx.rawTransaction.body.reserved!.should.have.property('features', 1);\n\n      // Step 3: Add sender signature\n      stakingTx.addSenderSignature(mockSenderSignature);\n      should.exist(stakingTx.senderSignature);\n      Buffer.from(stakingTx.senderSignature!).should.eql(mockSenderSignature);\n\n      // Step 4: Add fee payer signature\n      stakingTx.addFeePayerSignature(mockFeePayerSignature);\n      should.exist(stakingTx.feePayerSignature);\n      Buffer.from(stakingTx.feePayerSignature!).should.eql(mockFeePayerSignature);\n\n      // Step 5: Generate transaction ID\n\n      // This should NOT throw \"not signed transaction: id unavailable\" error anymore\n      const transactionId = stakingTx.id;\n      should.exist(transactionId);\n      transactionId.should.not.equal('UNAVAILABLE');\n\n      // Step 6: Serialize the fully signed transaction\n      const serializedTx = stakingTx.toBroadcastFormat();\n      should.exist(serializedTx);\n      serializedTx.should.be.type('string');\n      serializedTx.should.startWith('0x');\n\n      // Step 7: Verify transaction can be deserialized\n      const deserializedBuilder = factory.from(serializedTx);\n      const deserializedTx = deserializedBuilder.transaction as StakeClauseTransaction;\n\n      deserializedTx.should.be.instanceof(StakeClauseTransaction);\n      deserializedTx.stakingContractAddress.should.equal(stakingContractAddress);\n      deserializedTx.amountToStake.should.equal(amountToStake);\n      deserializedTx.levelId.should.equal(levelId);\n\n      // Step 8: Verify toJson output\n      const jsonOutput = stakingTx.toJson();\n      should.exist(jsonOutput);\n      jsonOutput.should.have.property('id', transactionId);\n      jsonOutput.should.have.property('stakingContractAddress', stakingContractAddress);\n      // JSON output keeps decimal format for amounts\n      jsonOutput.should.have.property('amountToStake', amountToStake);\n      jsonOutput.should.have.property('levelId', levelId);\n    });\n\n    it('should build, sign, and serialize a complete validator registration transaction with fee delegation', async function () {\n      // Step 1: Build the staking transaction\n      const validatorRegistrationBuilder = factory.getValidatorRegistrationBuilder();\n\n      validatorRegistrationBuilder\n        .stakingContractAddress(builtInStakerContractAddress)\n        .stakingPeriod(60480)\n        .validator(validatorAddress)\n        .amountToStake(amountToStakeForValidatorRegistration)\n        .sender(senderAddress)\n        .chainTag(0x27) // Testnet chain tag\n        .blockRef('0x014ead140e77bbc1')\n        .expiration(64)\n        .gas(100000)\n        .gasPriceCoef(128)\n        .nonce('12345');\n\n      validatorRegistrationBuilder.addFeePayerAddress(feePayerAddress);\n\n      const unsignedTx = await validatorRegistrationBuilder.build();\n      should.exist(unsignedTx);\n      unsignedTx.should.be.instanceof(ValidatorRegistrationTransaction);\n\n      const validatorRegistrationTx = unsignedTx as ValidatorRegistrationTransaction;\n\n      // Verify transaction structure\n      validatorRegistrationTx.type.should.equal(TransactionType.StakingLock);\n      validatorRegistrationTx.stakingContractAddress.should.equal(builtInStakerContractAddress);\n      validatorRegistrationTx.stakingPeriod.should.equal(stakingPeriod);\n      validatorRegistrationTx.validator.should.equal(validatorAddress);\n      validatorRegistrationTx.amountToStake.should.equal(amountToStakeForValidatorRegistration);\n\n      should.exist(validatorRegistrationTx.rawTransaction);\n      should.exist(validatorRegistrationTx.rawTransaction.body);\n\n      // This is the critical test - ensure reserved.features = 1\n      should.exist(validatorRegistrationTx.rawTransaction.body.reserved);\n      validatorRegistrationTx.rawTransaction.body.reserved!.should.have.property('features', 1);\n\n      // Step 3: Add sender signature\n      validatorRegistrationTx.addSenderSignature(mockSenderSignature);\n      should.exist(validatorRegistrationTx.senderSignature);\n      Buffer.from(validatorRegistrationTx.senderSignature!).should.eql(mockSenderSignature);\n\n      // Step 4: Add fee payer signature\n      validatorRegistrationTx.addFeePayerSignature(mockFeePayerSignature);\n      should.exist(validatorRegistrationTx.feePayerSignature);\n      Buffer.from(validatorRegistrationTx.feePayerSignature!).should.eql(mockFeePayerSignature);\n\n      // Step 5: Generate transaction ID\n\n      // This should NOT throw \"not signed transaction: id unavailable\" error anymore\n      const transactionId = validatorRegistrationTx.id;\n      should.exist(transactionId);\n      transactionId.should.not.equal('UNAVAILABLE');\n\n      // Step 6: Serialize the fully signed transaction\n      const serializedTx = validatorRegistrationTx.toBroadcastFormat();\n      should.exist(serializedTx);\n      serializedTx.should.be.type('string');\n      serializedTx.should.startWith('0x');\n\n      // Step 7: Verify transaction can be deserialized\n      const deserializedBuilder = factory.from(serializedTx);\n      const deserializedTx = deserializedBuilder.transaction as ValidatorRegistrationTransaction;\n\n      deserializedTx.should.be.instanceof(ValidatorRegistrationTransaction);\n      deserializedTx.stakingContractAddress.should.equal(builtInStakerContractAddress);\n      deserializedTx.stakingPeriod.should.equal(stakingPeriod);\n      deserializedTx.validator.should.equal(validatorAddress);\n      deserializedTx.amountToStake.should.equal(amountToStakeForValidatorRegistration);\n\n      // Step 8: Verify toJson output\n      const jsonOutput = validatorRegistrationTx.toJson();\n      should.exist(jsonOutput);\n      jsonOutput.should.have.property('id', transactionId);\n      jsonOutput.should.have.property('stakingContractAddress', builtInStakerContractAddress);\n      jsonOutput.should.have.property('stakingPeriod', stakingPeriod);\n      jsonOutput.should.have.property('validatorAddress', validatorAddress);\n      jsonOutput.should.have.property('amountToStake', amountToStakeForValidatorRegistration);\n    });\n\n    it('should handle signature combination in the correct order', async function () {\n      // This test specifically validates the signature combination flow that was failing\n      const stakingBuilder = factory.getStakingActivateBuilder();\n\n      stakingBuilder\n        .stakingContractAddress(stakingContractAddress)\n        .amountToStake(amountToStake)\n        .levelId(levelId)\n        .sender(senderAddress)\n        .chainTag(0x27)\n        .blockRef('0x014ead140e77bbc1')\n        .expiration(64)\n        .gas(100000)\n        .gasPriceCoef(128)\n        .nonce('12345');\n\n      stakingBuilder.addFeePayerAddress(feePayerAddress);\n\n      const tx = (await stakingBuilder.build()) as StakeClauseTransaction;\n\n      // Test 1: Only sender signature - should generate half-signed transaction\n      tx.addSenderSignature(mockSenderSignature);\n\n      // Test 2: Add fee payer signature - should generate fully signed transaction\n      tx.addFeePayerSignature(mockFeePayerSignature);\n\n      // Should be able to get transaction ID with both signatures\n      const fullSignedId = tx.id;\n      should.exist(fullSignedId);\n      fullSignedId.should.not.equal('UNAVAILABLE');\n\n      // The ID should be consistent\n      fullSignedId.should.be.type('string');\n      fullSignedId.length.should.be.greaterThan(10);\n    });\n\n    it('should properly set transaction type for fee delegation validation', async function () {\n      // This test ensures our fix for TransactionType.ContractCall is working\n      const stakingBuilder = factory.getStakingActivateBuilder();\n\n      stakingBuilder\n        .stakingContractAddress(stakingContractAddress)\n        .amountToStake(amountToStake)\n        .levelId(levelId)\n        .sender(senderAddress)\n        .chainTag(0x27)\n        .blockRef('0x014ead140e77bbc1')\n        .expiration(64)\n        .gas(100000)\n        .gasPriceCoef(128)\n        .nonce('12345');\n\n      stakingBuilder.addFeePayerAddress(feePayerAddress);\n\n      const tx = (await stakingBuilder.build()) as StakeClauseTransaction;\n\n      // Verify the transaction type is ContractCall\n      tx.type.should.equal(TransactionType.StakingActivate);\n\n      // Verify fee delegation is enabled via reserved.features = 1\n      const rawTxBody = tx.rawTransaction.body;\n      should.exist(rawTxBody.reserved);\n      rawTxBody.reserved!.should.have.property('features', 1);\n\n      // This proves that ContractCall transactions now get fee delegation support\n    });\n\n    it('should work with pre-built signed transaction from test data', async function () {\n      // Test using the actual signed transaction from our test data\n      const txBuilder = factory.from(testData.STAKING_TRANSACTION);\n      const tx = txBuilder.transaction as StakeClauseTransaction;\n\n      // Should be able to get ID without throwing errors\n      const txId = tx.id;\n      should.exist(txId);\n      txId.should.not.equal('UNAVAILABLE');\n\n      // Verify all staking properties are preserved\n      // Note: The test data uses a different contract address in the transaction\n      // The actual contract address from the parsed transaction is 0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7\n      tx.stakingContractAddress.should.equal('0x1856c533ac2d94340aaa8544d35a5c1d4a21dee7');\n      tx.levelId.should.equal(testData.STAKING_LEVEL_ID);\n    });\n  });\n\n  describe('Fee Delegation Flag Tests', function () {\n    it('should set fee delegation for all staking-related transaction types', async function () {\n      const testTypes = [\n        { type: TransactionType.ContractCall, name: 'Staking' },\n        { type: TransactionType.StakingUnlock, name: 'Exit Delegation' },\n        { type: TransactionType.StakingWithdraw, name: 'Burn NFT' },\n        { type: TransactionType.StakingClaim, name: 'Claim Rewards' },\n      ];\n\n      for (const testCase of testTypes) {\n        const stakingBuilder = factory.getStakingActivateBuilder();\n        stakingBuilder\n          .stakingContractAddress(stakingContractAddress)\n          .amountToStake(amountToStake)\n          .levelId(levelId)\n          .sender(senderAddress)\n          .chainTag(0x27)\n          .blockRef('0x014ead140e77bbc1')\n          .expiration(64)\n          .gas(100000)\n          .gasPriceCoef(128)\n          .nonce('12345');\n\n        stakingBuilder.addFeePayerAddress(feePayerAddress);\n\n        // Manually set the transaction type to test different types\n        const tx = (await stakingBuilder.build()) as StakeClauseTransaction;\n        (tx as any)._type = testCase.type;\n\n        // Rebuild the raw transaction to test fee delegation flag\n        await (tx as any).buildRawTransaction();\n\n        // Verify fee delegation is set for all types\n        const rawTxBody = tx.rawTransaction.body;\n        should.exist(rawTxBody.reserved);\n        rawTxBody.reserved!.should.have.property('features', 1);\n      }\n    });\n  });\n});\n"]}

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

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

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

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