@aztec/aztec.js 0.0.1-commit.6d3c34e → 0.0.1-commit.733c4a3

package/dest/wallet/account_entrypoint_meta_payment_method.js

@@ -1,7 +1,5 @@
 import { AccountFeePaymentMethodOptions } from '@aztec/entrypoints/account';
-import { EncodedAppEntrypointCalls } from '@aztec/entrypoints/encoding';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { FunctionCall, FunctionSelector, encodeArguments, getFunctionArtifactByName } from '@aztec/stdlib/abi';
 import { ExecutionPayload } from '@aztec/stdlib/tx';
 /**
  * Fee payment method that allows an account contract to pay for its own deployment
@@ -18,57 +16,44 @@ import { ExecutionPayload } from '@aztec/stdlib/tx';
  *
  * This class can be seen in action in DeployAccountMethod.ts#getSelfPaymentMethod
  */ export class AccountEntrypointMetaPaymentMethod {
-    wallet;
-    artifact;
-    feePaymentNameOrArtifact;
-    accountAddress;
+    account;
     paymentMethod;
-    constructor(wallet, artifact, feePaymentNameOrArtifact, accountAddress, paymentMethod){
-        this.wallet = wallet;
-        this.artifact = artifact;
-        this.feePaymentNameOrArtifact = feePaymentNameOrArtifact;
-        this.accountAddress = accountAddress;
+    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, it includes the calls and potentially authWitnesses
-        // It can be empty because the account might attempt to pay for the tx fee using its own
-        // FeeJuice balance
-        const { calls: feeCalls, authWitnesses: feeAuthwitnesses } = await this.paymentMethod?.getExecutionPayload() ?? ExecutionPayload.empty();
-        // Encode the calls for the fee
-        const feePayer = await this.paymentMethod?.getFeePayer() ?? this.accountAddress;
-        const isFeePayer = feePayer.equals(this.accountAddress);
-        let accountFeePaymentMethodOptions = AccountFeePaymentMethodOptions.EXTERNAL;
-        if (isFeePayer) {
-            // If the account is the fee payer, and the incoming fee payload has calls
-            // it can only be FeeJuicePaymentMethodWithClaim
-            // If the payload has no calls, it's paying using
-            // its own fee juice balance
-            accountFeePaymentMethodOptions = feeCalls.length === 0 ? AccountFeePaymentMethodOptions.PREEXISTING_FEE_JUICE : AccountFeePaymentMethodOptions.FEE_JUICE_WITH_CLAIM;
+        // 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
+            };
         }
-        const feeEncodedCalls = await EncodedAppEntrypointCalls.create(feeCalls);
-        // Get the entrypoint args
-        const args = [
-            feeEncodedCalls,
-            accountFeePaymentMethodOptions,
-            false
-        ];
-        const feePaymentArtifact = typeof this.feePaymentNameOrArtifact === 'string' ? getFunctionArtifactByName(this.artifact, this.feePaymentNameOrArtifact) : this.feePaymentNameOrArtifact;
-        const entrypointCall = new FunctionCall(feePaymentArtifact.name, this.accountAddress, await FunctionSelector.fromNameAndParameters(feePaymentArtifact.name, feePaymentArtifact.parameters), feePaymentArtifact.functionType, false, feePaymentArtifact.isStatic, encodeArguments(feePaymentArtifact, args), feePaymentArtifact.returnTypes);
-        // Compute the authwitness required to verify the combined payload
-        const payloadAuthWitness = await this.wallet.createAuthWit(this.accountAddress, await feeEncodedCalls.hash());
-        return new ExecutionPayload([
-            entrypointCall
-        ], [
-            payloadAuthWitness,
-            ...feeAuthwitnesses
-        ], [], feeEncodedCalls.hashedArguments, feePayer);
+        // Use the generic wrapping mechanism from the account interface
+        return this.account.wrapExecutionPayload(innerPayload, options);
     }
     getFeePayer() {
-        return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.accountAddress);
+        return this.paymentMethod?.getFeePayer() ?? Promise.resolve(this.account.getAddress());
     }
     getGasSettings() {
         return this.paymentMethod?.getGasSettings();

package/dest/wallet/account_manager.d.ts

@@ -3,7 +3,6 @@ import { CompleteAddress, type ContractInstanceWithAddress } from '@aztec/stdlib
 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 type { AccountInterface } from '../account/interface.js';
 import { DeployAccountMethod } from './deploy_account_method.js';
 import type { Wallet } from './wallet.js';
 /**
@@ -15,16 +14,14 @@ export declare class AccountManager {
     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>;
-    /**
-     * Returns the entrypoint for this account as defined by its account contract.
-     * @returns An entrypoint.
-     */
-    getAccountInterface(): Promise<AccountInterface>;
     /**
      * Gets the calculated complete address associated with this account.
      * Does not require the account to have been published for public execution.
@@ -35,7 +32,7 @@ export declare class AccountManager {
      * Returns the secret key used to derive the rest of the privacy keys for this contract
      */
     getSecretKey(): Fr;
-    get address(): import("../api/addresses.js").AztecAddress;
+    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.
@@ -63,4 +60,4 @@ export declare class AccountManager {
      */
     hasInitializer(): Promise<boolean>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2FjY291bnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLGVBQWUsRUFDZixLQUFLLDJCQUEyQixFQUVqQyxNQUFNLHdCQUF3QixDQUFDO0FBR2hDLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQzdFLE9BQU8sS0FBSyxFQUFFLElBQUksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFaEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRTFDOzs7R0FHRztBQUNILHFCQUFhLGNBQWM7SUFFdkIsT0FBTyxDQUFDLE1BQU07SUFDZCxPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsZUFBZTtJQUN2QixPQUFPLENBQUMsUUFBUTthQUlBLElBQUksRUFBRSxJQUFJO0lBUjVCLE9BQU8sZUFTSDtJQUVKLE9BQWEsTUFBTSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLElBQUksQ0FBQyxFQUFFLElBQUksMkJBa0IvRjtJQUVELFNBQVMsQ0FBQyxhQUFhLDRDQUV0QjtJQUVELFNBQVMsQ0FBQyxpQkFBaUIscUJBRTFCO0lBRUQ7OztPQUdHO0lBQ1UsbUJBQW1CLElBQUksT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBSTVEO0lBRUQ7Ozs7T0FJRztJQUNJLGtCQUFrQixJQUFJLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FFcEQ7SUFFRDs7T0FFRztJQUNJLFlBQVksT0FFbEI7SUFFRCxJQUFJLE9BQU8sK0NBRVY7SUFFRDs7OztPQUlHO0lBQ0ksV0FBVyxJQUFJLDJCQUEyQixDQUVoRDtJQUVEOzs7O09BSUc7SUFDVSxVQUFVLElBQUksT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBR3ZEO0lBRUQ7OztPQUdHO0lBQ0gsa0JBQWtCLElBQUksZUFBZSxDQUVwQztJQUVEOzs7T0FHRztJQUNVLGVBQWUsSUFBSSxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0F3QjNEO0lBRUQ7O09BRUc7SUFDVSxjQUFjLHFCQUUxQjtDQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2FjY291bnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLGVBQWUsRUFDZixLQUFLLDJCQUEyQixFQUVqQyxNQUFNLHdCQUF3QixDQUFDO0FBR2hDLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQzdFLE9BQU8sS0FBSyxFQUFFLElBQUksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRWhELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxQzs7O0dBR0c7QUFDSCxxQkFBYSxjQUFjO0lBRXZCLE9BQU8sQ0FBQyxNQUFNO0lBQ2QsT0FBTyxDQUFDLFNBQVM7SUFDakIsT0FBTyxDQUFDLGVBQWU7SUFDdkIsT0FBTyxDQUFDLFFBQVE7SUFDaEI7O09BRUc7YUFDYSxJQUFJLEVBQUUsSUFBSTtJQVI1QixPQUFPLGVBU0g7SUFFSixPQUFhLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxFQUFFLEVBQUUsZUFBZSxFQUFFLGVBQWUsRUFBRSxJQUFJLENBQUMsRUFBRSxJQUFJLDJCQWtCL0Y7SUFFRCxTQUFTLENBQUMsYUFBYSw0Q0FFdEI7SUFFRCxTQUFTLENBQUMsaUJBQWlCLHFCQUUxQjtJQUVEOzs7O09BSUc7SUFDSSxrQkFBa0IsSUFBSSxPQUFPLENBQUMsZUFBZSxDQUFDLENBRXBEO0lBRUQ7O09BRUc7SUFDSSxZQUFZLE9BRWxCO0lBRUQsSUFBSSxPQUFPLHVEQUVWO0lBRUQ7Ozs7T0FJRztJQUNJLFdBQVcsSUFBSSwyQkFBMkIsQ0FFaEQ7SUFFRDs7OztPQUlHO0lBQ1UsVUFBVSxJQUFJLE9BQU8sQ0FBQyxvQkFBb0IsQ0FBQyxDQUl2RDtJQUVEOzs7T0FHRztJQUNILGtCQUFrQixJQUFJLGVBQWUsQ0FFcEM7SUFFRDs7O09BR0c7SUFDVSxlQUFlLElBQUksT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBMEIzRDtJQUVEOztPQUVHO0lBQ1UsY0FBYyxxQkFFMUI7Q0FDRiJ9

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

@@ -1 +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;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,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;aAIA,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;;;OAGG;IACU,mBAAmB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAI5D;IAED;;;;OAIG;IACI,kBAAkB,IAAI,OAAO,CAAC,eAAe,CAAC,CAEpD;IAED;;OAEG;IACI,YAAY,OAElB;IAED,IAAI,OAAO,+CAEV;IAED;;;;OAIG;IACI,WAAW,IAAI,2BAA2B,CAEhD;IAED;;;;OAIG;IACU,UAAU,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAGvD;IAED;;;OAGG;IACH,kBAAkB,IAAI,eAAe,CAEpC;IAED;;;OAGG;IACU,eAAe,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAwB3D;IAED;;OAEG;IACU,cAAc,qBAE1B;CACF"}
+{"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

@@ -45,14 +45,6 @@ import { DeployAccountMethod } from './deploy_account_method.js';
         return this.getPublicKeys().hash();
     }
     /**
-   * Returns the entrypoint for this account as defined by its account contract.
-   * @returns An entrypoint.
-   */ async getAccountInterface() {
-        const chainInfo = await this.wallet.getChainInfo();
-        const completeAddress = await this.getCompleteAddress();
-        return this.accountContract.getInterface(completeAddress, chainInfo);
-    }
-    /**
    * 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.
@@ -79,8 +71,9 @@ import { DeployAccountMethod } from './deploy_account_method.js';
    * instances to be interacted with from this account.
    * @returns A Wallet instance.
    */ async getAccount() {
-        const accountInterface = await this.getAccountInterface();
-        return new AccountWithSecretKey(accountInterface, this.secretKey, this.salt);
+        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.
@@ -103,7 +96,8 @@ import { DeployAccountMethod } from './deploy_account_method.js';
             constructorName: undefined,
             constructorArgs: undefined
         };
-        return new DeployAccountMethod(this.getPublicKeys(), this.wallet, artifact, (instance)=>Contract.at(instance.address, artifact, this.wallet), new Fr(this.salt), constructorArgs, constructorName);
+        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.

package/dest/wallet/capabilities.d.ts

@@ -0,0 +1,452 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Aliased } from './wallet.js';
+/**
+ * Current capability manifest version.
+ */
+export declare const CAPABILITY_VERSION: "1.0";
+/**
+ * Pattern for matching contract functions with wildcards.
+ *
+ * Used in simulation and transaction capabilities to specify which
+ * contract functions are allowed.
+ *
+ * @example
+ * // Allow any function on a specific contract
+ * \{ contract: ammAddress, function: '*' \}
+ *
+ * @example
+ * // Allow only 'swap' function on a specific contract
+ * \{ contract: ammAddress, function: 'swap' \}
+ *
+ * @example
+ * // Allow 'transfer' on any contract
+ * \{ contract: '*', function: 'transfer' \}
+ */
+export interface ContractFunctionPattern {
+    /** Contract address or '*' for any contract */
+    contract: AztecAddress | '*';
+    /** Function name or '*' for any function */
+    function: string;
+    /**
+     * Additional addresses whose private state and keys are accessible
+     * when calling this function, beyond the sender's.
+     * - undefined: No additional scopes allowed
+     * - AztecAddress[]: Only these specific addresses allowed as additional scopes
+     * - '*': All known address allowed as an additional scope
+     */
+    additionalScopes?: AztecAddress[] | '*';
+}
+/**
+ * Account access capability - grants access to user accounts.
+ *
+ * Maps to wallet methods:
+ * - getAccounts (when canGet: true)
+ * - createAuthWit (when canCreateAuthWit: true)
+ *
+ * The wallet decides which accounts to reveal to the app.
+ * Apps don't specify which accounts they want - they just request
+ * the capability and the wallet shows them the available accounts.
+ */
+export interface AccountsCapability {
+    /** Discriminator for capability type */
+    type: 'accounts';
+    /** Can get accounts from wallet. Maps to: getAccounts */
+    canGet?: boolean;
+    /** Can create auth witnesses for accounts. Maps to: createAuthWit */
+    canCreateAuthWit?: boolean;
+}
+/**
+ * Granted account access capability.
+ *
+ * Extends the request with specific accounts that were granted by the wallet.
+ */
+export interface GrantedAccountsCapability extends AccountsCapability {
+    /** Specific accounts granted by the wallet with their aliases. The wallet adds this when granting the capability. */
+    accounts: Aliased<AztecAddress>[];
+}
+/**
+ * Contract interaction capability - for registering and querying contracts.
+ *
+ * Maps to wallet methods:
+ * - registerContract (when canRegister: true)
+ * - getContractMetadata (when canGetMetadata: true)
+ *
+ * Matching is done by contract address, not class ID. This allows updating
+ * existing contracts with new artifacts (e.g., when contract is upgraded
+ * to a new contractClassId on-chain).
+ *
+ * Note: For querying contract class metadata, use ContractClassesCapability instead.
+ *
+ * @example
+ * // Register and query specific contracts
+ * \{
+ *   type: 'contracts',
+ *   contracts: [ammAddress, tokenAddress],
+ *   canRegister: true,
+ *   canGetMetadata: true
+ * \}
+ *
+ * @example
+ * // Query any contract (read-only)
+ * \{
+ *   type: 'contracts',
+ *   contracts: '*',
+ *   canGetMetadata: true
+ * \}
+ */
+export interface ContractsCapability {
+    /** Discriminator for capability type */
+    type: 'contracts';
+    /**
+     * Which contracts this applies to:
+     * - '*': Any contract address
+     * - AztecAddress[]: Specific contract addresses
+     */
+    contracts: '*' | AztecAddress[];
+    /**
+     * Can register contracts and update existing registrations.
+     * Maps to: registerContract
+     *
+     * When true, allows:
+     * - Registering new contract instances at specified addresses
+     * - Re-registering existing contracts with updated artifacts (e.g., after upgrade)
+     */
+    canRegister?: boolean;
+    /** Can query contract metadata. Maps to: getContractMetadata */
+    canGetMetadata?: boolean;
+}
+/**
+ * Granted contract interaction capability.
+ *
+ * The wallet may reduce the scope (e.g., from '*' to specific addresses).
+ */
+export interface GrantedContractsCapability extends ContractsCapability {
+}
+/**
+ * Contract class capability - for querying contract class metadata.
+ *
+ * Maps to wallet methods:
+ * - getContractClassMetadata
+ *
+ * Contract classes are identified by their class ID (Fr), not by contract address.
+ * Multiple contract instances can share the same class. This capability grants
+ * permission to query metadata for specific contract classes.
+ *
+ * Apps typically acquire this permission automatically when registering a contract
+ * with an artifact (the wallet auto-grants permission for that contract's class ID).
+ *
+ * @example
+ * // Query specific contract classes
+ * \{
+ *   type: 'contractClasses',
+ *   classes: [classId1, classId2],
+ *   canGetMetadata: true
+ * \}
+ *
+ * @example
+ * // Query any contract class (wildcard)
+ * \{
+ *   type: 'contractClasses',
+ *   classes: '*',
+ *   canGetMetadata: true
+ * \}
+ */
+export interface ContractClassesCapability {
+    /** Discriminator for capability type */
+    type: 'contractClasses';
+    /**
+     * Which contract classes this applies to:
+     * - '*': Any contract class ID
+     * - Fr[]: Specific contract class IDs
+     */
+    classes: '*' | Fr[];
+    /** Can query contract class metadata. Maps to: getContractClassMetadata */
+    canGetMetadata: boolean;
+}
+/**
+ * Granted contract class capability.
+ *
+ * The wallet may reduce the scope (e.g., from '*' to specific class IDs).
+ */
+export interface GrantedContractClassesCapability extends ContractClassesCapability {
+}
+/**
+ * Transaction simulation capability - for simulating transactions and executing utilities.
+ *
+ * Maps to wallet methods:
+ * - simulateTx (when transactions scope specified)
+ * - executeUtility (when utilities scope specified)
+ * - profileTx (when transactions scope specified)
+ *
+ * @example
+ * // Simulate any transaction on specific contracts
+ * \{
+ *   type: 'simulation',
+ *   transactions: \{
+ *     scope: [
+ *       \{ contract: ammAddress, function: '*' \},
+ *       \{ contract: tokenAddress, function: 'transfer' \}
+ *     ]
+ *   \}
+ * \}
+ *
+ * @example
+ * // Simulate any transaction and execute any utility call
+ * \{
+ *   type: 'simulation',
+ *   transactions: \{ scope: '*' \},
+ *   utilities: \{ scope: '*' \}
+ * \}
+ */
+export interface SimulationCapability {
+    /** Discriminator for capability type */
+    type: 'simulation';
+    /** Transaction simulation scope. Maps to: simulateTx, profileTx */
+    transactions?: {
+        /**
+         * Which contracts/functions to allow:
+         * - '*': Any transaction
+         * - ContractFunctionPattern[]: Specific contract functions
+         */
+        scope: '*' | ContractFunctionPattern[];
+    };
+    /** Utility execution scope (unconstrained calls). Maps to: executeUtility */
+    utilities?: {
+        /**
+         * Which contracts/functions to allow:
+         * - '*': Any utility call
+         * - ContractFunctionPattern[]: Specific contract functions
+         */
+        scope: '*' | ContractFunctionPattern[];
+    };
+}
+/**
+ * Granted transaction simulation capability.
+ *
+ * The wallet may reduce the scope (e.g., from '*' to specific patterns).
+ */
+export interface GrantedSimulationCapability extends SimulationCapability {
+}
+/**
+ * Transaction execution capability - for sending transactions.
+ *
+ * Maps to wallet methods:
+ * - sendTx
+ *
+ * Policy enforcement (rate limits, spending limits) should be handled
+ * at the contract level in Aztec, not at the wallet level.
+ *
+ * @example
+ * // Send specific transactions with approval
+ * \{
+ *   type: 'transaction',
+ *   scope: [
+ *     \{ contract: ammAddress, function: 'swap' \},
+ *     \{ contract: ammAddress, function: 'addLiquidity' \}
+ *   ]
+ * \}
+ *
+ * @example
+ * // Send any transaction
+ * \{
+ *   type: 'transaction',
+ *   scope: '*'
+ * \}
+ */
+export interface TransactionCapability {
+    /** Discriminator for capability type */
+    type: 'transaction';
+    /**
+     * Which contracts/functions to allow:
+     * - '*': Any transaction
+     * - ContractFunctionPattern[]: Specific patterns
+     */
+    scope: '*' | ContractFunctionPattern[];
+}
+/**
+ * Granted transaction execution capability.
+ *
+ * The wallet may reduce the scope (e.g., from '*' to specific patterns).
+ */
+export interface GrantedTransactionCapability extends TransactionCapability {
+}
+/**
+ * Data access capability - for querying private data.
+ *
+ * Maps to wallet methods:
+ * - getAddressBook (when addressBook: true)
+ * - getPrivateEvents (when privateEvents specified)
+ *
+ * @example
+ * // Access address book and events from specific contract
+ * \{
+ *   type: 'data',
+ *   addressBook: true,
+ *   privateEvents: \{
+ *     contracts: [ammAddress],
+ *     events: ['Swap', 'LiquidityAdded']
+ *   \}
+ * \}
+ *
+ * @example
+ * // Access all events from any contract
+ * \{
+ *   type: 'data',
+ *   privateEvents: \{
+ *     contracts: '*',
+ *     events: '*'
+ *   \}
+ * \}
+ */
+export interface DataCapability {
+    /** Discriminator for capability type */
+    type: 'data';
+    /** Access to address book. Maps to: getAddressBook */
+    addressBook?: boolean;
+    /** Access to private events. Maps to: getPrivateEvents */
+    privateEvents?: {
+        /**
+         * Which contracts to allow event queries from:
+         * - '*': Any contract
+         * - AztecAddress[]: Specific contracts
+         */
+        contracts: '*' | AztecAddress[];
+    };
+}
+/**
+ * Granted data access capability.
+ *
+ * The wallet may reduce the scope (e.g., from '*' to specific contracts).
+ */
+export interface GrantedDataCapability extends DataCapability {
+}
+/**
+ * Union type of all capability scopes (app request).
+ *
+ * Capabilities group wallet operations by their security sensitivity
+ * and functional cohesion, making permission requests understandable
+ * to users.
+ */
+export type Capability = AccountsCapability | ContractsCapability | ContractClassesCapability | SimulationCapability | TransactionCapability | DataCapability;
+/**
+ * Union type of all granted capabilities (wallet response).
+ *
+ * The wallet may augment capabilities with additional information:
+ * - AccountsCapability: adds specific accounts granted
+ * - Other capabilities: may reduce scope (e.g., '*' to specific addresses)
+ */
+export type GrantedCapability = GrantedAccountsCapability | GrantedContractsCapability | GrantedContractClassesCapability | GrantedSimulationCapability | GrantedTransactionCapability | GrantedDataCapability;
+/**
+ * Application capability manifest.
+ *
+ * Sent by dApp to declare all operations it needs. This reduces authorization
+ * friction from multiple dialogs to a single comprehensive permission request.
+ *
+ * @example
+ * // DEX application manifest
+ * const manifest: AppCapabilities = \{
+ *   version: CAPABILITY_VERSION,
+ *   metadata: \{
+ *     name: 'MyDEX',
+ *     version: '1.0.0',
+ *     description: 'Decentralized exchange for private token swaps',
+ *     url: 'https://example.com',
+ *     icon: 'https://example.com/icon.png'
+ *   \},
+ *   capabilities: [
+ *     \{
+ *       type: 'accounts',
+ *       canGet: true,
+ *       canCreateAuthWit: true
+ *     \},
+ *     \{
+ *       type: 'contracts',
+ *       contracts: [ammAddress, tokenAAddress, tokenBAddress],
+ *       canRegister: true,
+ *       canGetMetadata: true
+ *     \},
+ *     \{
+ *       type: 'simulation',
+ *       transactions: \{
+ *         scope: [\{ contract: ammAddress, function: '*' \}]
+ *       \}
+ *     \},
+ *     \{
+ *       type: 'transaction',
+ *       scope: [\{ contract: ammAddress, function: 'swap' \}]
+ *     \}
+ *   ]
+ * \};
+ */
+export interface AppCapabilities {
+    /**
+     * Manifest version for forward compatibility.
+     * Currently only '1.0' is supported.
+     */
+    version: typeof CAPABILITY_VERSION;
+    /** Application metadata for display in authorization dialogs. */
+    metadata: {
+        /** Human-readable app name */
+        name: string;
+        /** App version */
+        version: string;
+        /** Optional description of what the app does */
+        description?: string;
+        /** Optional website URL */
+        url?: string;
+        /** Optional icon URL or data URI */
+        icon?: string;
+    };
+    /**
+     * Requested capabilities grouped by scope.
+     */
+    capabilities: Capability[];
+}
+/**
+ * Wallet capability response.
+ *
+ * Returned by wallet after user reviews and approves/denies the capability request.
+ *
+ * The wallet can modify requested capabilities:
+ * - Reduce scope (e.g., restrict to specific contracts instead of '*')
+ * - Add information (e.g., specify which accounts are granted)
+ * - Deny capabilities (by omitting them from the `granted` array)
+ *
+ * @example
+ * // App requests
+ * const manifest: AppCapabilities = \{
+ *   version: '1.0',
+ *   metadata: \{ name: 'MyDApp', version: '1.0.0' \},
+ *   capabilities: [
+ *     \{ type: 'accounts', canGet: true \},
+ *     \{ type: 'contracts', contracts: '*', canRegister: true \}
+ *   ]
+ * \};
+ *
+ * // Wallet responds with specific accounts and restricted contracts
+ * const response = await wallet.requestCapabilities(manifest);
+ * console.log(response.granted);
+ * // [
+ * //   \{ type: 'accounts', canGet: true, accounts: [addr1, addr2] \},
+ * //   \{ type: 'contracts', contracts: [specificContract], canRegister: true \}
+ * // ]
+ */
+export interface WalletCapabilities {
+    /** Response version for forward compatibility. */
+    version: typeof CAPABILITY_VERSION;
+    /**
+     * Capabilities granted by the wallet.
+     * Capabilities not in this array were implicitly denied.
+     * Empty array means the user denied all capabilities.
+     */
+    granted: GrantedCapability[];
+    /** Wallet implementation details. */
+    wallet: {
+        /** Wallet name/implementation */
+        name: string;
+        /** Wallet version */
+        version: string;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/wallet/capabilities.ts"],"names":[],"mappings":"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"}

package/dest/wallet/capabilities.js

@@ -0,0 +1,3 @@
+/**
+ * Current capability manifest version.
+ */ export const CAPABILITY_VERSION = '1.0';