Fixing build errors

Author: Pauan

sdk/src/network-client.ts

@@ -1715,16 +1715,16 @@ class AleoNetworkClient {
      * const transactionId = await networkClient.submitTransaction(tx);
      *
      * // Wait for the transaction to be confirmed.
-     * const transaction = await networkClient.waitForTransactionConfirmation(transactionId);
+     * const transaction = await networkClient.waitForTransactionConfirmation({ transactionId });
      */
     async waitForTransactionConfirmation({
         transactionId,
         checkInterval = 2000,
         timeout = 45000,
     }: {
         transactionId: string,
-        checkInterval: number,
-        timeout: number,
+        checkInterval?: number,
+        timeout?: number,
     }): Promise<ConfirmedTransactionJSON> {
         const startTime = Date.now();
 

sdk/src/program-manager.ts

@@ -2681,12 +2681,12 @@ class ProgramManager {
             try {
                 const recordProvider = <RecordProvider>this.recordProvider;
                 return <RecordPlaintext>(
-                    await recordProvider.findCreditsRecord(
-                        amount,
-                        true,
+                    await recordProvider.findCreditsRecord({
+                        microcredits: amount,
+                        unspent: true,
                         nonces,
-                        params,
-                    )
+                        searchParameters: params,
+                    })
                 );
             } catch (e: any) {
                 logAndThrow(

sdk/tests/network-client.test.ts

@@ -345,7 +345,9 @@ describe("NodeConnection", () => {
             if (connection.network === "mainnet") {
                 const connection = new AleoNetworkClient(host);
                 const txId = getTxId(connection, "accepted");
-                const data = await connection.waitForTransactionConfirmation(txId);
+                const data = await connection.waitForTransactionConfirmation({
+                    transactionId: txId,
+                });
                 expect(data.status).to.equal("accepted");
                 expect(data.type).to.be.a("string");
             }
@@ -356,7 +358,9 @@ describe("NodeConnection", () => {
             const txId = getTxId(connection, "rejected");
             try {
                 console.log(txId);
-                await connection.waitForTransactionConfirmation(txId);
+                await connection.waitForTransactionConfirmation({
+                    transactionId: txId,
+                });
                 throw new Error(
                     "Expected waitForTransactionConfirmation to throw for rejected tx",
                 );
@@ -371,7 +375,9 @@ describe("NodeConnection", () => {
         it("should throw for a malformed tx ID", async () => {
             const connection = new AleoNetworkClient(host);
             try {
-                await connection.waitForTransactionConfirmation(invalidTx);
+                await connection.waitForTransactionConfirmation({
+                    transactionId: invalidTx,
+                });
                 throw new Error(
                     "Expected waitForTransactionConfirmation to throw",
                 );
@@ -480,11 +486,11 @@ describe("NodeConnection", () => {
         it('Plaintext returned from the API should have expected properties', async () => {
             if (connection.network === "testnet") {
                 // Check a struct variant of a plaintext object.
-                let plaintext = await connection.getProgramMappingPlaintext(
-                    "credits.aleo",
-                    "committee",
-                    "aleo17m3l8a4hmf3wypzkf5lsausfdwq9etzyujd0vmqh35ledn2sgvqqzqkqal",
-                );
+                let plaintext = await connection.getProgramMappingPlaintext({
+                    programId: "credits.aleo",
+                    mappingName: "committee",
+                    key: "aleo17m3l8a4hmf3wypzkf5lsausfdwq9etzyujd0vmqh35ledn2sgvqqzqkqal",
+                });
                 expect(plaintext.plaintextType()).equal("struct");
 
                 // Ensure the JS object representation matches the wasm representation.
@@ -497,11 +503,11 @@ describe("NodeConnection", () => {
                 expect(plaintextObject.commission).equal(commission);
 
                 // Check a literal variant of a plaintext object.
-                plaintext = await connection.getProgramMappingPlaintext(
-                    "credits.aleo",
-                    "account",
-                    "aleo17m3l8a4hmf3wypzkf5lsausfdwq9etzyujd0vmqh35ledn2sgvqqzqkqal",
-                );
+                plaintext = await connection.getProgramMappingPlaintext({
+                    programId: "credits.aleo",
+                    mappingName: "account",
+                    key: "aleo17m3l8a4hmf3wypzkf5lsausfdwq9etzyujd0vmqh35ledn2sgvqqzqkqal",
+                });
                 expect(plaintext.plaintextType()).equal("u64");
                 expect(plaintext.toObject()).a("bigint");
             }

sdk/tests/program-manager.test.ts

@@ -39,13 +39,19 @@ import * as process from "node:process";
 describe('Program Manager', async () => {
     const keyProvider = new AleoKeyProvider();
     keyProvider.useCache(true);
-    const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider);
+    const programManager = new ProgramManager({
+        host: "https://api.explorer.provable.com/v1",
+        keyProvider,
+    });
     programManager.setAccount(new Account({privateKey: statePathv0RecordOwnerPrivateKey}));
     const network = programManager.networkClient.network;
 
     describe('Instantiate with AleoNetworkClientOptions', () => {
         it('should have the specified headers when instantiated', async () => {
-            const newProgramManager = new ProgramManager("https://api.explorer.provable.com/v1", undefined, undefined, { headers: {'X-Test-Header': 'programManager'} });
+            const newProgramManager = new ProgramManager({
+                host: "https://api.explorer.provable.com/v1",
+                networkClientOptions: { headers: {'X-Test-Header': 'programManager'} },
+            });
             expect(Object.keys(newProgramManager.networkClient.headers).length).equal(1);
             expect(newProgramManager.networkClient.headers['X-Test-Header']).equal('programManager');
             expect(newProgramManager.networkClient.headers['X-Aleo-SDK-Version']).undefined;
@@ -66,9 +72,17 @@ describe('Program Manager', async () => {
 
     describe('Execute offline', () => {
         it.skip('Program manager should execute offline and verify the resulting proof correctly', async () => {
-            const execution_result = <ExecutionResponse>await programManager.run(helloProgram, "hello", ["5u32", "5u32"], true, undefined, undefined, undefined, undefined, undefined, undefined)
+            const execution_result = <ExecutionResponse>await programManager.run({
+                program: helloProgram,
+                functionName: "hello",
+                inputs: ["5u32", "5u32"],
+                proveExecution: true,
+            });
             expect(execution_result.getOutputs()[0]).equal("10u32");
-            programManager.verifyExecution(execution_result, 10_300_000);
+            programManager.verifyExecution({
+                executionResponse: execution_result,
+                blockHeight: 10_300_000,
+            });
         });
     });
 
@@ -111,8 +125,17 @@ describe('Program Manager', async () => {
             offlineQuery.addStatePath(commitment, recordStatePathv0);
             const credits = <string>await programManager.networkClient.getProgram("credits.aleo");
 
-            const execution_result = <ExecutionResponse>await programManager.run(credits, "transfer_private", [statePathRecordv0, beaconAddressString, "5u64"], true, undefined, undefined, undefined, undefined, undefined, offlineQuery);
-            const verified = programManager.verifyExecution(execution_result, 10_300_000);
+            const execution_result = <ExecutionResponse>await programManager.run({
+                program: credits,
+                functionName: "transfer_private",
+                inputs: [statePathRecordv0, beaconAddressString, "5u64"],
+                proveExecution: true,
+                offlineQuery,
+            });
+            const verified = programManager.verifyExecution({
+                executionResponse: execution_result,
+                blockHeight: 10_300_000,
+            });
             expect(verified).equal(true);
         });
     });

sdk/tests/record-provider.integration.ts

@@ -18,7 +18,11 @@ describe('RecordProvider', () => {
             try {
                 // Find two records with findCreditsRecords
                 const nonces: string[] = [];
-                const records = await recordProvider.findCreditsRecords([100, 200], true, []);
+                const records = await recordProvider.findCreditsRecords({
+                    microcredits: [100, 200],
+                    unspent: true,
+                    nonces: [],
+                });
                 if (Array.isArray(records)) {
                     expect(records.length).equal(2);
                     records.forEach((record) => {
@@ -29,7 +33,11 @@ describe('RecordProvider', () => {
                 }
 
                 // Get another two records with findCreditsRecords and ensure they are unique
-                const records2 = await recordProvider.findCreditsRecords([100, 200], true, nonces);
+                const records2 = await recordProvider.findCreditsRecords({
+                    microcredits: [100, 200],
+                    unspent: true,
+                    nonces: nonces,
+                });
                 if (Array.isArray(records2)) {
                     expect(records2.length).equal(2);
                     records2.forEach((record) => {

sdk/tests/record-provider.test.ts

@@ -15,8 +15,13 @@ describe.skip('RecordProvider', () => {
 
     describe('Record provider', () => {
         it('should not find records where there are none', async () => {
-            const params = new BlockHeightSearch(0, 100);
-            const records = await recordProvider.findCreditsRecords([100, 200], true, [], params);
+            const params = new BlockHeightSearch({ startHeight: 0, endHeight: 100 });
+            const records = await recordProvider.findCreditsRecords({
+                microcredits: [100, 200],
+                unspent: true,
+                nonces: [],
+                searchParameters: params,
+            });
             expect(<object>records).equal([]);
         });
     });