@provablehq/sdk 0.9.10-testnet-rc → 0.9.10

package/dist/dynamic/browser.d.ts

@@ -0,0 +1,8 @@
+interface Networks {
+    "testnet": typeof import("../testnet/browser"),
+    "mainnet": typeof import("../mainnet/browser"),
+}
+
+export { Networks };
+
+export declare function loadNetwork<Key extends keyof Networks>(name: Key): Promise<Networks[Key]>;

package/dist/dynamic/browser.js

@@ -0,0 +1,8 @@
+const networks = {
+    "testnet": () => import("../testnet/browser.js"),
+    "mainnet": () => import("../mainnet/browser.js"),
+};
+
+export function loadNetwork(name) {
+    return networks[name]();
+}

package/dist/dynamic/node.d.ts

@@ -0,0 +1,8 @@
+interface Networks {
+    "testnet": typeof import("../testnet/node"),
+    "mainnet": typeof import("../mainnet/node"),
+}
+
+export { Networks };
+
+export declare function loadNetwork<Key extends keyof Networks>(name: Key): Promise<Networks[Key]>;

package/dist/dynamic/node.js

@@ -0,0 +1,8 @@
+const networks = {
+    "testnet": () => import("../testnet/node.js"),
+    "mainnet": () => import("../mainnet/node.js"),
+};
+
+export function loadNetwork(name) {
+    return networks[name]();
+}

package/dist/mainnet/browser.d.ts

@@ -37,10 +37,11 @@ import { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, Cach
 import { OfflineKeyProvider, OfflineSearchParams } from "./offline-key-provider.js";
 import { BlockHeightSearch, NetworkRecordProvider, RecordProvider } from "./record-provider.js";
 import { RecordScanner } from "./record-scanner.js";
+import { SealanceMerkleTree } from "./integrations/sealance/merkle-tree.js";
 declare function initializeWasm(): Promise<void>;
 export { ProgramManager, ProvingRequestOptions, ExecuteOptions, FeeAuthorizationOptions, AuthorizationOptions } from "./program-manager.js";
 export { logAndThrow } from "./utils.js";
 export { Address, Authorization, Boolean, BHP256, BHP512, BHP768, BHP1024, Ciphertext, ComputeKey, Execution as FunctionExecution, ExecutionRequest, ExecutionResponse, EncryptionToolkit, Field, GraphKey, Group, I8, I16, I32, I64, I128, OfflineQuery, Pedersen64, Pedersen128, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Signature, Scalar, Transaction, Transition, U8, U16, U32, U64, U128, VerifyingKey, ViewKey, initThreadPool, getOrInitConsensusVersionTestHeights, verifyFunctionExecution, } from "./wasm.js";
 export { initializeWasm };
 export { Key, CREDITS_PROGRAM_KEYS, KEY_STORE, PRIVATE_TRANSFER, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, PUBLIC_TO_PRIVATE_TRANSFER, RECORD_DOMAIN, VALID_TRANSFER_TYPES, } from "./constants.js";
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, BlockJSON, BlockHeightSearch, CachedKeyPair, ConfirmedTransactionJSON, DeploymentJSON, DeploymentObject, EncryptedRecord, ExecutionJSON, ExecutionObject, FeeExecutionJSON, FeeExecutionObject, FinalizeJSON, FunctionObject, FunctionKeyPair, FunctionKeyProvider, Header, ImportedPrograms, ImportedVerifyingKeys, InputJSON, InputObject, KeySearchParams, Metadata, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, OutputJSON, OutputObject, OwnedFilter, OwnedRecord, OwnerJSON, PartialSolutionJSON, PlaintextArray, PlaintextLiteral, PlaintextObject, PlaintextStruct, ProgramImports, ProvingRequestJSON, ProvingResponse, RatificationJSON, RecordsFilter, RecordsResponseFilter, RecordProvider, RecordScanner, RecordSearchParams, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, BlockJSON, BlockHeightSearch, CachedKeyPair, ConfirmedTransactionJSON, DeploymentJSON, DeploymentObject, EncryptedRecord, ExecutionJSON, ExecutionObject, FeeExecutionJSON, FeeExecutionObject, FinalizeJSON, FunctionObject, FunctionKeyPair, FunctionKeyProvider, Header, ImportedPrograms, ImportedVerifyingKeys, InputJSON, InputObject, KeySearchParams, Metadata, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, OutputJSON, OutputObject, OwnedFilter, OwnedRecord, OwnerJSON, PartialSolutionJSON, PlaintextArray, PlaintextLiteral, PlaintextObject, PlaintextStruct, ProgramImports, ProvingRequestJSON, ProvingResponse, RatificationJSON, RecordsFilter, RecordsResponseFilter, RecordProvider, RecordScanner, RecordSearchParams, SealanceMerkleTree, SolutionJSON, SolutionsJSON, TransactionJSON, TransactionObject, TransitionJSON, TransitionObject, VerifyingKeys, };

package/dist/mainnet/browser.js

@@ -1,6 +1,7 @@
 import 'core-js/proposals/json-parse-with-source.js';
 import { ViewKey, ComputeKey, Address, PrivateKeyCiphertext, PrivateKey, RecordCiphertext, EncryptionToolkit, Group, Program, Plaintext, Transaction, ProvingRequest, Metadata, VerifyingKey, ProvingKey, RecordPlaintext, Field, Poseidon4, ProgramManager as ProgramManager$1, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
 export { Address, Authorization, BHP1024, BHP256, BHP512, BHP768, Boolean, Ciphertext, ComputeKey, EncryptionToolkit, ExecutionRequest, ExecutionResponse, Field, Execution as FunctionExecution, GraphKey, Group, I128, I16, I32, I64, I8, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, ProvingRequest, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, U128, U16, U32, U64, U8, VerifyingKey, ViewKey, getOrInitConsensusVersionTestHeights, initThreadPool, verifyFunctionExecution } from '@provablehq/wasm/mainnet.js';
+import { bech32m } from '@scure/base';
 
 /**
  * Key Management class. Enables the creation of a new Aleo Account, importation of an existing account from
@@ -491,7 +492,7 @@ class AleoNetworkClient {
         else {
             this.headers = {
                 // This is replaced by the actual version by a Rollup plugin
-                "X-Aleo-SDK-Version": "0.9.10-testnet-rc",
+                "X-Aleo-SDK-Version": "0.9.10",
                 "X-Aleo-environment": environment(),
             };
         }
@@ -2045,6 +2046,10 @@ const PUBLIC_TO_PRIVATE_TRANSFER = new Set([
     "transferPublicToPrivate",
 ]);
 const RECORD_DOMAIN = "RecordScannerV0";
+/**
+ * Zero address on Aleo blockchain that corresponds to field element 0. Used as padding in Merkle trees and as a sentinel value.
+ */
+const ZERO_ADDRESS = "aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc";
 
 /**
  * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
@@ -3587,6 +3592,222 @@ class RecordScanner {
     }
 }
 
+/**
+ * Client library that encapsulates methods for constructing Merkle exclusion proofs for compliant stablecoin programs following the Sealance architecture.
+ *
+
+ * @example
+ * Construct a Merkle exclusion proof.
+ *  ```typescript
+ * const sealance = new SealanceMerkleTree();
+ * const leaves = [
+ *      "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px",
+ *      "aleo1s3ws5tra87fjycnjrwsjcrnw2qxr8jfqqdugnf0xzqqw29q9m5pqem2u4t",
+ *      "aleo1s3ws5tra87fjycnjrwsjcrnw2qxr8jfqqdugnf0xzqqw29q9m5pqem2u4t",
+ *    ];
+ * const result = sealance.generateLeaves(leaves);
+ * const tree = sealance.buildTree(result);
+ * const [leftIdx, rightIdx] = sealance.getLeafIndices(tree, "aleo1kypwp5m7qtk9mwazgcpg0tq8aal23mnrvwfvug65qgcg9xvsrqgspyjm6n");
+ * const proof_left = sealance.getSiblingPath(tree, leftIdx, 15);
+ * const proof_right = sealance.getSiblingPath(tree, rightIdx, 15);
+ * const exclusion_proof = [proof_left, proof_right];
+ * ```
+ */
+class SealanceMerkleTree {
+    static hasher = new Poseidon4();
+    /**
+    * Converts an Aleo blockchain address to a field element.
+    *
+    * This function decodes a bech32m-encoded Aleo address and converts it to a field element
+    * represented as a BigInt. The address format follows the Aleo protocol specification,
+    * starting with the prefix "aleo1" followed by encoded data.
+    *
+    * @param address - The Aleo blockchain address (e.g., "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px")
+    * @returns A BigInt representing the field element.
+    * @throws Error if the address is invalid or cannot be decoded.
+    *
+    * @example
+    * ```typescript
+    * const address = "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px";
+    * const fieldValue = convertAddressToField(address);
+    * console.log(fieldValue); // 123456789...n
+    * ```
+    */
+    convertAddressToField(address) {
+        const { words } = bech32m.decode(address);
+        const bytes = bech32m.fromWords(words);
+        // Convert bytes to BigInt (little-endian)
+        let fieldValue = BigInt(0);
+        for (let i = 0; i < bytes.length; i++) {
+            fieldValue |= BigInt(bytes[i]) << BigInt(i * 8);
+        }
+        return fieldValue;
+    }
+    /**
+    * Hashes two elements using Poseidon4 hash function
+    * @param prefix - Prefix for the hash (e.g., "0field" for nodes, "1field" for leaves)
+    * @param el1 - First element to hash
+    * @param el2 - Second element to hash
+    * @returns The hash result as a Field
+    * @throws {Error} If inputs are empty or invalid
+    */
+    hashTwoElements(prefix, el1, el2) {
+        if (!el1 || !el2) {
+            throw new Error("Invalid inputs: elements cannot be empty");
+        }
+        const fields = [Field.fromString(prefix), Field.fromString(el1), Field.fromString(el2)];
+        const arrayPlaintext = Plaintext.fromString(`[${fields.map(f => f.toString()).join(",")}]`);
+        return SealanceMerkleTree.hasher.hash(arrayPlaintext.toFields());
+    }
+    /**
+    * Builds a Merkle tree from given leaves. The tree is built bottom-up, hashing pairs of elements at each level.
+    *
+    * @param leaves - Array of leaf elements (must have even number of elements).
+    * @returns Array representing the complete Merkle tree as BigInts.
+    * @throws {Error} If leaves array is empty or has odd number of elements.
+    *
+    * @example
+    * ```typescript
+    * const leaves = ["0field", "1field", "2field", "3field"];
+    * const tree = buildTree(leaves);
+    * const root = tree[tree.length - 1]; // Get the Merkle root
+    * ```
+    */
+    buildTree(leaves) {
+        if (leaves.length === 0) {
+            throw new Error("Leaves array cannot be empty");
+        }
+        if (leaves.length % 2 !== 0) {
+            throw new Error("Leaves array must have even number of elements");
+        }
+        let currentLevel = leaves;
+        let tree = [...currentLevel];
+        let levelSize = currentLevel.length;
+        while (levelSize > 1) {
+            const nextLevel = [];
+            for (let i = 0; i < levelSize; i += 2) {
+                const left = currentLevel[i];
+                const right = currentLevel[i + 1];
+                const prefix = leaves.length === levelSize ? "1field" : "0field";
+                const hash = this.hashTwoElements(prefix, left, right);
+                nextLevel.push(hash.toString());
+            }
+            tree = [...tree, ...nextLevel];
+            currentLevel = nextLevel;
+            levelSize = currentLevel.length;
+        }
+        return tree.map(element => BigInt(element.slice(0, element.length - "field".length)));
+    }
+    /**
+    * Converts Aleo addresses to field elements, sorts them, pads with zero fields, and returns an array. This prepares addresses for Merkle tree construction.
+    *
+    * @param addresses - Array of Aleo addresses.
+    * @param maxTreeDepth - Maximum depth of the Merkle tree (default: 15).
+    * @returns Array of field elements ready for Merkle tree construction.
+    * @throws {Error} If the number of addresses exceeds the maximum capacity.
+    *
+    * @example
+    * ```typescript
+    * const addresses = [
+    *   "aleo1...",
+    *   "aleo1..."
+    * ];
+    * const leaves = generateLeaves(addresses, 15);
+    * const tree = buildTree(leaves);
+    * ```
+    */
+    generateLeaves(addresses, maxTreeDepth = 15) {
+        const maxNumLeaves = Math.floor(2 ** (maxTreeDepth - 1));
+        // Filter out zero addresses
+        addresses = addresses.filter(addr => addr !== ZERO_ADDRESS);
+        let numLeaves = 0;
+        if (addresses.length === 0 || addresses.length === 1) {
+            numLeaves = 2;
+        }
+        else {
+            numLeaves = Math.pow(2, Math.ceil(Math.log2(addresses.length)));
+        }
+        if (addresses.length > maxNumLeaves) {
+            throw new Error(`Leaves limit exceeded. Max: ${maxNumLeaves}, provided: ${addresses.length}`);
+        }
+        // Convert addresses to fields
+        const addressFields = addresses.map(addr => ({
+            address: addr,
+            field: this.convertAddressToField(addr),
+        }));
+        // Sort by field value
+        const sortedFields = addressFields.sort((a, b) => (a.field < b.field ? -1 : 1)).map(item => item.field);
+        // Convert to field strings
+        const sortedFieldElements = sortedFields.map(field => field.toString() + "field");
+        // Pad with zeros to reach power of 2
+        const fullTree = Array(Math.max(numLeaves - sortedFieldElements.length, 0)).fill("0field");
+        return fullTree.concat(sortedFieldElements);
+    }
+    /**
+    * Finds the leaf indices for non-inclusion proof of an address and returns the indices of the two adjacent leaves that surround the target address.
+    *
+    * @param merkleTree - The complete Merkle tree as array of BigInts.
+    * @param address - The Aleo address for which to find indices.
+    * @returns Tuple of [leftLeafIndex, rightLeafIndex].
+    *
+    * @example
+    * ```typescript
+    * const tree = buildTree(leaves);
+    * const [leftIdx, rightIdx] = getLeafIndices(tree, "aleo1...");
+    * ```
+    */
+    getLeafIndices(merkleTree, address) {
+        const num_leaves = Math.floor((merkleTree.length + 1) / 2);
+        const addressBigInt = this.convertAddressToField(address);
+        const leaves = merkleTree.slice(0, num_leaves);
+        let rightLeafIndex = leaves.findIndex((leaf) => addressBigInt <= leaf);
+        let leftLeafIndex = rightLeafIndex - 1;
+        if (rightLeafIndex === -1) {
+            rightLeafIndex = leaves.length - 1;
+            leftLeafIndex = leaves.length - 1;
+        }
+        if (rightLeafIndex === 0) {
+            leftLeafIndex = 0;
+        }
+        return [leftLeafIndex, rightLeafIndex];
+    }
+    /**
+    * Generates the sibling path (Merkle proof) for a given leaf index
+    *
+    * @param tree - The complete Merkle tree.
+    * @param leafIndex - Index of the leaf for which to generate the proof.
+    * @param depth - Maximum depth of the tree.
+    * @returns Object containing siblings array and leaf_index.
+    *
+    * @example
+    * ```typescript
+    * const tree = buildTree(leaves);
+    * const proof = getSiblingPath(tree, 0, 15);
+    * // proof = { siblings: [0n, 1n, ...], leaf_index: 0 }
+    * ```
+    */
+    getSiblingPath(tree, leafIndex, depth) {
+        let num_leaves = Math.floor((tree.length + 1) / 2);
+        const siblingPath = [];
+        let index = leafIndex;
+        let parentIndex = num_leaves;
+        siblingPath.push(tree[index]);
+        let level = 1;
+        while (parentIndex < tree.length) {
+            let siblingIndex = index % 2 === 0 ? index + 1 : index - 1; // Get the sibling index
+            siblingPath.push(tree[siblingIndex]);
+            index = parentIndex + Math.floor(leafIndex / 2 ** level); // Move up to the parent node
+            parentIndex += Math.floor(num_leaves / 2 ** level); // Halve the number of nodes for the next level
+            level++;
+        }
+        while (level < depth) {
+            siblingPath.push(0n);
+            level++;
+        }
+        return { siblings: siblingPath, leaf_index: leafIndex };
+    }
+}
+
 /**
  * The ProgramManager class is used to execute and deploy programs on the Aleo network and create value transfers.
  */
@@ -3976,6 +4197,132 @@ class ProgramManager {
         // Build an execution transaction
         return await ProgramManager$1.buildExecutionTransaction(executionPrivateKey, program, functionName, inputs, priorityFee, feeRecord, this.host, imports, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, offlineQuery, edition);
     }
+    /**
+     * Builds an execution transaction for submission to the Aleo network from an Authorization and Fee Authorization.
+     * This method is helpful if signing and authorization needs to be done in a secure environment separate from where
+     * transactions are built.
+     *
+     * @param {ExecuteAuthorizationOptions} options - The options for executing the authorizations.
+     * @returns {Promise<Transaction>} - A promise that resolves to the transaction or an error.
+     *
+     * @example
+     * /// Import the mainnet version of the sdk.
+     * import { AleoKeyProvider, ProgramManager, NetworkRecordProvider } from "@provablehq/sdk/mainnet.js";
+     *
+     * // Create a new NetworkClient, KeyProvider, and RecordProvider.
+     * const keyProvider = new AleoKeyProvider();
+     * keyProvider.useCache(true);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for executions
+     * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider);
+     *
+     * // Build the `Authorization`.
+     * const authorization = await programManager.buildAuthorization({
+     *   programName: "credits.aleo",
+     *   functionName: "transfer_public",
+     *   inputs: [
+     *     "aleo1vwls2ete8dk8uu2kmkmzumd7q38fvshrht8hlc0a5362uq8ftgyqnm3w08",
+     *     "10000000u64",
+     *   ],
+     * });
+     *
+     * // Derive the execution ID and base fee.
+     * const executionId = authorization.toExecutionId().toString();
+     *
+     * // Get the base fee in microcredits.
+     * const baseFeeMicrocredits = ProgramManager.estimateFeeForAuthorization(authorization, "credits.aleo");
+     * const baseFeeCredits = baseFeeMicrocredits/1000000;
+     *
+     * // Build a credits.aleo/fee_public `Authorization`.
+     * const feeAuthorization = await programManager.buildFeeAuthorization({
+     *   deploymentOrExecutionId: executionId,
+     *   baseFeeCredits,
+     * });
+     *
+     * // Build and execute the transaction
+     * const tx = await programManager.buildTransactionFromAuthorization({
+     *   programName: "hello_hello.aleo",
+     *   authorization,
+     *   feeAuthorization,
+     * });
+     *
+     * // Submit the transaction to the network
+     * await programManager.networkClient.submitTransaction(tx.toString());
+     *
+     * // Verify the transaction was successful
+     * setTimeout(async () => {
+     *  const transaction = await programManager.networkClient.getTransaction(tx.id());
+     *  assert(transaction.id() === tx.id());
+     * }, 10000);
+     */
+    async buildTransactionFromAuthorization(options) {
+        // Destructure the options object to access the parameters.
+        const { programName, authorization, } = options;
+        const feeAuthorization = options.feeAuthorization;
+        const keySearchParams = options.keySearchParams;
+        const offlineQuery = options.offlineQuery;
+        let provingKey = options.provingKey;
+        let verifyingKey = options.verifyingKey;
+        let program = options.program;
+        let imports = options.imports;
+        // Ensure the function exists on the network.
+        if (program === undefined) {
+            try {
+                program = (await this.networkClient.getProgram(programName));
+            }
+            catch (e) {
+                logAndThrow(`Error finding ${programName}. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network the program is deployed to the network.`);
+            }
+        }
+        else if (program instanceof Program) {
+            program = program.toString();
+        }
+        // Get the fee proving and verifying keys from the key provider.
+        let feeKeys;
+        const privateFee = feeAuthorization ? feeAuthorization.isFeePrivate() : false;
+        try {
+            feeKeys = privateFee
+                ? await this.keyProvider.feePrivateKeys()
+                : await this.keyProvider.feePublicKeys();
+        }
+        catch (e) {
+            logAndThrow(`Error finding fee keys. Key finder response: '${e.message}'. Please ensure your key provider is configured correctly.`);
+        }
+        const [feeProvingKey, feeVerifyingKey] = feeKeys;
+        // If the function proving and verifying keys are not provided, attempt to find them using the key provider.
+        if (!provingKey || !verifyingKey) {
+            try {
+                [provingKey, verifyingKey] = (await this.keyProvider.functionKeys(keySearchParams));
+            }
+            catch (e) {
+                console.log(`Function keys not found. Key finder response: '${e}'. The function keys will be synthesized`);
+            }
+        }
+        // Resolve the program imports if they exist.
+        const numberOfImports = Program.fromString(program).getImports().length;
+        if (numberOfImports > 0 && !imports) {
+            try {
+                imports = (await this.networkClient.getProgramImports(programName));
+            }
+            catch (e) {
+                logAndThrow(`Error finding program imports. Network response: '${e.message}'. Please ensure you're connected to a valid Aleo network and the program is deployed to the network.`);
+            }
+        }
+        // If the offline query exists, add the inclusion key.
+        if (offlineQuery && !this.inclusionKeysLoaded) {
+            try {
+                const inclusionKeys = await this.keyProvider.inclusionKeys();
+                ProgramManager$1.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 from the authorization.
+        return await ProgramManager$1.executeAuthorization(authorization, feeAuthorization, program, provingKey, verifyingKey, feeProvingKey, feeVerifyingKey, imports, this.host, offlineQuery);
+    }
     /**
      * Builds a SnarkVM `Authorization` for a specific function.
      *
@@ -4258,14 +4605,14 @@ class ProgramManager {
      * const programManager = new ProgramManager("https://api.explorer.provable.com/v1", keyProvider, recordProvider);
      *
      * // Build a credits.aleo/fee_public `Authorization`.
-     * const feePublicAuthorization = await programManager.authorizeFee({
+     * const feePublicAuthorization = await programManager.buildFeeAuthorization({
      *   deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
      *   baseFeeCredits: 0.1,
      * });
      *
      * // Build a credits.aleo/fee_private `Authorization`.
      * const record = "{ owner: aleo1j7qxyunfldj2lp8hsvy7mw5k8zaqgjfyr72x2gh3x4ewgae8v5gscf5jh3.private, microcredits: 1500000000000000u64.private, _nonce: 3077450429259593211617823051143573281856129402760267155982965992208217472983group.public }";
-     * const feePrivateAuthorization = await programManager.authorizeFee({
+     * const feePrivateAuthorization = await programManager.buildFeeAuthorization({
      *   deploymentOrExecutionId: "2423957656946557501636078245035919227529640894159332581642187482178647335171field",
      *   baseFeeCredits: 0.1,
      *   feeRecord: record,
@@ -5454,5 +5801,5 @@ async function initializeWasm() {
     console.warn("initializeWasm is deprecated, you no longer need to use it");
 }
 
-export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoNetworkClient, BlockHeightSearch, CREDITS_PROGRAM_KEYS, KEY_STORE, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TO_PRIVATE_TRANSFER, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, ProgramManager, RECORD_DOMAIN, RecordScanner, VALID_TRANSFER_TYPES, initializeWasm, logAndThrow };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoNetworkClient, BlockHeightSearch, CREDITS_PROGRAM_KEYS, KEY_STORE, NetworkRecordProvider, OfflineKeyProvider, OfflineSearchParams, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TO_PRIVATE_TRANSFER, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, ProgramManager, RECORD_DOMAIN, RecordScanner, SealanceMerkleTree, VALID_TRANSFER_TYPES, initializeWasm, logAndThrow };
 //# sourceMappingURL=browser.js.map