dash-platform-sdk 1.5.0-dev.1 → 1.5.0-dev.3

package/src/shielded/createStateTransition.js

@@ -32,7 +32,7 @@ const shieldedTransitionsMap = {
         optionalArguments: []
     }
 };
-export default function createStateTransition(builder, type, params) {
+export default async function createStateTransition(builder, type, params) {
     const { method: builderMethod, arguments: classArguments, optionalArguments } = shieldedTransitionsMap[type];
     if (builderMethod == null) {
         throw new Error(`Unimplemented shielded transition type: ${type}`);
@@ -43,7 +43,7 @@ export default function createStateTransition(builder, type, params) {
         throw new Error(`Shielded transition param "${missingArgument}" is missing`);
     }
     const transitionParams = classArguments.concat(optionalArguments).map((classArgument) => params[classArgument]);
-    const result = builderMethod.apply(builder, [...transitionParams, params.platformVersion ?? LATEST_PLATFORM_VERSION]);
+    const result = await builderMethod.apply(builder, [...transitionParams, params.platformVersion ?? LATEST_PLATFORM_VERSION]);
     if (result instanceof StateTransitionWASM) {
         return result;
     }

package/src/shielded/index.d.ts

@@ -16,14 +16,14 @@ export declare class ShieldedController {
      * Set bindings instance of builder
      * Needed for custom builder load, because ShieldedBuilderWASM inits very slow on old hardware
      */
-    init(builder?: ShieldedBuilderWASM): ShieldedBuilderWASM;
+    init(builder?: ShieldedBuilderWASM): Promise<ShieldedBuilderWASM>;
     /**
      * Lazily constructs and caches a {ShieldedBuilderWASM}. Construction builds
      * the Halo 2 proving key (~seconds), so the instance is created once and reused.
      *
      * @ignore
      */
-    getShieldedBuilder(): ShieldedBuilderWASM;
+    getShieldedBuilder(): Promise<ShieldedBuilderWASM>;
     /**
      * Retrieves a batch of shielded encrypted notes from the shielded pool,
      * starting from the given note index.
@@ -126,5 +126,5 @@ export declare class ShieldedController {
      *
      * @return {StateTransitionWASM}
      */
-    createStateTransition<K extends ShieldedTransitionType>(type: K, params: ShieldedTransitionParamsMap[K]): StateTransitionWASM;
+    createStateTransition<K extends ShieldedTransitionType>(type: K, params: ShieldedTransitionParamsMap[K]): Promise<StateTransitionWASM>;
 }

package/src/shielded/index.js

@@ -23,8 +23,9 @@ export class ShieldedController {
      * Set bindings instance of builder
      * Needed for custom builder load, because ShieldedBuilderWASM inits very slow on old hardware
      */
-    init(builder) {
+    async init(builder) {
         this.shieldedBuilder = builder ?? new ShieldedBuilderWASM();
+        await this.shieldedBuilder.init();
         return this.shieldedBuilder;
     }
     /**
@@ -33,9 +34,9 @@ export class ShieldedController {
      *
      * @ignore
      */
-    getShieldedBuilder() {
+    async getShieldedBuilder() {
         if (this.shieldedBuilder == null) {
-            return this.init();
+            return await this.init();
         }
         return this.shieldedBuilder;
     }
@@ -172,7 +173,7 @@ export class ShieldedController {
      *
      * @return {StateTransitionWASM}
      */
-    createStateTransition(type, params) {
+    async createStateTransition(type, params) {
         // @ts-expect-error a plain string memo is normalized to ShieldedMemoWASM (empty when omitted)
         params.memo = typeof params.memo === 'string' ? ShieldedMemoWASM.fromString(params.memo) : ShieldedMemoWASM.empty();
         if (type === 'identityCreateFromShieldedPool') {
@@ -181,6 +182,6 @@ export class ShieldedController {
             identityParams.publicKeys = identityParams.publicKeys
                 .map(({ id, purpose, securityLevel, keyType, readOnly, data, signature, contractBounds }) => new IdentityPublicKeyInCreationWASM(id, purpose, securityLevel, keyType, readOnly, data, signature, (contractBounds != null) ? new ContractBoundsWASM(contractBounds.dataContractId, contractBounds.documentType) : undefined));
         }
-        return createStateTransition(this.getShieldedBuilder(), type, params);
+        return await createStateTransition(await this.getShieldedBuilder(), type, params);
     }
 }

package/test/unit/Node.spec.js

@@ -51,6 +51,12 @@ describe('Node', () => {
         expect(epochsInfo.length).toEqual(10);
         expect(epochsInfo.map(epochInfo => epochInfo.number)).toEqual(expectedEpochsNumbers);
     });
+    test('should be able to call getFinalizedEpochInfos', async () => {
+        const epochsInfo = await sdk.node.getFinalizedEpochsInfo(17100, true, 17110, false);
+        const expectedEpochsNumbers = Array.from({ length: 10 }, (_val, index) => 17100 + index);
+        expect(epochsInfo.length).toEqual(10);
+        expect(epochsInfo.map(epochInfo => epochInfo.epochIndex)).toEqual(expectedEpochsNumbers);
+    });
     test('should be able to call getTotalCreditsInPlatform', async () => {
         const totalCredits = await sdk.node.totalCredits();
         expect(Number(totalCredits)).toBeGreaterThan(0);

package/test/unit/Shielded.spec.js

@@ -35,9 +35,10 @@ function makeSpendableNote(seed, value) {
     return { spend: new SpendableNoteWASM(note, merklePath), anchor, owner };
 }
 describe('Shielded', () => {
-    beforeAll(() => {
+    beforeAll(async () => {
         sdk = new DashPlatformSDK({ network: 'testnet' });
-    });
+        await sdk.shielded.init();
+    }, 60000);
     test('getShieldedNotesCount', async () => {
         const count = await sdk.shielded.getShieldedNotesCount();
         expect(typeof count).toBe('bigint');
@@ -89,7 +90,7 @@ describe('Shielded', () => {
         expect(Array.isArray(recovered)).toBe(true);
         expect(recovered).toHaveLength(0);
     });
-    test('buildSpendableNotes produces a spend usable by a transition', () => {
+    test('buildSpendableNotes produces a spend usable by a transition', async () => {
         const seed = randomBytes(32);
         const owner = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
         const rho = randomBytes(32);
@@ -106,7 +107,7 @@ describe('Shielded', () => {
         expect(spends[0]).toEqual(expect.any(SpendableNoteWASM));
         expect(anchor).toBeInstanceOf(Uint8Array);
         // the produced spend + anchor must actually prove a spend transition
-        const stateTransition = sdk.shielded.createStateTransition('shieldedTransfer', {
+        const stateTransition = await sdk.shielded.createStateTransition('shieldedTransfer', {
             spends,
             recipient: OrchardAddressWASM.fromSeed(randomBytes(32), COIN_TYPE, ACCOUNT),
             transferAmount: BigInt(1000000),
@@ -119,12 +120,12 @@ describe('Shielded', () => {
         expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
     }, 60000);
     describe('should be able to create state transition', () => {
-        test('should be able to create a shield transition', () => {
+        test('should be able to create a shield transition', async () => {
             const seed = randomBytes(32);
             const recipient = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
             const privateKey = new PrivateKeyWASM(randomBytes(32), 'testnet');
             const address = platformAddress(privateKey.getPublicKey().hash160());
-            const stateTransition = sdk.shielded.createStateTransition('shield', {
+            const stateTransition = await sdk.shielded.createStateTransition('shield', {
                 recipient,
                 shieldAmount: BigInt(50000000),
                 inputs: [new InputAddressWASM(address, 0, BigInt(100000000))],
@@ -135,13 +136,13 @@ describe('Shielded', () => {
             });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
         }, 60000);
-        test('should be able to create a shieldFromAssetLock transition', () => {
+        test('should be able to create a shieldFromAssetLock transition', async () => {
             const seed = randomBytes(32);
             const recipient = OrchardAddressWASM.fromSeed(seed, COIN_TYPE, ACCOUNT);
             const privateKey = PrivateKeyWASM.fromHex('edd04a71bddb31e530f6c2314fd42ada333f6656bb853ece13f0577a8fd30612', 'testnet');
             const txid = '61aede830477254876d435a317241ad46753c4b1350dc991a45ebcf19ab80a11';
             const assetLockProof = AssetLockProofWASM.createChainAssetLockProof(1337, new OutPointWASM(txid, 0));
-            const stateTransition = sdk.shielded.createStateTransition('shieldFromAssetLock', {
+            const stateTransition = await sdk.shielded.createStateTransition('shieldFromAssetLock', {
                 recipient,
                 shieldAmount: BigInt(50000000),
                 assetLockProof,
@@ -151,11 +152,11 @@ describe('Shielded', () => {
             });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
         }, 60000);
-        test('should be able to create a shieldedTransfer transition', () => {
+        test('should be able to create a shieldedTransfer transition', async () => {
             const seed = randomBytes(32);
             const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
             const recipient = OrchardAddressWASM.fromSeed(randomBytes(32), COIN_TYPE, ACCOUNT);
-            const stateTransition = sdk.shielded.createStateTransition('shieldedTransfer', {
+            const stateTransition = await sdk.shielded.createStateTransition('shieldedTransfer', {
                 spends: [spend],
                 recipient,
                 transferAmount: BigInt(1000000),
@@ -168,10 +169,10 @@ describe('Shielded', () => {
             });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
         }, 60000);
-        test('should be able to create an unshield transition', () => {
+        test('should be able to create an unshield transition', async () => {
             const seed = randomBytes(32);
             const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
-            const stateTransition = sdk.shielded.createStateTransition('unshield', {
+            const stateTransition = await sdk.shielded.createStateTransition('unshield', {
                 spends: [spend],
                 outputAddress: platformAddress(),
                 unshieldAmount: BigInt(1000000),
@@ -184,10 +185,10 @@ describe('Shielded', () => {
             });
             expect(stateTransition).toEqual(expect.any(StateTransitionWASM));
         }, 60000);
-        test('should be able to create a shieldedWithdrawal transition', () => {
+        test('should be able to create a shieldedWithdrawal transition', async () => {
             const seed = randomBytes(32);
             const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(10000000000));
-            const stateTransition = sdk.shielded.createStateTransition('shieldedWithdrawal', {
+            const stateTransition = await sdk.shielded.createStateTransition('shieldedWithdrawal', {
                 spends: [spend],
                 withdrawalAmount: BigInt(1000000),
                 outputScript: CoreScriptWASM.newP2PKH(randomBytes(20)),
@@ -205,7 +206,7 @@ describe('Shielded', () => {
         // The proving step succeeds, but `IdentityCreateFromShieldedPoolResultWASM.identityId`
         // (read while assembling the transition) rejects the derived id for synthetic notes.
         // A real run needs a funded note and signed keys, so this is covered against a live pool.
-        test('should be able to create an identityCreateFromShieldedPool transition', () => {
+        test('should be able to create an identityCreateFromShieldedPool transition', async () => {
             const seed = randomBytes(32);
             const { spend, anchor, owner } = makeSpendableNote(seed, BigInt(20000000000));
             const privateKey = PrivateKeyWASM.fromHex('a1286dd195e2b8e1f6bdc946c56a53e0c544750d6452ddc0f4c593ef311f21af', 'testnet');
@@ -217,7 +218,7 @@ describe('Shielded', () => {
                 readOnly: false,
                 data: privateKey.getPublicKey().bytes()
             };
-            const stateTransition = sdk.shielded.createStateTransition('identityCreateFromShieldedPool', {
+            const stateTransition = await sdk.shielded.createStateTransition('identityCreateFromShieldedPool', {
                 publicKeys: [identityPublicKeyInCreation],
                 privateKeys: [privateKey],
                 denomination: BigInt(10000000000),