@bitgo/sdk-coin-polyx 1.10.2 → 1.10.4

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

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const statics_1 = require("@bitgo/statics");
+const should_1 = __importDefault(require("should"));
+const sinon_1 = __importDefault(require("sinon"));
+const lib_1 = require("../../../src/lib");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const utils_1 = __importDefault(require("../../../src/lib/utils"));
+const resources_1 = require("../../resources");
+function createMockTransaction(txData) {
+    return {
+        id: '123',
+        type: sdk_core_1.TransactionType.StakingWithdraw,
+        toBroadcastFormat: () => txData,
+        inputs: [],
+        outputs: [],
+        signature: ['mock-signature'],
+        toJson: () => ({
+            id: '123',
+            type: 'StakingWithdraw',
+            sender: resources_1.accounts.account1.address,
+            referenceBlock: '0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d',
+            blockNumber: 100,
+            genesisHash: '0x',
+            nonce: 1,
+            tip: 0,
+            specVersion: 1,
+            transactionVersion: 1,
+            chainName: 'Polymesh',
+            inputs: [],
+            outputs: [],
+        }),
+    };
+}
+describe('Polyx WithdrawUnbonded Builder', function () {
+    let builder;
+    const factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get('tpolyx'));
+    const senderAddress = resources_1.accounts.account1.address;
+    const testSlashingSpans = 0;
+    beforeEach(() => {
+        builder = factory.getWithdrawUnbondedBuilder();
+    });
+    describe('setter validation', () => {
+        it('should validate slashing spans', () => {
+            const spy = sinon_1.default.spy(builder, 'validateValue');
+            should_1.default.throws(() => builder.slashingSpans(-1), /Value cannot be less than zero/);
+            should_1.default.doesNotThrow(() => builder.slashingSpans(0));
+            sinon_1.default.assert.calledTwice(spy);
+        });
+    });
+    describe('Build and Sign', function () {
+        it('should build a withdraw unbonded transaction', async () => {
+            builder
+                .slashingSpans(testSlashingSpans)
+                .sender({ address: senderAddress })
+                .validity({ firstValid: 3933, maxDuration: 64 })
+                .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });
+            const mockTx = createMockTransaction(resources_1.rawTx.withdrawUnbonded.unsigned);
+            sinon_1.default.stub(builder, 'build').resolves(mockTx);
+            const tx = await builder.build();
+            should_1.default.exist(tx);
+            should_1.default.equal(builder.getSlashingSpans(), testSlashingSpans);
+        });
+    });
+    describe('Transaction Validation', function () {
+        it('should build, decode, and validate a real withdrawUnbonded transaction', () => {
+            // Build the transaction with real parameters
+            builder
+                .slashingSpans(testSlashingSpans)
+                .sender({ address: senderAddress })
+                .validity({ firstValid: 3933, maxDuration: 64 })
+                .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });
+            // Set up material for decoding
+            const material = utils_1.default.getMaterial(statics_1.coins.get('tpolyx').network.type);
+            builder.material(material);
+            // Build the actual unsigned transaction
+            const unsignedTx = builder['buildTransaction']();
+            const registry = builder['_registry'];
+            // Decode the actual built transaction
+            const decodedTx = (0, txwrapper_polkadot_1.decode)(unsignedTx, {
+                metadataRpc: material.metadata,
+                registry: registry,
+            });
+            // Validate the decoded transaction structure
+            should_1.default.equal(decodedTx.method.name, 'withdrawUnbonded');
+            should_1.default.equal(decodedTx.method.pallet, 'staking');
+            const withdrawArgs = decodedTx.method.args;
+            should_1.default.equal(withdrawArgs.numSlashingSpans, testSlashingSpans);
+            // Now validate using the builder's validation method
+            should_1.default.doesNotThrow(() => {
+                builder.validateDecodedTransaction(decodedTx);
+            });
+        });
+        it('should reject invalid transaction types', () => {
+            const mockDecodedTx = {
+                method: {
+                    name: 'transfer',
+                    pallet: 'balances',
+                    args: {},
+                },
+            };
+            should_1.default.throws(() => {
+                builder.validateDecodedTransaction(mockDecodedTx);
+            }, /Invalid transaction type/);
+        });
+    });
+    describe('From Raw Transaction', function () {
+        it('should rebuild from real withdrawUnbonded transaction', async () => {
+            // First build a transaction to get a real raw transaction
+            const originalBuilder = factory.getWithdrawUnbondedBuilder();
+            originalBuilder
+                .slashingSpans(testSlashingSpans)
+                .sender({ address: senderAddress })
+                .validity({ firstValid: 3933, maxDuration: 64 })
+                .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });
+            // Set up material
+            const material = utils_1.default.getMaterial(statics_1.coins.get('tpolyx').network.type);
+            originalBuilder.material(material);
+            // Build the transaction and get the serialized hex
+            const tx = await originalBuilder.build();
+            const rawTxHex = tx.toBroadcastFormat();
+            // Create a new builder and reconstruct from the transaction hex
+            const newBuilder = factory.getWithdrawUnbondedBuilder();
+            newBuilder.material(material);
+            newBuilder.from(rawTxHex);
+            // Verify the reconstructed builder has the same parameters
+            should_1.default.equal(newBuilder.getSlashingSpans(), testSlashingSpans);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"withdrawUnbondedBuilder.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/withdrawUnbondedBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { DecodedSigningPayload } from '@substrate/txwrapper-core';\nimport { decode } from '@substrate/txwrapper-polkadot';\nimport { coins } from '@bitgo/statics';\nimport should from 'should';\nimport sinon from 'sinon';\nimport { TransactionBuilderFactory, WithdrawUnbondedBuilder, Transaction } from '../../../src/lib';\nimport { TransactionType } from '@bitgo/sdk-core';\nimport utils from '../../../src/lib/utils';\n\nimport { accounts, rawTx } from '../../resources';\n\nfunction createMockTransaction(txData: string): Partial<Transaction> {\n  return {\n    id: '123',\n    type: TransactionType.StakingWithdraw,\n    toBroadcastFormat: () => txData,\n    inputs: [],\n    outputs: [],\n    signature: ['mock-signature'],\n    toJson: () => ({\n      id: '123',\n      type: 'StakingWithdraw',\n      sender: accounts.account1.address,\n      referenceBlock: '0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d',\n      blockNumber: 100,\n      genesisHash: '0x',\n      nonce: 1,\n      tip: 0,\n      specVersion: 1,\n      transactionVersion: 1,\n      chainName: 'Polymesh',\n      inputs: [],\n      outputs: [],\n    }),\n  };\n}\n\ndescribe('Polyx WithdrawUnbonded Builder', function () {\n  let builder: WithdrawUnbondedBuilder;\n  const factory = new TransactionBuilderFactory(coins.get('tpolyx'));\n\n  const senderAddress = accounts.account1.address;\n  const testSlashingSpans = 0;\n\n  beforeEach(() => {\n    builder = factory.getWithdrawUnbondedBuilder();\n  });\n\n  describe('setter validation', () => {\n    it('should validate slashing spans', () => {\n      const spy = sinon.spy(builder, 'validateValue');\n      should.throws(() => builder.slashingSpans(-1), /Value cannot be less than zero/);\n      should.doesNotThrow(() => builder.slashingSpans(0));\n      sinon.assert.calledTwice(spy);\n    });\n  });\n\n  describe('Build and Sign', function () {\n    it('should build a withdraw unbonded transaction', async () => {\n      builder\n        .slashingSpans(testSlashingSpans)\n        .sender({ address: senderAddress })\n        .validity({ firstValid: 3933, maxDuration: 64 })\n        .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });\n\n      const mockTx = createMockTransaction(rawTx.withdrawUnbonded.unsigned);\n      sinon.stub(builder, 'build').resolves(mockTx as Transaction);\n\n      const tx = await builder.build();\n      should.exist(tx);\n\n      should.equal(builder.getSlashingSpans(), testSlashingSpans);\n    });\n  });\n\n  describe('Transaction Validation', function () {\n    it('should build, decode, and validate a real withdrawUnbonded transaction', () => {\n      // Build the transaction with real parameters\n      builder\n        .slashingSpans(testSlashingSpans)\n        .sender({ address: senderAddress })\n        .validity({ firstValid: 3933, maxDuration: 64 })\n        .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });\n\n      // Set up material for decoding\n      const material = utils.getMaterial(coins.get('tpolyx').network.type);\n      builder.material(material);\n\n      // Build the actual unsigned transaction\n      const unsignedTx = builder['buildTransaction']();\n      const registry = builder['_registry'];\n\n      // Decode the actual built transaction\n      const decodedTx = decode(unsignedTx, {\n        metadataRpc: material.metadata,\n        registry: registry,\n      });\n\n      // Validate the decoded transaction structure\n      should.equal(decodedTx.method.name, 'withdrawUnbonded');\n      should.equal(decodedTx.method.pallet, 'staking');\n\n      const withdrawArgs = decodedTx.method.args as { numSlashingSpans: number };\n      should.equal(withdrawArgs.numSlashingSpans, testSlashingSpans);\n\n      // Now validate using the builder's validation method\n      should.doesNotThrow(() => {\n        builder.validateDecodedTransaction(decodedTx);\n      });\n    });\n\n    it('should reject invalid transaction types', () => {\n      const mockDecodedTx: DecodedSigningPayload = {\n        method: {\n          name: 'transfer',\n          pallet: 'balances',\n          args: {},\n        },\n      } as unknown as DecodedSigningPayload;\n\n      should.throws(() => {\n        builder.validateDecodedTransaction(mockDecodedTx);\n      }, /Invalid transaction type/);\n    });\n  });\n\n  describe('From Raw Transaction', function () {\n    it('should rebuild from real withdrawUnbonded transaction', async () => {\n      // First build a transaction to get a real raw transaction\n      const originalBuilder = factory.getWithdrawUnbondedBuilder();\n      originalBuilder\n        .slashingSpans(testSlashingSpans)\n        .sender({ address: senderAddress })\n        .validity({ firstValid: 3933, maxDuration: 64 })\n        .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 100 });\n\n      // Set up material\n      const material = utils.getMaterial(coins.get('tpolyx').network.type);\n      originalBuilder.material(material);\n\n      // Build the transaction and get the serialized hex\n      const tx = await originalBuilder.build();\n      const rawTxHex = tx.toBroadcastFormat();\n\n      // Create a new builder and reconstruct from the transaction hex\n      const newBuilder = factory.getWithdrawUnbondedBuilder();\n      newBuilder.material(material);\n      newBuilder.from(rawTxHex);\n\n      // Verify the reconstructed builder has the same parameters\n      should.equal(newBuilder.getSlashingSpans(), testSlashingSpans);\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,143 @@
+"use strict";
+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 src_1 = require("../../src");
+const resources_1 = require("../resources");
+const resources_2 = require("../../src/resources");
+describe('Polyx Utils', () => {
+    // Create a proper Material object from testnetMaterial
+    const material = {
+        genesisHash: resources_2.testnetMaterial.genesisHash,
+        chainName: resources_2.testnetMaterial.chainName,
+        specName: resources_2.testnetMaterial.specName,
+        specVersion: resources_2.testnetMaterial.specVersion,
+        txVersion: resources_2.testnetMaterial.txVersion,
+        metadata: resources_2.testnetMaterial.metadata,
+    };
+    describe('decodeTransaction', () => {
+        it('should decode a signed transfer transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.transfer.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a balances transfer
+            decoded.method.pallet.should.equal('balances');
+            decoded.method.name.should.equal('transferWithMemo');
+        });
+        it('should decode an unsigned transfer transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.transfer.unsigned, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a balances transfer
+            decoded.method.pallet.should.equal('balances');
+            decoded.method.name.should.equal('transferWithMemo');
+        });
+        it('should decode a CDD registration transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.cddTransaction.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a CDD transaction
+            decoded.method.pallet.should.equal('identity');
+            decoded.method.name.should.equal('cddRegisterDidWithCdd');
+        });
+        it('should decode a staking bond transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.stakingTx.bond.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a staking bond
+            decoded.method.pallet.should.equal('staking');
+            decoded.method.name.should.equal('bond');
+        });
+        it('should decode a staking unbond transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.stakingTx.unbond.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a staking unbond
+            decoded.method.pallet.should.equal('staking');
+            decoded.method.name.should.equal('unbond');
+        });
+        it('should decode a batch transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.stakingTx.batch.bondAndNominate.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a batch transaction
+            decoded.method.pallet.should.equal('utility');
+            decoded.method.name.should.equal('batchAll');
+            // Check the batch calls (handle potential null/undefined)
+            decoded.method.should.have.property('args');
+            decoded.method.args.should.have.property('calls');
+            if (Array.isArray(decoded.method.args.calls)) {
+                decoded.method.args.calls.should.be.an.Array();
+                decoded.method.args.calls.length.should.equal(2);
+                // First call should be bond
+                if (decoded.method.args.calls[0]) {
+                    decoded.method.args.calls[0].should.have.property('callIndex');
+                }
+                // Second call should be nominate
+                if (decoded.method.args.calls[1]) {
+                    decoded.method.args.calls[1].should.have.property('callIndex');
+                }
+            }
+        });
+        it('should decode a preApprove asset transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.preApproveAsset.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's an asset preApprove
+            decoded.method.pallet.should.equal('asset');
+            decoded.method.name.should.equal('preApproveAsset');
+        });
+        it('should decode a token transfer transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.tokenTransfer.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a settlement transaction
+            decoded.method.pallet.should.equal('settlement');
+            decoded.method.name.should.equal('addAndAffirmWithMediators');
+        });
+        it('should decode unstake transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.unstake.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a batch unstaking transaction
+            decoded.method.pallet.should.equal('utility');
+            decoded.method.name.should.equal('batchAll');
+        });
+        it('should decode withdraw unbonded transaction and identify method name', () => {
+            const decoded = src_1.utils.decodeTransaction(resources_1.rawTx.withdrawUnbonded.signed, material);
+            should_1.default.exist(decoded);
+            decoded.should.have.property('method');
+            decoded.method.should.have.property('pallet');
+            decoded.method.should.have.property('name');
+            // Check that it's a staking withdraw unbonded
+            decoded.method.pallet.should.equal('staking');
+            decoded.method.name.should.equal('withdrawUnbonded');
+        });
+        it('should throw error for invalid transaction hex', () => {
+            should_1.default.throws(() => {
+                src_1.utils.decodeTransaction('0xinvalid', material);
+            }, /Failed to decode transaction/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../test/unit/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { utils } from '../../src';\nimport { rawTx, stakingTx } from '../resources';\nimport { testnetMaterial } from '../../src/resources';\nimport { Interface } from '@bitgo/abstract-substrate';\n\ntype Material = Interface.Material;\n\ndescribe('Polyx Utils', () => {\n  // Create a proper Material object from testnetMaterial\n  const material: Material = {\n    genesisHash: testnetMaterial.genesisHash,\n    chainName: testnetMaterial.chainName,\n    specName: testnetMaterial.specName,\n    specVersion: testnetMaterial.specVersion,\n    txVersion: testnetMaterial.txVersion,\n    metadata: testnetMaterial.metadata as `0x${string}`,\n  };\n\n  describe('decodeTransaction', () => {\n    it('should decode a signed transfer transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.transfer.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a balances transfer\n      decoded.method.pallet.should.equal('balances');\n      decoded.method.name.should.equal('transferWithMemo');\n    });\n\n    it('should decode an unsigned transfer transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.transfer.unsigned, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a balances transfer\n      decoded.method.pallet.should.equal('balances');\n      decoded.method.name.should.equal('transferWithMemo');\n    });\n\n    it('should decode a CDD registration transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.cddTransaction.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a CDD transaction\n      decoded.method.pallet.should.equal('identity');\n      decoded.method.name.should.equal('cddRegisterDidWithCdd');\n    });\n\n    it('should decode a staking bond transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(stakingTx.bond.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a staking bond\n      decoded.method.pallet.should.equal('staking');\n      decoded.method.name.should.equal('bond');\n    });\n\n    it('should decode a staking unbond transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(stakingTx.unbond.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a staking unbond\n      decoded.method.pallet.should.equal('staking');\n      decoded.method.name.should.equal('unbond');\n    });\n\n    it('should decode a batch transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(stakingTx.batch.bondAndNominate.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a batch transaction\n      decoded.method.pallet.should.equal('utility');\n      decoded.method.name.should.equal('batchAll');\n\n      // Check the batch calls (handle potential null/undefined)\n      decoded.method.should.have.property('args');\n      decoded.method.args.should.have.property('calls');\n      if (Array.isArray(decoded.method.args.calls)) {\n        decoded.method.args.calls.should.be.an.Array();\n        decoded.method.args.calls.length.should.equal(2);\n\n        // First call should be bond\n        if (decoded.method.args.calls[0]) {\n          decoded.method.args.calls[0].should.have.property('callIndex');\n        }\n        // Second call should be nominate\n        if (decoded.method.args.calls[1]) {\n          decoded.method.args.calls[1].should.have.property('callIndex');\n        }\n      }\n    });\n\n    it('should decode a preApprove asset transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.preApproveAsset.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's an asset preApprove\n      decoded.method.pallet.should.equal('asset');\n      decoded.method.name.should.equal('preApproveAsset');\n    });\n\n    it('should decode a token transfer transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.tokenTransfer.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a settlement transaction\n      decoded.method.pallet.should.equal('settlement');\n      decoded.method.name.should.equal('addAndAffirmWithMediators');\n    });\n\n    it('should decode unstake transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.unstake.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a batch unstaking transaction\n      decoded.method.pallet.should.equal('utility');\n      decoded.method.name.should.equal('batchAll');\n    });\n\n    it('should decode withdraw unbonded transaction and identify method name', () => {\n      const decoded = utils.decodeTransaction(rawTx.withdrawUnbonded.signed, material);\n\n      should.exist(decoded);\n      decoded.should.have.property('method');\n      decoded.method.should.have.property('pallet');\n      decoded.method.should.have.property('name');\n\n      // Check that it's a staking withdraw unbonded\n      decoded.method.pallet.should.equal('staking');\n      decoded.method.name.should.equal('withdrawUnbonded');\n    });\n\n    it('should throw error for invalid transaction hex', () => {\n      should.throws(() => {\n        utils.decodeTransaction('0xinvalid', material);\n      }, /Failed to decode transaction/);\n    });\n  });\n});\n"]}