@bitgo-beta/sdk-coin-sol 7.6.4-beta.31 → 7.6.4-beta.310

package/dist/cjs/test/unit/jitoWasmVerification.d.ts

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

package/dist/cjs/test/unit/jitoWasmVerification.d.ts.map

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

package/dist/cjs/test/unit/jitoWasmVerification.js

@@ -0,0 +1,78 @@
+"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 });
+/**
+ * Verification test: Jito WASM parsing works in BitGoJS
+ */
+const should = __importStar(require("should"));
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const src_1 = require("../../src");
+describe('Jito WASM Verification', function () {
+    let bitgo;
+    let tsol;
+    // From BitGoJS test/resources/sol.ts - JITO_STAKING_ACTIVATE_SIGNED_TX
+    const JITO_TX_BASE64 = 'AdOUrFCk9yyhi1iB1EfOOXHOeiaZGQnLRwnypt+be8r9lrYMx8w7/QTnithrqcuBApg1ctJAlJMxNZ925vMP2Q0BAAQKReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Ecg6pe+BOG2OETfAVS9ftz6va1oE4onLBolJ2N+ZOOhJ6naP7fZEyKrpuOIYit0GvFUPv3Fsgiuc5jx3g9lS4fCeaj/uz5kDLhwd9rlyLcs2NOe440QJNrw0sMwcjrUh/80UHpgyyvEK2RdJXKDycbWyk81HAn6nNwB+1A6zmgvQSKPgjDtJW+F/RUJ9ib7FuAx+JpXBhk12dD2zm+00bWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABU5Z4kwFGooUp7HpeX8OEs36dJAhZlMZWmpRKm8WZgKwaBTtTK9ooXRnL9rIYDGmPoTqFe+h1EtyKT9tvbABZQBt324ddloZPZy+FGzut5rBy0he1fWzeROoz1hX7/AKnjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQEICgUHAgABAwEEBgkJDuCTBAAAAAAA';
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.safeRegister('tsol', src_1.Tsol.createInstance);
+        bitgo.initializeTestVars();
+        tsol = bitgo.coin('tsol');
+    });
+    it('should parse Jito DepositSol transaction via WASM', function () {
+        // Verify the raw WASM parsing returns StakePoolDepositSol
+        const { Transaction, parseTransaction } = require('@bitgo/wasm-solana');
+        const txBytes = Buffer.from(JITO_TX_BASE64, 'base64');
+        const tx = Transaction.fromBytes(txBytes);
+        const wasmParsed = parseTransaction(tx);
+        // Verify WASM returns StakePoolDepositSol instruction
+        const depositSolInstr = wasmParsed.instructionsData.find((i) => i.type === 'StakePoolDepositSol');
+        should.exist(depositSolInstr, 'WASM should parse StakePoolDepositSol instruction');
+        depositSolInstr.lamports.should.equal(300000n);
+        // Now test explainTransactionWithWasm - should map to StakingActivate
+        const explained = tsol.explainTransactionWithWasm({
+            txBase64: JITO_TX_BASE64,
+            feeInfo: { fee: '5000' },
+        });
+        // Verify the transaction is correctly interpreted
+        should.exist(explained.id);
+        explained.type.should.equal('StakingActivate');
+        explained.outputAmount.should.equal('300000');
+        explained.outputs.length.should.equal(1);
+        explained.outputs[0].address.should.equal('Jito4APyf642JPZPx3hGc6WWJ8zPKtRbRs4P815Awbb');
+        explained.outputs[0].amount.should.equal('300000');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{test → cjs/test}/unit/keyPair.d.ts.map

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

package/dist/cjs/test/unit/keyPair.js

@@ -0,0 +1,177 @@
+"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 assert_1 = __importDefault(require("assert"));
+const src_1 = require("../../src");
+const should_1 = __importDefault(require("should"));
+const testData = __importStar(require("../resources/sol"));
+const utils_1 = require("../../src/lib/utils");
+describe('Sol KeyPair', function () {
+    const defaultSeed = { seed: testData.accountWithSeed.seed };
+    describe('should create a valid KeyPair', () => {
+        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);
+            keyPair.getKeys().prv?.length.should.be.belowOrEqual(88);
+            keyPair.getKeys().prv?.length.should.be.aboveOrEqual(76);
+            keyPair.getKeys().pub.length.should.be.belowOrEqual(44);
+            keyPair.getKeys().pub.length.should.be.aboveOrEqual(32);
+        });
+        it('from a private key', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });
+            should_1.default.equal(keyPair.getKeys().pub, testData.accountWithSeed.publicKey);
+            should_1.default.equal(keyPair.getKeys().prv, testData.accountWithSeed.privateKey.base58);
+            should_1.default.equal(keyPair.getKeys(true).pub, testData.accountWithSeed.publicKey);
+            should_1.default.deepEqual(keyPair.getKeys(true).prv, testData.accountWithSeed.privateKey.uint8Array);
+        });
+        it('from an public key', () => {
+            const keyPair = new src_1.KeyPair({ pub: testData.accountWithSeed.publicKey });
+            should_1.default.equal(keyPair.getKeys().pub, testData.accountWithSeed.publicKey);
+        });
+        it('should always generate and regenerate valid key pairs', () => {
+            for (let i = 0; i < 50; i++) {
+                const keyPair = new src_1.KeyPair();
+                (0, utils_1.isValidPublicKey)(keyPair.getKeys().pub).should.be.true();
+                (0, utils_1.isValidAddress)(keyPair.getAddress()).should.be.true();
+                const prv = keyPair.getKeys().prv;
+                should_1.default.exist(prv);
+                // verify key pair can be re-generated from private portion
+                const regeneratedKeyPairFromPrv = new src_1.KeyPair({ prv: prv });
+                regeneratedKeyPairFromPrv.getKeys().should.deepEqual(keyPair.getKeys());
+                regeneratedKeyPairFromPrv.getAddress().should.equal(keyPair.getAddress());
+                regeneratedKeyPairFromPrv.should.deepEqual(keyPair);
+                should_1.default.exist(regeneratedKeyPairFromPrv.getKeys().prv);
+                // verify key pair can be re-generated from public portion
+                const pub = keyPair.getKeys().pub;
+                const regeneratedKeyPairFromPub = new src_1.KeyPair({ pub: pub });
+                regeneratedKeyPairFromPub.getKeys().pub.should.deepEqual(keyPair.getKeys().pub);
+                regeneratedKeyPairFromPub.getAddress().should.equal(keyPair.getAddress());
+                should_1.default.not.exist(regeneratedKeyPairFromPub.getKeys().prv);
+            }
+        });
+    });
+    describe('should fail to create a KeyPair', function () {
+        it('from invalid options', () => {
+            // @ts-expect-error Testing for an params, should throw error
+            (0, should_1.default)(() => new src_1.KeyPair({ random: 'random' })).throwError('Invalid key pair options');
+        });
+        it('from an invalid seed', () => {
+            const seed = { seed: Buffer.alloc(8) }; //  Seed should be 512 bits (64 bytes)
+            assert_1.default.throws(() => new src_1.KeyPair(seed));
+        });
+        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));
+        });
+    });
+    describe('getAddress', function () {
+        it('should get an address', () => {
+            const keyPair = new src_1.KeyPair(defaultSeed);
+            const address = keyPair.getAddress();
+            address.should.equal(testData.accountWithSeed.publicKey);
+        });
+    });
+    describe('getKeys', function () {
+        it('should get public keys in base58 and private in Uint8Array', () => {
+            const keyPair = new src_1.KeyPair(defaultSeed);
+            const { prv, pub } = keyPair.getKeys(true);
+            prv?.should.deepEqual(testData.accountWithSeed.privateKey.uint8Array);
+            pub.should.equal(testData.accountWithSeed.publicKey);
+        });
+        it('should get private and public keys base58', () => {
+            const keyPair = new src_1.KeyPair(defaultSeed);
+            const { prv, pub } = keyPair.getKeys();
+            prv?.should.equal(testData.accountWithSeed.privateKey.base58);
+            pub.should.equal(testData.accountWithSeed.publicKey);
+        });
+        it('should get private and public keys for a random seed', () => {
+            const keyPair = new src_1.KeyPair();
+            const { prv, pub } = keyPair.getKeys();
+            should_1.default.exist(prv);
+            should_1.default.exist(pub);
+        });
+    });
+    describe('signMessage and verifySignature', function () {
+        const message = 'test message pls ignore';
+        it('should succeed to sign a msg ', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });
+            const signedMessage = keyPair.signMessage(message);
+            signedMessage.should.deepEqual(testData.SIGNED_MESSAGE_SIGNATURE);
+        });
+        it('should fail to sign a msg if prv key is missing', () => {
+            const keyPair = new src_1.KeyPair({ pub: testData.pubKeys.validPubKeys[0] });
+            (0, should_1.default)(() => keyPair.signMessage(message)).throwError('Missing private key');
+        });
+    });
+    describe('verifySignature', function () {
+        it('should succeed to verify a signature', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });
+            const signature = testData.SIGNED_MESSAGE_SIGNATURE;
+            const message = 'test message pls ignore';
+            keyPair.verifySignature(message, signature).should.equal(true);
+        });
+        it('should succeed to verify a signature if the msg is a UInt8Array', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });
+            const signature = testData.SIGNED_MESSAGE_SIGNATURE;
+            const message = new Uint8Array(Buffer.from('test message pls ignore'));
+            keyPair.verifySignature(message, signature).should.equal(true);
+        });
+        it('should fail to verify a signature if the prv key is not correct', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.extraAccounts.prv1 });
+            const signature = testData.SIGNED_MESSAGE_SIGNATURE;
+            const message = 'test message pls ignore';
+            keyPair.verifySignature(message, signature).should.equal(false);
+        });
+        it('should fail to verify a signature if the message is not correct', () => {
+            const keyPair = new src_1.KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });
+            const signature = testData.SIGNED_MESSAGE_SIGNATURE;
+            const message = 'incorrect msg';
+            keyPair.verifySignature(message, signature).should.equal(false);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyPair.js","sourceRoot":"","sources":["../../../../test/unit/keyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport { KeyPair } from '../../src';\nimport should from 'should';\nimport * as testData from '../resources/sol';\nimport { isValidPublicKey, isValidAddress } from '../../src/lib/utils';\n\ndescribe('Sol KeyPair', function () {\n  const defaultSeed = { seed: testData.accountWithSeed.seed };\n\n  describe('should create a valid KeyPair', () => {\n    it('from an empty value', () => {\n      const keyPair = new KeyPair();\n      should.exists(keyPair.getKeys().prv);\n      should.exists(keyPair.getKeys().pub);\n      keyPair.getKeys().prv?.length.should.be.belowOrEqual(88);\n      keyPair.getKeys().prv?.length.should.be.aboveOrEqual(76);\n      keyPair.getKeys().pub.length.should.be.belowOrEqual(44);\n      keyPair.getKeys().pub.length.should.be.aboveOrEqual(32);\n    });\n\n    it('from a private key', () => {\n      const keyPair = new KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });\n      should.equal(keyPair.getKeys().pub, testData.accountWithSeed.publicKey);\n      should.equal(keyPair.getKeys().prv, testData.accountWithSeed.privateKey.base58);\n      should.equal(keyPair.getKeys(true).pub, testData.accountWithSeed.publicKey);\n      should.deepEqual(keyPair.getKeys(true).prv, testData.accountWithSeed.privateKey.uint8Array);\n    });\n\n    it('from an public key', () => {\n      const keyPair = new KeyPair({ pub: testData.accountWithSeed.publicKey });\n      should.equal(keyPair.getKeys().pub, testData.accountWithSeed.publicKey);\n    });\n\n    it('should always generate and regenerate valid key pairs', () => {\n      for (let i = 0; i < 50; i++) {\n        const keyPair = new KeyPair();\n        isValidPublicKey(keyPair.getKeys().pub).should.be.true();\n        isValidAddress(keyPair.getAddress()).should.be.true();\n\n        const prv = keyPair.getKeys().prv as string;\n        should.exist(prv);\n\n        // verify key pair can be re-generated from private portion\n        const regeneratedKeyPairFromPrv = new KeyPair({ prv: prv });\n        regeneratedKeyPairFromPrv.getKeys().should.deepEqual(keyPair.getKeys());\n        regeneratedKeyPairFromPrv.getAddress().should.equal(keyPair.getAddress());\n        regeneratedKeyPairFromPrv.should.deepEqual(keyPair);\n        should.exist(regeneratedKeyPairFromPrv.getKeys().prv);\n\n        // verify key pair can be re-generated from public portion\n        const pub = keyPair.getKeys().pub;\n        const regeneratedKeyPairFromPub = new KeyPair({ pub: pub });\n        regeneratedKeyPairFromPub.getKeys().pub.should.deepEqual(keyPair.getKeys().pub);\n        regeneratedKeyPairFromPub.getAddress().should.equal(keyPair.getAddress());\n        should.not.exist(regeneratedKeyPairFromPub.getKeys().prv);\n      }\n    });\n  });\n\n  describe('should fail to create a KeyPair', function () {\n    it('from invalid options', () => {\n      // @ts-expect-error Testing for an params, should throw error\n      should(() => new KeyPair({ random: 'random' })).throwError('Invalid key pair options');\n    });\n\n    it('from an invalid seed', () => {\n      const seed = { seed: Buffer.alloc(8) }; //  Seed should be 512 bits (64 bytes)\n      assert.throws(() => new KeyPair(seed));\n    });\n\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    });\n  });\n\n  describe('getAddress', function () {\n    it('should get an address', () => {\n      const keyPair = new KeyPair(defaultSeed);\n      const address = keyPair.getAddress();\n      address.should.equal(testData.accountWithSeed.publicKey);\n    });\n  });\n\n  describe('getKeys', function () {\n    it('should get public keys in base58 and private in Uint8Array', () => {\n      const keyPair = new KeyPair(defaultSeed);\n      const { prv, pub } = keyPair.getKeys(true);\n      prv?.should.deepEqual(testData.accountWithSeed.privateKey.uint8Array);\n      pub.should.equal(testData.accountWithSeed.publicKey);\n    });\n\n    it('should get private and public keys base58', () => {\n      const keyPair = new KeyPair(defaultSeed);\n      const { prv, pub } = keyPair.getKeys();\n      prv?.should.equal(testData.accountWithSeed.privateKey.base58);\n      pub.should.equal(testData.accountWithSeed.publicKey);\n    });\n\n    it('should get private and public keys for a random seed', () => {\n      const keyPair = new KeyPair();\n      const { prv, pub } = keyPair.getKeys();\n      should.exist(prv);\n      should.exist(pub);\n    });\n  });\n\n  describe('signMessage and verifySignature', function () {\n    const message = 'test message pls ignore';\n\n    it('should succeed to sign a msg ', () => {\n      const keyPair = new KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });\n      const signedMessage = keyPair.signMessage(message);\n      signedMessage.should.deepEqual(testData.SIGNED_MESSAGE_SIGNATURE);\n    });\n\n    it('should fail to sign a msg if prv key is missing', () => {\n      const keyPair = new KeyPair({ pub: testData.pubKeys.validPubKeys[0] });\n      should(() => keyPair.signMessage(message)).throwError('Missing private key');\n    });\n  });\n\n  describe('verifySignature', function () {\n    it('should succeed to verify a signature', () => {\n      const keyPair = new KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });\n      const signature = testData.SIGNED_MESSAGE_SIGNATURE;\n      const message = 'test message pls ignore';\n      keyPair.verifySignature(message, signature).should.equal(true);\n    });\n\n    it('should succeed to verify a signature if the msg is a UInt8Array', () => {\n      const keyPair = new KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });\n      const signature = testData.SIGNED_MESSAGE_SIGNATURE;\n      const message = new Uint8Array(Buffer.from('test message pls ignore'));\n      keyPair.verifySignature(message, signature).should.equal(true);\n    });\n\n    it('should fail to verify a signature if the prv key is not correct', () => {\n      const keyPair = new KeyPair({ prv: testData.extraAccounts.prv1 });\n      const signature = testData.SIGNED_MESSAGE_SIGNATURE;\n      const message = 'test message pls ignore';\n      keyPair.verifySignature(message, signature).should.equal(false);\n    });\n\n    it('should fail to verify a signature if the message is not correct', () => {\n      const keyPair = new KeyPair({ prv: testData.accountWithSeed.privateKey.base58 });\n      const signature = testData.SIGNED_MESSAGE_SIGNATURE;\n      const message = 'incorrect msg';\n      keyPair.verifySignature(message, signature).should.equal(false);\n    });\n  });\n});\n"]}

package/dist/cjs/test/unit/messages/messageBuilderFactory.d.ts.map

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

package/dist/cjs/test/unit/messages/messageBuilderFactory.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon_1 = __importDefault(require("sinon"));
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../../../src");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+describe('Solana MessageBuilderFactory', function () {
+    let sandbox;
+    let factory;
+    const coinConfig = { name: 'tsol' };
+    // Common test data
+    const signatureBase64 = Buffer.from('signature1').toString('base64');
+    const testBroadcastMessage = {
+        type: sdk_core_1.MessageStandardType.SIMPLE,
+        payload: 'test message',
+        serializedSignatures: [
+            {
+                publicKey: 'pubkey1',
+                signature: signatureBase64,
+            },
+        ],
+        signers: ['signer1'],
+        metadata: {},
+    };
+    const unsupportedMessageTypes = [
+        sdk_core_1.MessageStandardType.UNKNOWN,
+        sdk_core_1.MessageStandardType.EIP191,
+        sdk_core_1.MessageStandardType.CIP8,
+        'UNSUPPORTED',
+    ];
+    // Helper functions
+    const assertSimpleMessageBuilder = (builder) => {
+        should_1.default.exist(builder);
+        builder.should.be.instanceof(sdk_core_1.SimpleMessageBuilder);
+    };
+    const assertBuilderMessageProperties = async (builder, expectedPayload) => {
+        const message = await builder.build();
+        message.getType().should.equal(sdk_core_1.MessageStandardType.SIMPLE);
+        message.getPayload().should.equal(expectedPayload);
+        message.getSignatures().should.have.length(1);
+        message.getSigners().should.have.length(1);
+        message.getSigners()[0].should.equal('signer1');
+        message.getMetadata().should.be.an.Object();
+        return message;
+    };
+    const assertSignatureProperties = (message) => {
+        const signature = message.getSignatures()[0];
+        signature.should.have.properties(['publicKey', 'signature']);
+        signature.publicKey.pub.should.equal('pubkey1');
+        signature.signature.toString('base64').should.equal(signatureBase64);
+    };
+    const assertBroadcastFormatProperties = async (message, expectedSerializedSignatures) => {
+        const rebroadcastMessage = await message.toBroadcastFormat();
+        rebroadcastMessage.should.have.properties(['type', 'payload', 'serializedSignatures', 'signers', 'metadata']);
+        rebroadcastMessage.type.should.equal(sdk_core_1.MessageStandardType.SIMPLE);
+        rebroadcastMessage.payload.should.equal('test message');
+        rebroadcastMessage.serializedSignatures?.should.deepEqual(expectedSerializedSignatures);
+        rebroadcastMessage.signers?.should.deepEqual(['signer1']);
+    };
+    beforeEach(function () {
+        sandbox = sinon_1.default.createSandbox();
+        factory = new src_1.MessageBuilderFactory(coinConfig);
+    });
+    afterEach(function () {
+        sandbox.restore();
+    });
+    describe('getMessageBuilder', function () {
+        it('should return SimpleMessageBuilder for SIMPLE type', function () {
+            const builder = factory.getMessageBuilder(sdk_core_1.MessageStandardType.SIMPLE);
+            assertSimpleMessageBuilder(builder);
+        });
+        it('should throw error for unsupported message type', function () {
+            unsupportedMessageTypes.forEach((type) => {
+                should_1.default.throws(() => factory.getMessageBuilder(type), new RegExp(`Invalid message standard ${type}`));
+            });
+        });
+    });
+    describe('fromBroadcastFormat', function () {
+        it('should get the correct builder type from broadcastable message', async function () {
+            const builder = factory.fromBroadcastFormat(testBroadcastMessage);
+            assertSimpleMessageBuilder(builder);
+            const message = await assertBuilderMessageProperties(builder, 'test message');
+            assertSignatureProperties(message);
+            await assertBroadcastFormatProperties(message, testBroadcastMessage.serializedSignatures);
+        });
+        it('should throw for unsupported message type in broadcastable message', function () {
+            const broadcastMessage = {
+                ...testBroadcastMessage,
+                type: sdk_core_1.MessageStandardType.EIP191,
+            };
+            should_1.default.throws(() => factory.fromBroadcastFormat(broadcastMessage), new RegExp(`Invalid message standard ${sdk_core_1.MessageStandardType.EIP191}`));
+        });
+    });
+    describe('fromBroadcastString', function () {
+        it('should parse broadcastable string and return correct builder type', async function () {
+            const broadcastString = JSON.stringify(testBroadcastMessage);
+            const broadcastHex = Buffer.from(broadcastString).toString('hex');
+            const builder = factory.fromBroadcastString(broadcastHex);
+            assertSimpleMessageBuilder(builder);
+            const message = await assertBuilderMessageProperties(builder, 'test message');
+            assertSignatureProperties(message);
+            await assertBroadcastFormatProperties(message, testBroadcastMessage.serializedSignatures);
+        });
+        it('should throw for invalid JSON string', function () {
+            try {
+                factory.fromBroadcastString('abcdefg'); // Invalid hex string
+                fail('Expected error not thrown');
+            }
+            catch (error) {
+                error.should.be.instanceof(SyntaxError);
+            }
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"messageBuilderFactory.js","sourceRoot":"","sources":["../../../../../test/unit/messages/messageBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin } from '@bitgo-beta/statics';\nimport sinon from 'sinon';\nimport should from 'should';\nimport { MessageBuilderFactory } from '../../../src';\nimport {\n  BroadcastableMessage,\n  IMessage,\n  IMessageBuilder,\n  MessageStandardType,\n  SerializedSignature,\n  SimpleMessageBuilder,\n} from '@bitgo-beta/sdk-core';\n\ndescribe('Solana MessageBuilderFactory', function () {\n  let sandbox: sinon.SinonSandbox;\n  let factory: MessageBuilderFactory;\n  const coinConfig = { name: 'tsol' } as BaseCoin;\n\n  // Common test data\n  const signatureBase64 = Buffer.from('signature1').toString('base64');\n  const testBroadcastMessage: BroadcastableMessage = {\n    type: MessageStandardType.SIMPLE,\n    payload: 'test message',\n    serializedSignatures: [\n      {\n        publicKey: 'pubkey1',\n        signature: signatureBase64,\n      },\n    ],\n    signers: ['signer1'],\n    metadata: {},\n  };\n\n  const unsupportedMessageTypes = [\n    MessageStandardType.UNKNOWN,\n    MessageStandardType.EIP191,\n    MessageStandardType.CIP8,\n    'UNSUPPORTED' as MessageStandardType,\n  ];\n\n  // Helper functions\n  const assertSimpleMessageBuilder = (builder: IMessageBuilder) => {\n    should.exist(builder);\n    builder.should.be.instanceof(SimpleMessageBuilder);\n  };\n\n  const assertBuilderMessageProperties = async (builder: IMessageBuilder, expectedPayload: string) => {\n    const message = await builder.build();\n    message.getType().should.equal(MessageStandardType.SIMPLE);\n    message.getPayload()!.should.equal(expectedPayload);\n    message.getSignatures().should.have.length(1);\n    message.getSigners().should.have.length(1);\n    message.getSigners()[0].should.equal('signer1');\n    message.getMetadata()!.should.be.an.Object();\n    return message;\n  };\n\n  const assertSignatureProperties = (message: IMessage) => {\n    const signature = message.getSignatures()[0];\n    signature.should.have.properties(['publicKey', 'signature']);\n    signature.publicKey.pub.should.equal('pubkey1');\n    signature.signature.toString('base64').should.equal(signatureBase64);\n  };\n\n  const assertBroadcastFormatProperties = async (\n    message: IMessage,\n    expectedSerializedSignatures?: SerializedSignature[]\n  ) => {\n    const rebroadcastMessage = await message.toBroadcastFormat();\n    rebroadcastMessage.should.have.properties(['type', 'payload', 'serializedSignatures', 'signers', 'metadata']);\n    rebroadcastMessage.type.should.equal(MessageStandardType.SIMPLE);\n    rebroadcastMessage.payload.should.equal('test message');\n    rebroadcastMessage.serializedSignatures?.should.deepEqual(expectedSerializedSignatures);\n    rebroadcastMessage.signers?.should.deepEqual(['signer1']);\n  };\n\n  beforeEach(function () {\n    sandbox = sinon.createSandbox();\n    factory = new MessageBuilderFactory(coinConfig);\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  describe('getMessageBuilder', function () {\n    it('should return SimpleMessageBuilder for SIMPLE type', function () {\n      const builder = factory.getMessageBuilder(MessageStandardType.SIMPLE);\n      assertSimpleMessageBuilder(builder);\n    });\n\n    it('should throw error for unsupported message type', function () {\n      unsupportedMessageTypes.forEach((type) => {\n        should.throws(() => factory.getMessageBuilder(type), new RegExp(`Invalid message standard ${type}`));\n      });\n    });\n  });\n\n  describe('fromBroadcastFormat', function () {\n    it('should get the correct builder type from broadcastable message', async function () {\n      const builder = factory.fromBroadcastFormat(testBroadcastMessage);\n      assertSimpleMessageBuilder(builder);\n\n      const message = await assertBuilderMessageProperties(builder, 'test message');\n      assertSignatureProperties(message);\n      await assertBroadcastFormatProperties(message, testBroadcastMessage.serializedSignatures);\n    });\n\n    it('should throw for unsupported message type in broadcastable message', function () {\n      const broadcastMessage = {\n        ...testBroadcastMessage,\n        type: MessageStandardType.EIP191,\n      };\n\n      should.throws(\n        () => factory.fromBroadcastFormat(broadcastMessage),\n        new RegExp(`Invalid message standard ${MessageStandardType.EIP191}`)\n      );\n    });\n  });\n\n  describe('fromBroadcastString', function () {\n    it('should parse broadcastable string and return correct builder type', async function () {\n      const broadcastString = JSON.stringify(testBroadcastMessage);\n      const broadcastHex = Buffer.from(broadcastString).toString('hex');\n      const builder = factory.fromBroadcastString(broadcastHex);\n\n      assertSimpleMessageBuilder(builder);\n      const message = await assertBuilderMessageProperties(builder, 'test message');\n      assertSignatureProperties(message);\n      await assertBroadcastFormatProperties(message, testBroadcastMessage.serializedSignatures);\n    });\n\n    it('should throw for invalid JSON string', function () {\n      try {\n        factory.fromBroadcastString('abcdefg'); // Invalid hex string\n        fail('Expected error not thrown');\n      } catch (error) {\n        error.should.be.instanceof(SyntaxError);\n      }\n    });\n  });\n});\n"]}

package/dist/cjs/test/unit/messages/simpleMessageBuilder.d.ts.map

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