@bitgo/sdk-coin-hbar 2.8.3 → 2.9.0

package/dist/test/unit/transactionBuilder/coinTransferBuilder.d.ts

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

package/dist/test/unit/transactionBuilder/coinTransferBuilder.d.ts.map

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

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

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const should = __importStar(require("should"));
+const getBuilderFactory_1 = require("../getBuilderFactory");
+const testData = __importStar(require("../../resources/hbar"));
+/**
+ * Tests for CoinTransferBuilder self-transfer (stakeClaimRewards).
+ *
+ * HBAR staking rewards are claimed by submitting a 1-tinybar CryptoTransfer
+ * where sender == receiver == accountId. Hedera atomically flushes
+ * pending_reward into account balance on any CryptoTransfer touching the
+ * account. staking-service uses this as the CLAIM_REWARDS operation.
+ *
+ * The key behaviour under test:
+ *   buildTransferData() must produce TWO separate accountAmounts entries:
+ *     [{accountId, -1}, {accountId, +1}]
+ *   The Hedera SDK TransferTransaction merges same-account entries (nets to 0),
+ *   so CoinTransferBuilder.buildTransferData() bypasses that by building the
+ *   proto list directly.
+ *
+ *   initTransfers() must reconstruct the self-transfer from serialised bytes:
+ *   it filters for positive amounts only, so recipients[0].address == source.
+ */
+describe('HBAR CoinTransferBuilder - self-transfer (stakeClaimRewards)', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('thbar');
+    const SOURCE = testData.ACCOUNT_1.accountId; // '0.0.81320'
+    const initSelfTransferBuilder = () => {
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.fee({ fee: testData.FEE });
+        txBuilder.source({ address: SOURCE });
+        txBuilder.send({ address: SOURCE, amount: '1' }); // self-transfer: 1 tinybar
+        txBuilder.node({ nodeId: '0.0.3' });
+        txBuilder.startTime('1596110493.372646570');
+        return txBuilder;
+    };
+    describe('build', () => {
+        it('should build a self-transfer transaction with source equal to recipient', async () => {
+            const tx = await initSelfTransferBuilder().build();
+            const txJson = tx.toJson();
+            // Source and recipient are the same account
+            should.deepEqual(txJson.from, SOURCE);
+            should.deepEqual(txJson.to, SOURCE);
+            should.deepEqual(txJson.amount, '1');
+            // inputs and outputs both reference the same address
+            tx.inputs.length.should.equal(1);
+            tx.inputs[0].address.should.equal(SOURCE);
+            tx.inputs[0].value.should.equal('1');
+            tx.outputs.length.should.equal(1);
+            tx.outputs[0].address.should.equal(SOURCE);
+            tx.outputs[0].value.should.equal('1');
+        });
+        it('should produce two separate accountAmounts entries in the protobuf', async () => {
+            const tx = await initSelfTransferBuilder().build();
+            // Access the raw protobuf transfer list
+            const transfers = tx.txBody.cryptoTransfer.transfers.accountAmounts;
+            should.exist(transfers);
+            transfers.length.should.equal(2, 'expected exactly two entries: [{source,-1},{source,+1}]');
+            // Both entries reference the same account
+            const accountNums = transfers.map((a) => {
+                const id = a.accountID;
+                return `${id.shardNum || 0}.${id.realmNum || 0}.${id.accountNum}`;
+            });
+            accountNums.every((id) => id === SOURCE || id.endsWith('.81320')).should.be.true();
+            // One entry is -1 (debit), one is +1 (credit)
+            const amounts = transfers.map((a) => Number(a.amount.toString()));
+            amounts.should.containEql(-1);
+            amounts.should.containEql(1);
+        });
+        it('should round-trip through serialisation: deserialized tx has source == recipient', async () => {
+            const originalTx = await initSelfTransferBuilder().build();
+            const txHex = originalTx.toBroadcastFormat();
+            should.exist(txHex);
+            txHex.length.should.be.greaterThan(0);
+            // Rebuild from serialised hex
+            const rebuiltBuilder = factory.getTransferBuilder();
+            rebuiltBuilder.from(txHex);
+            const rebuiltTx = await rebuiltBuilder.build();
+            const rebuiltJson = rebuiltTx.toJson();
+            // After round-trip, source and recipient must still be the same account
+            should.deepEqual(rebuiltJson.from, SOURCE);
+            should.deepEqual(rebuiltJson.to, SOURCE);
+            should.deepEqual(rebuiltJson.amount, '1');
+        });
+        it('should sign a self-transfer transaction successfully', async () => {
+            const builder = initSelfTransferBuilder();
+            builder.sign({ key: testData.ACCOUNT_1.prvKeyWithPrefix });
+            const tx = await builder.build();
+            tx.signature.length.should.equal(1);
+            const txJson = tx.toJson();
+            should.deepEqual(txJson.from, SOURCE);
+            should.deepEqual(txJson.to, SOURCE);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coinTransferBuilder.js","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/coinTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as should from 'should';\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport * as testData from '../../resources/hbar';\n\n/**\n * Tests for CoinTransferBuilder self-transfer (stakeClaimRewards).\n *\n * HBAR staking rewards are claimed by submitting a 1-tinybar CryptoTransfer\n * where sender == receiver == accountId. Hedera atomically flushes\n * pending_reward into account balance on any CryptoTransfer touching the\n * account. staking-service uses this as the CLAIM_REWARDS operation.\n *\n * The key behaviour under test:\n *   buildTransferData() must produce TWO separate accountAmounts entries:\n *     [{accountId, -1}, {accountId, +1}]\n *   The Hedera SDK TransferTransaction merges same-account entries (nets to 0),\n *   so CoinTransferBuilder.buildTransferData() bypasses that by building the\n *   proto list directly.\n *\n *   initTransfers() must reconstruct the self-transfer from serialised bytes:\n *   it filters for positive amounts only, so recipients[0].address == source.\n */\ndescribe('HBAR CoinTransferBuilder - self-transfer (stakeClaimRewards)', () => {\n  const factory = getBuilderFactory('thbar');\n\n  const SOURCE = testData.ACCOUNT_1.accountId; // '0.0.81320'\n\n  const initSelfTransferBuilder = () => {\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.fee({ fee: testData.FEE });\n    txBuilder.source({ address: SOURCE });\n    txBuilder.send({ address: SOURCE, amount: '1' }); // self-transfer: 1 tinybar\n    txBuilder.node({ nodeId: '0.0.3' });\n    txBuilder.startTime('1596110493.372646570');\n    return txBuilder;\n  };\n\n  describe('build', () => {\n    it('should build a self-transfer transaction with source equal to recipient', async () => {\n      const tx = await initSelfTransferBuilder().build();\n      const txJson = tx.toJson();\n\n      // Source and recipient are the same account\n      should.deepEqual(txJson.from, SOURCE);\n      should.deepEqual(txJson.to, SOURCE);\n      should.deepEqual(txJson.amount, '1');\n\n      // inputs and outputs both reference the same address\n      tx.inputs.length.should.equal(1);\n      tx.inputs[0].address.should.equal(SOURCE);\n      tx.inputs[0].value.should.equal('1');\n\n      tx.outputs.length.should.equal(1);\n      tx.outputs[0].address.should.equal(SOURCE);\n      tx.outputs[0].value.should.equal('1');\n    });\n\n    it('should produce two separate accountAmounts entries in the protobuf', async () => {\n      const tx = await initSelfTransferBuilder().build();\n\n      // Access the raw protobuf transfer list\n      const transfers = (tx as any).txBody.cryptoTransfer.transfers.accountAmounts as any[];\n      should.exist(transfers);\n      transfers.length.should.equal(2, 'expected exactly two entries: [{source,-1},{source,+1}]');\n\n      // Both entries reference the same account\n      const accountNums = transfers.map((a: any) => {\n        const id = a.accountID;\n        return `${id.shardNum || 0}.${id.realmNum || 0}.${id.accountNum}`;\n      });\n      accountNums.every((id: string) => id === SOURCE || id.endsWith('.81320')).should.be.true();\n\n      // One entry is -1 (debit), one is +1 (credit)\n      const amounts = transfers.map((a: any) => Number(a.amount.toString()));\n      amounts.should.containEql(-1);\n      amounts.should.containEql(1);\n    });\n\n    it('should round-trip through serialisation: deserialized tx has source == recipient', async () => {\n      const originalTx = await initSelfTransferBuilder().build();\n      const txHex = originalTx.toBroadcastFormat();\n      should.exist(txHex);\n      txHex.length.should.be.greaterThan(0);\n\n      // Rebuild from serialised hex\n      const rebuiltBuilder = factory.getTransferBuilder();\n      rebuiltBuilder.from(txHex);\n      const rebuiltTx = await rebuiltBuilder.build();\n      const rebuiltJson = rebuiltTx.toJson();\n\n      // After round-trip, source and recipient must still be the same account\n      should.deepEqual(rebuiltJson.from, SOURCE);\n      should.deepEqual(rebuiltJson.to, SOURCE);\n      should.deepEqual(rebuiltJson.amount, '1');\n    });\n\n    it('should sign a self-transfer transaction successfully', async () => {\n      const builder = initSelfTransferBuilder();\n      builder.sign({ key: testData.ACCOUNT_1.prvKeyWithPrefix });\n      const tx = await builder.build();\n\n      tx.signature.length.should.equal(1);\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.from, SOURCE);\n      should.deepEqual(txJson.to, SOURCE);\n    });\n  });\n});\n"]}