@bitgo-beta/sdk-coin-vet 1.0.1-beta.58 → 1.0.1-beta.580

package/dist/test/unit/stakingFlowE2E.js

@@ -0,0 +1,222 @@
+"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 amountToStake = '1000000000000000000'; // 1 VET in wei
+    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 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 } 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 amountToStake = '1000000000000000000'; // 1 VET in wei\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 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":""}

package/dist/test/unit/utils.js

@@ -0,0 +1,106 @@
+"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 testData = __importStar(require("../resources/vet"));
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+describe('Vechain util library', function () {
+    describe('isValidAddress', function () {
+        it('should succeed to validate raw transactoin', function () {
+            for (const address of testData.addresses.validAddresses) {
+                should_1.default.equal(utils_1.default.isValidAddress(address), true);
+            }
+        });
+        it('should fail to validate invalid addresses', function () {
+            for (const address of testData.addresses.invalidAddresses) {
+                should_1.default.doesNotThrow(() => utils_1.default.isValidAddress(address));
+                should_1.default.equal(utils_1.default.isValidAddress(address), false);
+            }
+            // @ts-expect-error Testing for missing param, should not throw an error
+            should_1.default.doesNotThrow(() => utils_1.default.isValidAddress(undefined));
+            // @ts-expect-error Testing for missing param, should return false
+            should_1.default.equal(utils_1.default.isValidAddress(undefined), false);
+        });
+    });
+    describe('isValidBlockId', function () {
+        it('should succeed to validate valid block IDs', function () {
+            for (const blockId of testData.blockIds.validBlockIds) {
+                should_1.default.equal(utils_1.default.isValidBlockId(blockId), true);
+            }
+        });
+        it('should fail to validate invalid block IDs', function () {
+            for (const blockId of testData.blockIds.invalidBlockIds) {
+                should_1.default.doesNotThrow(() => utils_1.default.isValidBlockId(blockId));
+                should_1.default.equal(utils_1.default.isValidBlockId(blockId), false);
+            }
+            // @ts-expect-error Testing for missing param, should not throw an error
+            should_1.default.doesNotThrow(() => utils_1.default.isValidBlockId(undefined));
+            // @ts-expect-error Testing for missing param, should return false
+            should_1.default.equal(utils_1.default.isValidBlockId(undefined), false);
+        });
+    });
+    describe('isValidDeserialize', function () {
+        it('should succeed to correctly deserialize sponsored signed serialized transaction', function () {
+            const signedTxn = utils_1.default.deserializeTransaction(testData.SPONSORED_TRANSACTION);
+            should_1.default.equal(signedTxn.origin.toString().toLowerCase(), '0x7ca00e3bc8a836026c2917c6c7c6d049e52099dd');
+            should_1.default.equal(signedTxn.gasPayer.toString().toLowerCase(), '0xdc9fef0b84a0ccf3f1bd4b84e41743e3e051a083');
+        });
+        it('should succeed to correctly deserialize unsigned serialized transaction', function () {
+            const signedTxn = utils_1.default.deserializeTransaction(testData.UNSIGNED_TRANSACTION);
+            should_1.default.equal(signedTxn.isSigned, false);
+            should_1.default.equal(signedTxn.body.gas, 21000);
+            should_1.default.equal(signedTxn.body.nonce, 400496);
+            should_1.default.equal(signedTxn.body.expiration, 64);
+            should_1.default.equal(signedTxn.body.blockRef, '0x01536ce9e9fb0638');
+        });
+        it('should fail to deserialize an invalid serialized transaction', function () {
+            should_1.default.throws(() => utils_1.default.deserializeTransaction(testData.INVALID_TRANSACTION));
+        });
+    });
+    it('should get correct transaction type from clause', function () {
+        should_1.default.equal(sdk_core_1.TransactionType.Send, utils_1.default.getTransactionTypeFromClause(testData.TRANSFER_CLAUSE));
+    });
+    it('is valid public key', function () {
+        // with 0x prefix
+        should_1.default.equal(false, utils_1.default.isValidPublicKey('0x9b4e96086d111500259f9b38680b0509a405c1904da18976455a20c691d3bb07'));
+        // without 0x prefix
+        should_1.default.equal(true, utils_1.default.isValidPublicKey('029831d82c36a58a69b31177b73d852e260a37769561450dab6ed234d5d965ef0b'));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../test/unit/utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAA4B;AAE5B,2DAA6C;AAC7C,gEAAwC;AACxC,mDAAuD;AAEvD,QAAQ,CAAC,sBAAsB,EAAE;IAC/B,QAAQ,CAAC,gBAAgB,EAAE;QACzB,EAAE,CAAC,4CAA4C,EAAE;YAC/C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;gBACxD,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;YACpD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2CAA2C,EAAE;YAC9C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;gBAC1D,gBAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;gBACzD,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;YACrD,CAAC;YACD,wEAAwE;YACxE,gBAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,eAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;YAC3D,kEAAkE;YAClE,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,gBAAgB,EAAE;QACzB,EAAE,CAAC,4CAA4C,EAAE;YAC/C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;gBACtD,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,CAAC;YACpD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,2CAA2C,EAAE;YAC9C,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;gBACxD,gBAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;gBACzD,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;YACrD,CAAC;YACD,wEAAwE;YACxE,gBAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC,eAAK,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;YAC3D,kEAAkE;YAClE,gBAAM,CAAC,KAAK,CAAC,eAAK,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,oBAAoB,EAAE;QAC7B,EAAE,CAAC,iFAAiF,EAAE;YACpF,MAAM,SAAS,GAAmB,eAAK,CAAC,sBAAsB,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;YAC/F,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,EAAE,4CAA4C,CAAC,CAAC;YACtG,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,EAAE,4CAA4C,CAAC,CAAC;QAC1G,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,yEAAyE,EAAE;YAC5E,MAAM,SAAS,GAAmB,eAAK,CAAC,sBAAsB,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC;YAC9F,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACxC,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACxC,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC3C,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;YAC5C,gBAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC,CAAC;QAC9D,CAAC,CAAC,CAAC;QACH,EAAE,CAAC,8DAA8D,EAAE;YACjE,gBAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,eAAK,CAAC,sBAAsB,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAClF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iDAAiD,EAAE;QACpD,gBAAM,CAAC,KAAK,CAAC,0BAAe,CAAC,IAAI,EAAE,eAAK,CAAC,4BAA4B,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC;IACnG,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qBAAqB,EAAE;QACxB,iBAAiB;QACjB,gBAAM,CAAC,KAAK,CAAC,KAAK,EAAE,eAAK,CAAC,gBAAgB,CAAC,oEAAoE,CAAC,CAAC,CAAC;QAClH,oBAAoB;QACpB,gBAAM,CAAC,KAAK,CAAC,IAAI,EAAE,eAAK,CAAC,gBAAgB,CAAC,oEAAoE,CAAC,CAAC,CAAC;IACnH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import should from 'should';\nimport { Transaction as VetTransaction } from '@vechain/sdk-core';\nimport * as testData from '../resources/vet';\nimport utils from '../../src/lib/utils';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\n\ndescribe('Vechain util library', function () {\n  describe('isValidAddress', function () {\n    it('should succeed to validate raw transactoin', function () {\n      for (const address of testData.addresses.validAddresses) {\n        should.equal(utils.isValidAddress(address), true);\n      }\n    });\n\n    it('should fail to validate invalid addresses', function () {\n      for (const address of testData.addresses.invalidAddresses) {\n        should.doesNotThrow(() => utils.isValidAddress(address));\n        should.equal(utils.isValidAddress(address), false);\n      }\n      // @ts-expect-error Testing for missing param, should not throw an error\n      should.doesNotThrow(() => utils.isValidAddress(undefined));\n      // @ts-expect-error Testing for missing param, should return false\n      should.equal(utils.isValidAddress(undefined), false);\n    });\n  });\n\n  describe('isValidBlockId', function () {\n    it('should succeed to validate valid block IDs', function () {\n      for (const blockId of testData.blockIds.validBlockIds) {\n        should.equal(utils.isValidBlockId(blockId), true);\n      }\n    });\n\n    it('should fail to validate invalid block IDs', function () {\n      for (const blockId of testData.blockIds.invalidBlockIds) {\n        should.doesNotThrow(() => utils.isValidBlockId(blockId));\n        should.equal(utils.isValidBlockId(blockId), false);\n      }\n      // @ts-expect-error Testing for missing param, should not throw an error\n      should.doesNotThrow(() => utils.isValidBlockId(undefined));\n      // @ts-expect-error Testing for missing param, should return false\n      should.equal(utils.isValidBlockId(undefined), false);\n    });\n  });\n\n  describe('isValidDeserialize', function () {\n    it('should succeed to correctly deserialize sponsored signed serialized transaction', function () {\n      const signedTxn: VetTransaction = utils.deserializeTransaction(testData.SPONSORED_TRANSACTION);\n      should.equal(signedTxn.origin.toString().toLowerCase(), '0x7ca00e3bc8a836026c2917c6c7c6d049e52099dd');\n      should.equal(signedTxn.gasPayer.toString().toLowerCase(), '0xdc9fef0b84a0ccf3f1bd4b84e41743e3e051a083');\n    });\n    it('should succeed to correctly deserialize unsigned serialized transaction', function () {\n      const signedTxn: VetTransaction = utils.deserializeTransaction(testData.UNSIGNED_TRANSACTION);\n      should.equal(signedTxn.isSigned, false);\n      should.equal(signedTxn.body.gas, 21000);\n      should.equal(signedTxn.body.nonce, 400496);\n      should.equal(signedTxn.body.expiration, 64);\n      should.equal(signedTxn.body.blockRef, '0x01536ce9e9fb0638');\n    });\n    it('should fail to deserialize an invalid serialized transaction', function () {\n      should.throws(() => utils.deserializeTransaction(testData.INVALID_TRANSACTION));\n    });\n  });\n\n  it('should get correct transaction type from clause', function () {\n    should.equal(TransactionType.Send, utils.getTransactionTypeFromClause(testData.TRANSFER_CLAUSE));\n  });\n\n  it('is valid public key', function () {\n    // with 0x prefix\n    should.equal(false, utils.isValidPublicKey('0x9b4e96086d111500259f9b38680b0509a405c1904da18976455a20c691d3bb07'));\n    // without 0x prefix\n    should.equal(true, utils.isValidPublicKey('029831d82c36a58a69b31177b73d852e260a37769561450dab6ed234d5d965ef0b'));\n  });\n});\n"]}

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

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

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

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