Enable offline transactions

Author: iamalwaysuncomfortable

create-leo-app/template-offline-public-transaction-ts/src/index.ts

@@ -43,7 +43,7 @@ async function buildTransferPublicTxOffline(recipientAddress: Address, amount: n
     // keys into the key manager.
     console.log("Inserting proving keys into key provider");
     offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
-    offlineKeyProvider.cacheKeys(CREDITS_PROGRAM_KEYS.inclusion.locator, [inclusionKey, VerifyingKey.inclusionVerifier()]);
+    offlineKeyProvider.insertInclusionKeys(inclusionKey)
 
     try {
         offlineKeyProvider.insertTransferPublicKeys(transferPublicProvingKey);
@@ -54,7 +54,7 @@ async function buildTransferPublicTxOffline(recipientAddress: Address, amount: n
 
     // Create an offline query to complete the inclusion proof
     let offlineQuery: OfflineQuery;
-    const blockHeight = 0;
+    const blockHeight = 9233665;
     // TODO this is a placeholder block height for now, which offlineQuery now requires
     try {
         offlineQuery = new OfflineQuery(blockHeight, latestStateRoot);
@@ -115,7 +115,7 @@ async function buildBondingTxOffline(
     offlineKeyProvider.insertBondPublicKeys(bondPublicProvingKey);
     offlineKeyProvider.insertUnbondPublicKeys(unBondPublicProvingKey);
     offlineKeyProvider.insertClaimUnbondPublicKeys(claimUnbondPublicProvingKey);
-    offlineKeyProvider.cacheKeys(CREDITS_PROGRAM_KEYS.inclusion.locator, [inclusionProvingKey, VerifyingKey.inclusionVerifier()]);
+    offlineKeyProvider.insertInclusionKeys(inclusionProvingKey);
 
     // Insert the key provider into the program manager
     programManager.setKeyProvider(offlineKeyProvider);
@@ -129,7 +129,7 @@ async function buildBondingTxOffline(
 
     const bondPublicOptions = {
         keySearchParams: OfflineSearchParams.bondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
+        offlineQuery: new OfflineQuery(9233665, latestStateRoot)
     };
 
     console.log("Build bond public transaction");
@@ -144,7 +144,7 @@ async function buildBondingTxOffline(
 
     const unbondPublicOptions = {
         keySearchParams: OfflineSearchParams.unbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
+        offlineQuery: new OfflineQuery(9233665, latestStateRoot)
     };
 
     const unBondTx = <Transaction>await programManager.buildUnbondPublicTransaction(
@@ -157,7 +157,7 @@ async function buildBondingTxOffline(
     console.log("Building a claim_unbond_public transaction offline");
     const claimUnbondPublicOptions = {
         keySearchParams: OfflineSearchParams.claimUnbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(0, latestStateRoot)
+        offlineQuery: new OfflineQuery(9233665, latestStateRoot)
     };
 
     const claimUnbondTx = <Transaction>await programManager.buildClaimUnbondPublicTransaction(
@@ -185,14 +185,19 @@ async function main() {
         // ------------------OFFLINE COMPONENT---------------------
         //           (Do this part on an offline machine)
         // Get the latest state root from an online machine and enter it into an offline machine
-        const latestStateRoot = "sr1p93gpsezrjzdhcd2wujznx5s07k8qa39t6vfcej35zew8vn2jyrs46te8q";
+        const latestStateRoot = "sr18kzmy5fw3rwr8gldzfg2deemvyapgkuahte372shyz7phtwtsypqngg0ml";
 
-        // Build a transfer_public transaction
+        // // // Build a transfer_public transaction
         const transferTx = await buildTransferPublicTxOffline(stakerAddress, 10000, latestStateRoot, transferKeyPaths);
         console.log("Transfer transaction built offline!");
         console.log(`\n---------------transfer_public transaction---------------\n${transferTx}`);
         console.log(`---------------------------------------------------------`);
 
+        function sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+        await sleep(15000);
+
         // Build bonding & unbonding transactions
         const bondTransactions = await buildBondingTxOffline(validatorAddress, withdrawalAddress, 100, latestStateRoot, bondingKeyPaths);
         console.log("Bonding transactions built offline!");

sdk/src/function-key-provider.ts

@@ -173,6 +173,13 @@ interface FunctionKeyProvider {
      */
     feePublicKeys(): Promise<FunctionKeyPair>;
 
+    /**
+     * Get keys for the inclusion proof.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the join function
+     */
+    inclusionKeys(): Promise<FunctionKeyPair>;
+
     /**
      * Get join function keys from the credits.aleo program
      *
@@ -515,6 +522,24 @@ class AleoKeyProvider implements FunctionKeyProvider {
         }
     }
 
+    /**
+     * Returns the proving and verifying keys for the transfer_public function.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the transfer_public function
+     */
+    async transferPublicKeys(): Promise<FunctionKeyPair> {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.transfer_public);
+    }
+
+    /**
+     * Returns the proving and verifying keys for the inclusion proof.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the inclusion proof.
+     */
+    async inclusionKeys(): Promise<FunctionKeyPair> {
+        return await this.fetchCreditsKeys(CREDITS_PROGRAM_KEYS.inclusion);
+    }
+
     /**
      * Returns the proving and verifying keys for the join function in the credits.aleo program
      *

sdk/src/offline-key-provider.ts

@@ -361,6 +361,15 @@ class OfflineKeyProvider implements FunctionKeyProvider {
         return this.functionKeys(OfflineSearchParams.feePublicKeyParams());
     };
 
+    /**
+     * Get the inclusion prover keys from. The keys must be cached prior to calling this method for it to work.
+     *
+     * @returns {Promise<FunctionKeyPair>} Proving and verifying keys for the inclusion prover
+     */
+    inclusionKeys(): Promise<FunctionKeyPair> {
+        return this.functionKeys(OfflineSearchParams.inclusionKeyParams());
+    };
+
     /**
      * Get join function keys from the credits.aleo program. The keys must be cached prior to calling this
      * method for it to work.
@@ -488,6 +497,21 @@ class OfflineKeyProvider implements FunctionKeyProvider {
         }
     }
 
+    /**
+     * Insert the proving and verifying keys for the inclusion prover into the cache. Only the proving key needs
+     * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check
+     * that the keys match the expected checksum for the inclusion prover.
+     *
+     * @param provingKey
+     */
+    insertInclusionKeys(provingKey: ProvingKey) {
+        if (provingKey.isInclusionProver()) {
+            this.cache.set(CREDITS_PROGRAM_KEYS.inclusion.locator, [provingKey.toBytes(), VerifyingKey.inclusionVerifier().toBytes()]);
+        } else {
+            throw new Error("Attempted to insert invalid proving keys for the inclusion prover");
+        }
+    }
+
     /**
      * Insert the proving and verifying keys for the join function into the cache. Only the proving key needs
      * to be inserted, the verifying key is automatically inserted by the SDK. This function will automatically check

sdk/src/program-manager.ts

@@ -116,6 +116,7 @@ class ProgramManager {
     host: string;
     networkClient: AleoNetworkClient;
     recordProvider: RecordProvider | undefined;
+    inclusionKeysLoaded: boolean = false;
 
     /** Create a new instance of the ProgramManager
      *
@@ -584,10 +585,15 @@ class ProgramManager {
             }
         }
 
-        if (offlineQuery) {
-            console.log("Using offline query.");
-        } else {
-            console.log("Not using offline query.");
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                WasmProgramManager.loadInclusionProver(inclusionKeys[0])
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            } catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`)
+            }
         }
 
         // Build an execution transaction
@@ -1118,6 +1124,18 @@ class ProgramManager {
             );
         }
 
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                WasmProgramManager.loadInclusionProver(inclusionKeys[0])
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            } catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`)
+            }
+        }
+
         // Build an execution transaction and submit it to the network
         const tx = await WasmProgramManager.buildJoinTransaction(
             executionPrivateKey,
@@ -1210,6 +1228,18 @@ class ProgramManager {
             );
         }
 
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                WasmProgramManager.loadInclusionProver(inclusionKeys[0])
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            } catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`)
+            }
+        }
+
         // Build an execution transaction and submit it to the network
         const tx = await WasmProgramManager.buildSplitTransaction(
             executionPrivateKey,
@@ -1388,10 +1418,18 @@ class ProgramManager {
             );
         }
 
-        if (offlineQuery) {
-            console.log("Using offline query.");
-        } else {
-            console.log("Using online query.")
+        // Load the inclusion prover offline.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            const inclusionKeys = await this.keyProvider.inclusionKeys();
+            WasmProgramManager.loadInclusionProver(inclusionKeys[0])
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                WasmProgramManager.loadInclusionProver(inclusionKeys[0])
+                this.inclusionKeysLoaded = true;
+                console.log("Successfully loaded inclusion key");
+            } catch {
+                logAndThrow(`Inclusion key bytes not loaded, please ensure the program manager is initialized with a KeyProvider that includes the inclusion key.`)
+            }
         }
 
         // Build an execution transaction
@@ -2320,6 +2358,15 @@ class ProgramManager {
         }
     }
 
+    /**
+     * Set the inclusion key bytes.
+     *
+     * @param {executionResponse} executionResponse The response from an offline function execution (via the `programManager.run` method)
+     * @param {ImportedPrograms} imports The imported programs used in the execution. Specified as { "programName": "programSourceCode", ... }
+     * @param {ImportedVerifyingKeys} importedVerifyingKeys The verifying keys in the execution. Specified as { "programName": [["functionName", "verifyingKey"], ...], ... }
+     * @returns {boolean} True if the proof is valid, false otherwise
+     *
+
     /**
      * Create a program object from a program's source code
      *