@aztec/aztec.js 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/dest/utils/node.js

@@ -1,4 +1,6 @@
 import { retryUntil } from '@aztec/foundation/retry';
+import { SortedTxStatuses, TxStatus } from '@aztec/stdlib/tx';
+import { DefaultWaitOpts } from '../contract/wait_opts.js';
 export const waitForNode = async (node, logger)=>{
     await retryUntil(async ()=>{
         try {
@@ -6,10 +8,54 @@ export const waitForNode = async (node, logger)=>{
             await node.getNodeInfo();
             logger?.verbose('Contacted Aztec node');
             return true;
-        } catch (error) {
+        } catch  {
             logger?.verbose('Failed to contact Aztec Node');
         }
         return undefined;
     }, 'RPC Get Node Info');
 };
+/** Returns true if the receipt status is at least the desired status level. */ function hasReachedStatus(receipt, desiredStatus) {
+    return SortedTxStatuses.indexOf(receipt.status) >= SortedTxStatuses.indexOf(desiredStatus);
+}
+/**
+ * Waits for a transaction to be mined and returns its receipt.
+ * @param node - The Aztec node to query for transaction status
+ * @param txHash - The hash of the transaction to wait for
+ * @param opts - Optional configuration for waiting behavior
+ * @returns The transaction receipt
+ * @throws If the transaction fails and dontThrowOnRevert is not set
+ */ export async function waitForTx(node, txHash, opts) {
+    const startTime = Date.now();
+    const ignoreDroppedReceiptsFor = opts?.ignoreDroppedReceiptsFor ?? DefaultWaitOpts.ignoreDroppedReceiptsFor;
+    const waitForStatus = opts?.waitForStatus ?? TxStatus.CHECKPOINTED;
+    const receipt = await retryUntil(async ()=>{
+        const txReceipt = await node.getTxReceipt(txHash);
+        // If receipt is not yet available, try again
+        if (txReceipt.isPending()) {
+            return undefined;
+        }
+        // If the tx was "dropped", either return it or ignore based on timing.
+        // We can ignore it at first because the transaction may have been sent to node 1, and now we're asking node 2 for the receipt.
+        // If we don't allow a short grace period, we could incorrectly return a TxReceipt with status DROPPED.
+        if (txReceipt.isDropped()) {
+            const elapsedSeconds = (Date.now() - startTime) / 1000;
+            if (!ignoreDroppedReceiptsFor || elapsedSeconds > ignoreDroppedReceiptsFor) {
+                return txReceipt;
+            }
+            return undefined;
+        }
+        // Check if the receipt has reached the desired status level
+        if (!hasReachedStatus(txReceipt, waitForStatus)) {
+            return undefined;
+        }
+        return txReceipt;
+    }, 'isMined', opts?.timeout ?? DefaultWaitOpts.timeout, opts?.interval ?? DefaultWaitOpts.interval);
+    if (!receipt.isMined()) {
+        throw new Error(`Transaction ${txHash.toString()} was ${receipt.status}. Reason: ${receipt.error ?? 'unknown'}`);
+    }
+    if (!receipt.hasExecutionSucceeded() && !opts?.dontThrowOnRevert) {
+        throw new Error(`Transaction ${txHash.toString()} reverted: ${receipt.executionResult}. Reason: ${receipt.error ?? 'unknown'}`);
+    }
+    return receipt;
+}
 export { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';

package/dest/utils/pub_key.d.ts

@@ -1,4 +1,4 @@
-import type { GrumpkinScalar } from '@aztec/foundation/fields';
+import type { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 import type { PublicKey } from '@aztec/stdlib/keys';
 /**
  * Method for generating a public grumpkin key from a private key.
@@ -6,4 +6,4 @@ import type { PublicKey } from '@aztec/stdlib/keys';
  * @returns The generated public key.
  */
 export declare function generatePublicKey(privateKey: GrumpkinScalar): Promise<PublicKey>;
-//# sourceMappingURL=pub_key.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHViX2tleS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3B1Yl9rZXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQ7Ozs7R0FJRztBQUNILHdCQUFnQixpQkFBaUIsQ0FBQyxVQUFVLEVBQUUsY0FBYyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FFaEYifQ==

package/dest/utils/pub_key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pub_key.d.ts","sourceRoot":"","sources":["../../src/utils/pub_key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAGhF"}
+{"version":3,"file":"pub_key.d.ts","sourceRoot":"","sources":["../../src/utils/pub_key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CAEhF"}

package/dest/utils/pub_key.js

@@ -1,9 +1,8 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 /**
  * Method for generating a public grumpkin key from a private key.
  * @param privateKey - The private key.
  * @returns The generated public key.
  */ export function generatePublicKey(privateKey) {
-    const grumpkin = new Grumpkin();
-    return grumpkin.mul(grumpkin.generator(), privateKey);
+    return Grumpkin.mul(Grumpkin.generator, privateKey);
 }

package/dest/wallet/account_entrypoint_meta_payment_method.d.ts

@@ -0,0 +1,31 @@
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasSettings } from '@aztec/stdlib/gas';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+import type { Account } from '../account/account.js';
+import type { FeePaymentMethod } from '../fee/fee_payment_method.js';
+/**
+ * Fee payment method that allows an account contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */
+export declare class AccountEntrypointMetaPaymentMethod implements FeePaymentMethod {
+    private account;
+    private paymentMethod?;
+    private feeEntrypointOptions?;
+    constructor(account: Account, paymentMethod?: FeePaymentMethod | undefined, feeEntrypointOptions?: any);
+    getAsset(): Promise<AztecAddress>;
+    getExecutionPayload(): Promise<ExecutionPayload>;
+    getFeePayer(): Promise<AztecAddress>;
+    getGasSettings(): GasSettings | undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9lbnRyeXBvaW50X21ldGFfcGF5bWVudF9tZXRob2QuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YWxsZXQvYWNjb3VudF9lbnRyeXBvaW50X21ldGFfcGF5bWVudF9tZXRob2QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzNELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFckU7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxxQkFBYSxrQ0FBbUMsWUFBVyxnQkFBZ0I7SUFFdkUsT0FBTyxDQUFDLE9BQU87SUFDZixPQUFPLENBQUMsYUFBYSxDQUFDO0lBQ3RCLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQztJQUgvQixZQUNVLE9BQU8sRUFBRSxPQUFPLEVBQ2hCLGFBQWEsQ0FBQyw4QkFBa0IsRUFDaEMsb0JBQW9CLENBQUMsS0FBSyxFQUNoQztJQUVKLFFBQVEsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLENBRWhDO0lBRUssbUJBQW1CLElBQUksT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBNkJyRDtJQUVELFdBQVcsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLENBRW5DO0lBRUQsY0FBYyxJQUFJLFdBQVcsR0FBRyxTQUFTLENBRXhDO0NBQ0YifQ==

package/dest/wallet/account_entrypoint_meta_payment_method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_entrypoint_meta_payment_method.d.ts","sourceRoot":"","sources":["../../src/wallet/account_entrypoint_meta_payment_method.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kCAAmC,YAAW,gBAAgB;IAEvE,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,oBAAoB,CAAC;IAH/B,YACU,OAAO,EAAE,OAAO,EAChB,aAAa,CAAC,8BAAkB,EAChC,oBAAoB,CAAC,KAAK,EAChC;IAEJ,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC,CAEhC;IAEK,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CA6BrD;IAED,WAAW,IAAI,OAAO,CAAC,YAAY,CAAC,CAEnC;IAED,cAAc,IAAI,WAAW,GAAG,SAAS,CAExC;CACF"}

package/dest/wallet/account_entrypoint_meta_payment_method.js

@@ -0,0 +1,61 @@
+import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { ExecutionPayload } from '@aztec/stdlib/tx';
+/**
+ * Fee payment method that allows an account contract to pay for its own deployment
+ * It works by rerouting the provided fee payment method through the account's entrypoint,
+ * which sets itself as fee payer. If no payment method is provided, it is assumed the
+ * account will pay with its own fee juice balance.
+ *
+ * Usually, in order to pay fees it is necessary to obtain an ExecutionPayload that encodes the necessary information
+ * that is sent to the user's account entrypoint, that has plumbing to handle it.
+ * If there's no account contract yet (it's being deployed) a MultiCallContract is used, which doesn't have a concept of fees or
+ * how to handle this payload.
+ * HOWEVER, the account contract's entrypoint does, so this method reshapes that fee payload into a call to the account contract entrypoint
+ * being deployed with the original fee payload.
+ *
+ * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
+ */ export class AccountEntrypointMetaPaymentMethod {
+    account;
+    paymentMethod;
+    feeEntrypointOptions;
+    constructor(account, paymentMethod, feeEntrypointOptions){
+        this.account = account;
+        this.paymentMethod = paymentMethod;
+        this.feeEntrypointOptions = feeEntrypointOptions;
+    }
+    getAsset() {
+        return this.paymentMethod?.getAsset() ?? Promise.resolve(ProtocolContractAddress.FeeJuice);
+    }
+    async getExecutionPayload() {
+        // Get the execution payload for the fee
+        const innerPayload = await this.paymentMethod?.getExecutionPayload() ?? ExecutionPayload.empty();
+        // If no fee entrypoint options were provided, compute them based on the wrapped payment method
+        // This mimics how the actual account contract works when invoked directly:
+        // - If we are the fee payer, are there calls in the inner payload? In that case, those calls can
+        //   only be claiming fee juice, so we use FEE_JUICE_WITH_CLAIM
+        // - If we are the fee payer, but there are no calls, then we assume the account already has
+        //   fee juice and can pay directly with PREEXISTING_FEE_JUICE
+        // - If we are not the fee payer, then EXTERNAL is used
+        let options = this.feeEntrypointOptions;
+        if (!options) {
+            const feePayer = await this.paymentMethod?.getFeePayer() ?? this.account.getAddress();
+            const isFeePayer = feePayer.equals(this.account.getAddress());
+            let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
+            if (isFeePayer) {
+                accountFeePaymentMethodOptions = innerPayload.calls.length === 0 ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+            }
+            options = {
+                feePaymentMethodOptions: accountFeePaymentMethodOptions
+            };
+        }
+        // Use the generic wrapping mechanism from the account interface
+        return this.account.wrapExecutionPayload(innerPayload, options);
+    }
+    getFeePayer() {
+        return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
+    }
+    getGasSettings() {
+        return this.paymentMethod?.getGasSettings();
+    }
+}

package/dest/wallet/account_manager.d.ts

@@ -0,0 +1,63 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { AccountContract } from '../account/account_contract.js';
+import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
+import type { Salt } from '../account/index.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+import type { Wallet } from './wallet.js';
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */
+export declare class AccountManager {
+    private wallet;
+    private secretKey;
+    private accountContract;
+    private instance;
+    /**
+     * Contract instantiation salt for the account contract
+     */
+    readonly salt: Salt;
+    private constructor();
+    static create(wallet: Wallet, secretKey: Fr, accountContract: AccountContract, salt?: Salt): Promise<AccountManager>;
+    protected getPublicKeys(): import("@aztec/stdlib/keys").PublicKeys;
+    protected getPublicKeysHash(): Fr | Promise<Fr>;
+    /**
+     * Gets the calculated complete address associated with this account.
+     * Does not require the account to have been published for public execution.
+     * @returns The address, partial address, and encryption public key.
+     */
+    getCompleteAddress(): Promise<CompleteAddress>;
+    /**
+     * Returns the secret key used to derive the rest of the privacy keys for this contract
+     */
+    getSecretKey(): Fr;
+    get address(): import("@aztec/stdlib/aztec-address").AztecAddress;
+    /**
+     * Returns the contract instance definition associated with this account.
+     * Does not require the account to have been published for public execution.
+     * @returns ContractInstance instance.
+     */
+    getInstance(): ContractInstanceWithAddress;
+    /**
+     * Returns a Wallet instance associated with this account. Use it to create Contract
+     * instances to be interacted with from this account.
+     * @returns A Wallet instance.
+     */
+    getAccount(): Promise<AccountWithSecretKey>;
+    /**
+     * Returns the account contract that backs this account.
+     * @returns The account contract
+     */
+    getAccountContract(): AccountContract;
+    /**
+     * Returns a preconfigured deploy method that contains all the necessary function
+     * calls to deploy the account contract.
+     */
+    getDeployMethod(): Promise<DeployAccountMethod>;
+    /**
+     * Returns whether this account contract has an initializer function.
+     */
+    hasInitializer(): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2FjY291bnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLGVBQWUsRUFDZixLQUFLLDJCQUEyQixFQUVqQyxNQUFNLHdCQUF3QixDQUFDO0FBR2hDLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQzdFLE9BQU8sS0FBSyxFQUFFLElBQUksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRWhELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxQzs7O0dBR0c7QUFDSCxxQkFBYSxjQUFjO0lBRXZCLE9BQU8sQ0FBQyxNQUFNO0lBQ2QsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLGVBQWU7SUFDdkIsT0FBTyxDQUFDLFFBQVE7SUFDaEI7O09BRUc7YUFDYSxJQUFJLEVBQUUsSUFBSTtJQVI1QixPQUFPLGVBU0g7SUFFSixPQUFhLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxJQUFJLENBQUMsRUFBRSxJQUFJLDJCQWtCL0Y7SUFFRCxTQUFTLENBQUMsYUFBYSw0Q0FFdEI7SUFFRCxTQUFTLENBQUMsaUJBQWlCLHFCQUUxQjtJQUVEOzs7O09BSUc7SUFDSSxrQkFBa0IsSUFBSSxPQUFPLENBQUMsZUFBZSxDQUFDLENBRXBEO0lBRUQ7O09BRUc7SUFDSSxZQUFZLE9BRWxCO0lBRUQsSUFBSSxPQUFPLHVEQUVWO0lBRUQ7Ozs7T0FJRztJQUNJLFdBQVcsSUFBSSwyQkFBMkIsQ0FFaEQ7SUFFRDs7OztPQUlHO0lBQ1UsVUFBVSxJQUFJLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUl2RDtJQUVEOzs7T0FHRztJQUNILGtCQUFrQixJQUFJLGVBQWUsQ0FFcEM7SUFFRDs7O09BR0c7SUFDVSxlQUFlLElBQUksT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBMEIzRDtJQUVEOztPQUVHO0lBQ1UsY0FBYyxxQkFFMUI7Q0FDRiJ9

package/dest/wallet/account_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account_manager.d.ts","sourceRoot":"","sources":["../../src/wallet/account_manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,eAAe,EACf,KAAK,2BAA2B,EAEjC,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,qBAAa,cAAc;IAEvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ;IAChB;;OAEG;aACa,IAAI,EAAE,IAAI;IAR5B,OAAO,eASH;IAEJ,OAAa,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,eAAe,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,IAAI,2BAkB/F;IAED,SAAS,CAAC,aAAa,4CAEtB;IAED,SAAS,CAAC,iBAAiB,qBAE1B;IAED;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC,CAEpD;IAED;;OAEG;IACI,YAAY,OAElB;IAED,IAAI,OAAO,uDAEV;IAED;;;;OAIG;IACI,WAAW,IAAI,2BAA2B,CAEhD;IAED;;;;OAIG;IACU,UAAU,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAIvD;IAED;;;OAGG;IACH,kBAAkB,IAAI,eAAe,CAEpC;IAED;;;OAGG;IACU,eAAe,IAAI,OAAO,CAAC,mBAAmB,CAAC,CA0B3D;IAED;;OAEG;IACU,cAAc,qBAE1B;CACF"}

package/dest/wallet/account_manager.js

@@ -0,0 +1,107 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CompleteAddress, getContractInstanceFromInstantiationParams } from '@aztec/stdlib/contract';
+import { deriveKeys } from '@aztec/stdlib/keys';
+import { AccountWithSecretKey } from '../account/account_with_secret_key.js';
+import { Contract } from '../contract/contract.js';
+import { DeployAccountMethod } from './deploy_account_method.js';
+/**
+ * Manages a user account. Provides methods for calculating the account's address and other related data,
+ * plus a helper to return a preconfigured deploy method.
+ */ export class AccountManager {
+    wallet;
+    secretKey;
+    accountContract;
+    instance;
+    salt;
+    constructor(wallet, secretKey, accountContract, instance, /**
+     * Contract instantiation salt for the account contract
+     */ salt){
+        this.wallet = wallet;
+        this.secretKey = secretKey;
+        this.accountContract = accountContract;
+        this.instance = instance;
+        this.salt = salt;
+    }
+    static async create(wallet, secretKey, accountContract, salt) {
+        const { publicKeys } = await deriveKeys(secretKey);
+        salt = salt !== undefined ? new Fr(salt) : Fr.random();
+        const { constructorName, constructorArgs } = await accountContract.getInitializationFunctionAndArgs() ?? {
+            constructorName: undefined,
+            constructorArgs: undefined
+        };
+        const artifact = await accountContract.getContractArtifact();
+        const instance = await getContractInstanceFromInstantiationParams(artifact, {
+            constructorArtifact: constructorName,
+            constructorArgs,
+            salt: salt,
+            publicKeys
+        });
+        return new AccountManager(wallet, secretKey, accountContract, instance, salt);
+    }
+    getPublicKeys() {
+        return this.instance.publicKeys;
+    }
+    getPublicKeysHash() {
+        return this.getPublicKeys().hash();
+    }
+    /**
+   * Gets the calculated complete address associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns The address, partial address, and encryption public key.
+   */ getCompleteAddress() {
+        return CompleteAddress.fromSecretKeyAndInstance(this.secretKey, this.instance);
+    }
+    /**
+   * Returns the secret key used to derive the rest of the privacy keys for this contract
+   */ getSecretKey() {
+        return this.secretKey;
+    }
+    get address() {
+        return this.instance.address;
+    }
+    /**
+   * Returns the contract instance definition associated with this account.
+   * Does not require the account to have been published for public execution.
+   * @returns ContractInstance instance.
+   */ getInstance() {
+        return this.instance;
+    }
+    /**
+   * Returns a Wallet instance associated with this account. Use it to create Contract
+   * instances to be interacted with from this account.
+   * @returns A Wallet instance.
+   */ async getAccount() {
+        const completeAddress = await this.getCompleteAddress();
+        const account = this.accountContract.getAccount(completeAddress);
+        return new AccountWithSecretKey(account, this.secretKey, this.salt);
+    }
+    /**
+   * Returns the account contract that backs this account.
+   * @returns The account contract
+   */ getAccountContract() {
+        return this.accountContract;
+    }
+    /**
+   * Returns a preconfigured deploy method that contains all the necessary function
+   * calls to deploy the account contract.
+   */ async getDeployMethod() {
+        const artifact = await this.accountContract.getContractArtifact();
+        if (!await this.hasInitializer()) {
+            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/15576):
+            // there should be a path which enables an account contract's class & instance to be published,
+            // even if the account contract doesn't have an initializer function. This should not throw.
+            throw new Error(`Account contract ${artifact.name} does not have an initializer function to call.`);
+        }
+        const { constructorName, constructorArgs } = await this.accountContract.getInitializationFunctionAndArgs() ?? {
+            constructorName: undefined,
+            constructorArgs: undefined
+        };
+        const account = await this.getAccount();
+        return new DeployAccountMethod(this.getPublicKeys(), this.wallet, artifact, (instance)=>Contract.at(instance.address, artifact, this.wallet), new Fr(this.salt), account, constructorArgs, constructorName);
+    }
+    /**
+   * Returns whether this account contract has an initializer function.
+   */ async hasInitializer() {
+        return await this.accountContract.getInitializationFunctionAndArgs() !== undefined;
+    }
+}