@azguardwallet/aztec-wallet 2.0.3 → 3.0.0-devnet.20251212

package/README.md

@@ -30,7 +30,7 @@ const wallet = await AztecWallet.connect(
         logo: "...",
         url: "..."
     },
-    "testnet" // or "sandbox", or CAIP-string like "aztec:11155111"
+    "devnet" // or "sandbox", or CAIP-string like "aztec:1654394782"
 );
 ```
 
@@ -39,16 +39,24 @@ Then use this `wallet` for interaction with Aztec.js:
 ```js
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import { SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
-import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { TokenContract, TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 
-const address = wallet.getAddress();
+const accounts = await wallet.getAccounts();
+const address = accounts[0].item;
 
 const tokenAddress = AztecAddress.fromString("0x...");
 const tokenContract = await TokenContract.at(tokenAddress, wallet);
 
+// register token contract in user's PXE
+
+const node = createAztecNodeClient("https://next.devnet.aztec-labs.com");
+const tokenInstance = await node.getContract(tokenAddress);
+await wallet.registerContract(tokenInstance, TokenContractArtifact);
+
 // get token private balance
 
-const prvBalance = await token.methods
+const prvBalance = await tokenContract.methods
     .balance_of_private(address)
     .simulate({from: address});
 
@@ -56,7 +64,7 @@ console.log("Private balance", prvBalance);
 
 // get token public balance
 
-const pubBalance = await token.methods
+const pubBalance = await tokenContract.methods
     .balance_of_public(address)
     .simulate({from: address});
 
@@ -70,7 +78,7 @@ const feeOptions = {
     ),
 };
 
-const txReceipt = await token.methods
+const txReceipt = await tokenContract.methods
     .transfer(AztecAddress.fromString("0x..."), 100000000n)
     .send({from: address, fee: feeOptions})
     .wait();
@@ -87,7 +95,9 @@ When Azguard user confirms connection from a dapp (`AztecWallet.connect()`), a d
 Even though the `AztecWallet` client reconnects automatically, you might want to additionally track the connection state. You can do the following:
 
 ```js
-// connect the wallet (in most cases it's called automatically under the hood, so you don't have to call it manually)
+// connect the wallet
+// (it's lazily called under the hood, so you don't have to call it manually,
+// unless you want to connect immediately)
 await wallet.connect();
 
 // check if the wallet is connected

package/dist/azguard.d.ts

@@ -1,21 +1,24 @@
 import { CaipChain, DappMetadata } from "@azguardwallet/types";
-import { AuthWitness, AztecAddress, CompleteAddress, ContractArtifact, ContractInstanceWithAddress, Fr, IntentAction, IntentInnerHash, NodeInfo, Tx, TxExecutionRequest, TxHash, TxProfileResult, TxReceipt, Wallet } from "@aztec/aztec.js";
-import { FeeOptions, TxExecutionOptions } from "@aztec/entrypoints/interfaces";
-import { ExecutionPayload } from "@aztec/entrypoints/payload";
-import { GasFees } from "@aztec/stdlib/gas";
-import { ContractClassMetadata, ContractMetadata, PXEInfo, EventMetadataDefinition } from "@aztec/stdlib/interfaces/client";
-import { SimulationOverrides, TxSimulationResult, UtilitySimulationResult, PrivateExecutionResult, TxProvingResult } from "@aztec/stdlib/tx";
+import { CallIntent, IntentInnerHash } from "@aztec/aztec.js/authorization";
+import { Aliased, BatchableMethods, BatchedMethod, BatchResults, PrivateEvent, PrivateEventFilter, ProfileOptions, SendOptions, SimulateOptions, Wallet } from "@aztec/aztec.js/wallet";
+import { ChainInfo } from "@aztec/entrypoints/interfaces";
+import { Fr } from "@aztec/foundation/curves/bn254";
+import { ContractArtifact, EventMetadataDefinition, FunctionCall } from "@aztec/stdlib/abi";
+import { AztecAddress } from "@aztec/stdlib/aztec-address";
+import { AuthWitness } from "@aztec/stdlib/auth-witness";
+import { ContractClassMetadata, ContractInstanceWithAddress, ContractMetadata } from "@aztec/stdlib/contract";
+import { ExecutionPayload, TxSimulationResult, UtilitySimulationResult, TxHash, TxReceipt, TxProfileResult } from "@aztec/stdlib/tx";
 /** Azguard Wallet client fully compatible with Aztec.js' `Wallet` interface */
 export declare class AztecWallet implements Wallet {
     #private;
     /**
      * Creates `AztecWallet` instance, connected to Azguard Wallet
      * @param dapp Dapp metadata (default: { name: window.location.hostname })
-     * @param chain Chain (default: "testnet")
+     * @param chain Chain (default: "devnet")
      * @param timeout Timeout in ms for the `window.azguard` object lookup (default: 1000ms)
      * @returns AztecWallet instance
      */
-    static connect(dapp?: DappMetadata, chain?: "testnet" | "sandbox" | CaipChain, timeout?: number): Promise<AztecWallet>;
+    static connect(dapp?: DappMetadata, chain?: "devnet" | "sandbox" | CaipChain, timeout?: number): Promise<AztecWallet>;
     /** Indicates whether the wallet is connected or not */
     get connected(): boolean;
     /** Event handlers invoked when the wallet is connected */
@@ -27,32 +30,19 @@ export declare class AztecWallet implements Wallet {
     /** Disconnects from the wallet */
     disconnect(): Promise<void>;
     private constructor();
-    getCompleteAddress(): CompleteAddress;
-    getAddress(): AztecAddress;
-    getChainId(): Fr;
-    getVersion(): Fr;
-    createTxExecutionRequest(exec: ExecutionPayload, fee: FeeOptions, options: TxExecutionOptions): Promise<TxExecutionRequest>;
-    createAuthWit(messageHashOrIntent: IntentAction | IntentInnerHash | Fr | Buffer): Promise<AuthWitness>;
-    simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean, skipTxValidation?: boolean, skipFeeEnforcement?: boolean, overrides?: SimulationOverrides, scopes?: AztecAddress[]): Promise<TxSimulationResult>;
-    simulateUtility(functionName: string, args: any[], to: AztecAddress, authwits?: AuthWitness[], from?: AztecAddress, scopes?: AztecAddress[]): Promise<UtilitySimulationResult>;
-    profileTx(txRequest: TxExecutionRequest, profileMode: "gates" | "execution-steps" | "full", skipProofGeneration?: boolean, msgSender?: AztecAddress): Promise<TxProfileResult>;
-    sendTx(tx: Tx): Promise<TxHash>;
     getContractClassMetadata(id: Fr, includeArtifact?: boolean): Promise<ContractClassMetadata>;
     getContractMetadata(address: AztecAddress): Promise<ContractMetadata>;
-    registerContract(contract: {
-        instance: ContractInstanceWithAddress;
-        artifact?: ContractArtifact;
-    }): Promise<void>;
-    registerContractClass(artifact: ContractArtifact): Promise<void>;
-    proveTx(txRequest: TxExecutionRequest, privateExecutionResult?: PrivateExecutionResult): Promise<TxProvingResult>;
-    getNodeInfo(): Promise<NodeInfo>;
-    getPXEInfo(): Promise<PXEInfo>;
-    getCurrentBaseFees(): Promise<GasFees>;
-    updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void>;
-    registerSender(address: AztecAddress): Promise<AztecAddress>;
-    getSenders(): Promise<AztecAddress[]>;
-    removeSender(address: AztecAddress): Promise<void>;
+    getPrivateEvents<T>(eventMetadata: EventMetadataDefinition, eventFilter: PrivateEventFilter): Promise<PrivateEvent<T>[]>;
+    getChainInfo(): Promise<ChainInfo>;
     getTxReceipt(txHash: TxHash): Promise<TxReceipt>;
-    getPrivateEvents<T>(contractAddress: AztecAddress, eventMetadata: EventMetadataDefinition, from: number, numBlocks: number, recipients: AztecAddress[]): Promise<T[]>;
-    getPublicEvents<T>(eventMetadata: EventMetadataDefinition, from: number, limit: number): Promise<T[]>;
+    registerSender(address: AztecAddress, alias?: string): Promise<AztecAddress>;
+    getAddressBook(): Promise<Aliased<AztecAddress>[]>;
+    getAccounts(): Promise<Aliased<AztecAddress>[]>;
+    registerContract(instance: ContractInstanceWithAddress, artifact?: ContractArtifact, secretKey?: Fr): Promise<ContractInstanceWithAddress>;
+    simulateTx(exec: ExecutionPayload, opts: SimulateOptions): Promise<TxSimulationResult>;
+    simulateUtility(call: FunctionCall, authwits?: AuthWitness[]): Promise<UtilitySimulationResult>;
+    profileTx(exec: ExecutionPayload, opts: ProfileOptions): Promise<TxProfileResult>;
+    sendTx(exec: ExecutionPayload, opts: SendOptions): Promise<TxHash>;
+    createAuthWit(from: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent): Promise<AuthWitness>;
+    batch<const T extends readonly BatchedMethod<keyof BatchableMethods>[]>(methods: T): Promise<BatchResults<T>>;
 }

package/dist/azguard.js

@@ -1,17 +1,18 @@
 import { AzguardClient } from "@azguardwallet/client";
-import { AuthWitness, AztecAddress, CompleteAddress, ContractFunctionInteraction, Fr, TxExecutionRequest, TxHash, TxProfileResult, TxReceipt, } from "@aztec/aztec.js";
-import { GasFees } from "@aztec/stdlib/gas";
-import { TxSimulationResult, UtilitySimulationResult, TxProvingResult, } from "@aztec/stdlib/tx";
-import { NodeInfoSchema } from "@aztec/stdlib/contract";
+import { AztecAddress } from "@aztec/stdlib/aztec-address";
+import { AuthWitness } from "@aztec/stdlib/auth-witness";
+import { ContractInstanceWithAddressSchema, } from "@aztec/stdlib/contract";
+import { TxSimulationResult, UtilitySimulationResult, TxHash, TxReceipt, TxProfileResult } from "@aztec/stdlib/tx";
 import z from "zod";
-import { ContractClassMetadataSchema, ContractMetadataSchema, PXEInfoSchema } from "./schemas";
+import { ChainInfoSchema } from "@aztec/entrypoints/interfaces";
+import { AddressBookSchema, ContractClassMetadataSchema, ContractMetadataSchema } from "./schemas";
 import { aztecMethods } from "./methods";
 /** Azguard Wallet client fully compatible with Aztec.js' `Wallet` interface */
 export class AztecWallet {
     /**
      * Creates `AztecWallet` instance, connected to Azguard Wallet
      * @param dapp Dapp metadata (default: { name: window.location.hostname })
-     * @param chain Chain (default: "testnet")
+     * @param chain Chain (default: "devnet")
      * @param timeout Timeout in ms for the `window.azguard` object lookup (default: 1000ms)
      * @returns AztecWallet instance
      */
@@ -19,11 +20,11 @@ export class AztecWallet {
         if (!dapp?.name) {
             dapp = { ...dapp, name: window.location.hostname };
         }
-        if (!chain || chain === "testnet") {
-            chain = "aztec:11155111";
+        if (!chain || chain === "devnet") {
+            chain = "aztec:1654394782";
         }
         else if (chain === "sandbox") {
-            chain = "aztec:31337";
+            chain = "aztec:0";
         }
         const azguard = await AzguardClient.create("aztec.js", timeout ?? 1000);
         const wallet = new AztecWallet(azguard, chain, dapp);
@@ -53,35 +54,21 @@ export class AztecWallet {
     #azguard;
     #chain;
     #dapp;
-    #completeAddress;
-    #address;
-    #chainId;
-    #version;
     constructor(azguard, chain, dapp) {
         this.#azguard = azguard;
         this.#chain = chain;
         this.#dapp = dapp;
         this.#azguard.onAccountsChanged.addHandler(this.#onAccountsChanged);
         this.#azguard.onPermissionsChanged.addHandler(this.#onPermissionsChanged);
-        this.#azguard.onDisconnected.addHandler(this.#onDisconnected);
     }
-    #onAccountsChanged = (accounts) => {
-        const currentAccount = this.#address?.toString();
-        if (currentAccount && !accounts.some((x) => x.endsWith(currentAccount))) {
-            this.#azguard.disconnect();
-        }
+    #onAccountsChanged = () => {
+        this.#azguard.disconnect();
     };
     #onPermissionsChanged = (permissions) => {
         if (aztecMethods.some((x) => !permissions.some((p) => p.chains?.includes(this.#chain) && p.methods?.includes(x)))) {
             this.#azguard.disconnect();
         }
     };
-    #onDisconnected = () => {
-        this.#completeAddress = undefined;
-        this.#address = undefined;
-        this.#chainId = undefined;
-        this.#version = undefined;
-    };
     async #ensureConnected() {
         if (!this.#azguard.connected) {
             await this.#azguard.connect(this.#dapp, [
@@ -91,33 +78,6 @@ export class AztecWallet {
                 },
             ]);
         }
-        if (!this.#version) {
-            const [r1, r2, r3, r4] = await this.#azguard.execute([
-                {
-                    kind: "aztec_getCompleteAddress",
-                    account: this.#azguard.accounts[0],
-                },
-                {
-                    kind: "aztec_getAddress",
-                    account: this.#azguard.accounts[0],
-                },
-                {
-                    kind: "aztec_getChainId",
-                    chain: this.#chain,
-                },
-                {
-                    kind: "aztec_getVersion",
-                    chain: this.#chain,
-                },
-            ]);
-            if (r1.status !== "ok" || r2.status !== "ok" || r3.status !== "ok" || r4.status !== "ok") {
-                throw new Error("Failed to initialize aztec wallet");
-            }
-            this.#completeAddress = await CompleteAddress.schema.parseAsync(r1.result);
-            this.#address = await AztecAddress.schema.parseAsync(r2.result);
-            this.#chainId = await Fr.schema.parseAsync(r3.result);
-            this.#version = await Fr.schema.parseAsync(r4.result);
-        }
     }
     async #account() {
         await this.#ensureConnected();
@@ -134,118 +94,6 @@ export class AztecWallet {
         }
         return await schema.parseAsync(result.result);
     }
-    getCompleteAddress() {
-        if (!this.#completeAddress) {
-            throw new Error("Aztec wallet was disconnected by the user");
-        }
-        return this.#completeAddress;
-    }
-    getAddress() {
-        if (!this.#address) {
-            throw new Error("Aztec wallet was disconnected by the user");
-        }
-        return this.#address;
-    }
-    getChainId() {
-        if (!this.#chainId) {
-            throw new Error("Aztec wallet was disconnected by the user");
-        }
-        return this.#chainId;
-    }
-    getVersion() {
-        if (!this.#version) {
-            throw new Error("Aztec wallet was disconnected by the user");
-        }
-        return this.#version;
-    }
-    async createTxExecutionRequest(exec, fee, options) {
-        let asset;
-        try {
-            asset = await fee.paymentMethod.getAsset();
-        }
-        catch { }
-        const paymentMethodDto = {
-            asset,
-            executionPayload: await fee.paymentMethod.getExecutionPayload(fee.gasSettings),
-            feePayer: await fee.paymentMethod.getFeePayer(fee.gasSettings),
-        };
-        return await this.#execute(TxExecutionRequest.schema, {
-            kind: "aztec_createTxExecutionRequest",
-            account: await this.#account(),
-            exec,
-            fee: {
-                paymentMethod: paymentMethodDto,
-                gasSettings: fee.gasSettings,
-            },
-            options,
-        });
-    }
-    async createAuthWit(messageHashOrIntent) {
-        let intentDto;
-        if (typeof messageHashOrIntent === "object" && "caller" in messageHashOrIntent) {
-            intentDto = {
-                caller: messageHashOrIntent.caller,
-                action: messageHashOrIntent.action instanceof ContractFunctionInteraction
-                    ? (await messageHashOrIntent.action.request()).calls[0]
-                    : messageHashOrIntent.action,
-            };
-        }
-        else if (typeof messageHashOrIntent === "object" && "consumer" in messageHashOrIntent) {
-            intentDto = {
-                consumer: messageHashOrIntent.consumer,
-                innerHash: new Fr(messageHashOrIntent.innerHash),
-            };
-        }
-        else {
-            intentDto = new Fr(messageHashOrIntent);
-        }
-        return await this.#execute(AuthWitness.schema, {
-            kind: "aztec_createAuthWit",
-            account: await this.#account(),
-            messageHashOrIntent: intentDto,
-        });
-    }
-    async simulateTx(txRequest, simulatePublic, skipTxValidation, skipFeeEnforcement, overrides, scopes) {
-        return await this.#execute(TxSimulationResult.schema, {
-            kind: "aztec_simulateTx",
-            chain: this.#chain,
-            txRequest,
-            simulatePublic,
-            skipTxValidation,
-            skipFeeEnforcement,
-            overrides,
-            scopes,
-        });
-    }
-    async simulateUtility(functionName, args, to, authwits, from, scopes) {
-        return await this.#execute(UtilitySimulationResult.schema, {
-            kind: "aztec_simulateUtility",
-            chain: this.#chain,
-            functionName,
-            args,
-            to,
-            authwits,
-            from,
-            scopes,
-        });
-    }
-    async profileTx(txRequest, profileMode, skipProofGeneration, msgSender) {
-        return await this.#execute(TxProfileResult.schema, {
-            kind: "aztec_profileTx",
-            chain: this.#chain,
-            txRequest,
-            profileMode,
-            skipProofGeneration,
-            msgSender,
-        });
-    }
-    async sendTx(tx) {
-        return await this.#execute(TxHash.schema, {
-            kind: "aztec_sendTx",
-            chain: this.#chain,
-            tx,
-        });
-    }
     async getContractClassMetadata(id, includeArtifact) {
         return await this.#execute(ContractClassMetadataSchema, {
             kind: "aztec_getContractClassMetadata",
@@ -261,99 +109,237 @@ export class AztecWallet {
             address,
         });
     }
-    async registerContract(contract) {
-        return await this.#execute(z.void(), {
-            kind: "aztec_registerContract",
+    async getPrivateEvents(eventMetadata, eventFilter) {
+        return await this.#execute(z.any(), {
+            kind: "aztec_getPrivateEvents",
             chain: this.#chain,
-            contract,
+            eventMetadata,
+            eventFilter,
         });
     }
-    async registerContractClass(artifact) {
-        return await this.#execute(z.void(), {
-            kind: "aztec_registerContractClass",
+    async getChainInfo() {
+        return await this.#execute(ChainInfoSchema, {
+            kind: "aztec_getChainInfo",
             chain: this.#chain,
-            artifact,
         });
     }
-    async proveTx(txRequest, privateExecutionResult) {
-        return await this.#execute(TxProvingResult.schema, {
-            kind: "aztec_proveTx",
+    async getTxReceipt(txHash) {
+        return await this.#execute(TxReceipt.schema, {
+            kind: "aztec_getTxReceipt",
             chain: this.#chain,
-            txRequest,
-            privateExecutionResult,
+            txHash,
         });
     }
-    async getNodeInfo() {
-        return await this.#execute(NodeInfoSchema, {
-            kind: "aztec_getNodeInfo",
+    async registerSender(address, alias) {
+        return await this.#execute(AztecAddress.schema, {
+            kind: "aztec_registerSender",
             chain: this.#chain,
+            address,
+            alias,
         });
     }
-    async getPXEInfo() {
-        return await this.#execute(PXEInfoSchema, {
-            kind: "aztec_getPXEInfo",
+    async getAddressBook() {
+        return await this.#execute(AddressBookSchema, {
+            kind: "aztec_getAddressBook",
             chain: this.#chain,
         });
     }
-    async getCurrentBaseFees() {
-        return await this.#execute(GasFees.schema, {
-            kind: "aztec_getCurrentBaseFees",
-            chain: this.#chain,
-        });
+    async getAccounts() {
+        await this.#ensureConnected();
+        return this.#azguard.accounts.map((x, i) => ({
+            alias: `Account ${i + 1}`,
+            item: AztecAddress.fromString(x.split(":").at(-1)),
+        }));
     }
-    async updateContract(contractAddress, artifact) {
-        return await this.#execute(z.void(), {
-            kind: "aztec_updateContract",
+    async registerContract(instance, artifact, secretKey) {
+        return await this.#execute(ContractInstanceWithAddressSchema, {
+            kind: "aztec_registerContract",
             chain: this.#chain,
-            contractAddress,
+            instance,
             artifact,
+            secretKey,
         });
     }
-    async registerSender(address) {
-        return await this.#execute(AztecAddress.schema, {
-            kind: "aztec_registerSender",
-            chain: this.#chain,
-            address,
+    async simulateTx(exec, opts) {
+        await this.#ensureConnected();
+        const account = this.#azguard.accounts.find((x) => x.endsWith(opts?.from?.toString()));
+        if (!account) {
+            throw new Error("Unauthorized 'from' account");
+        }
+        return await this.#execute(TxSimulationResult.schema, {
+            kind: "aztec_simulateTx",
+            account,
+            exec,
+            opts,
         });
     }
-    async getSenders() {
-        return await this.#execute(z.array(AztecAddress.schema), {
-            kind: "aztec_getSenders",
-            chain: this.#chain,
+    async simulateUtility(call, authwits) {
+        return await this.#execute(UtilitySimulationResult.schema, {
+            kind: "aztec_simulateUtility",
+            account: await this.#account(),
+            call,
+            authwits,
         });
     }
-    async removeSender(address) {
-        return await this.#execute(z.void(), {
-            kind: "aztec_removeSender",
-            chain: this.#chain,
-            address,
+    async profileTx(exec, opts) {
+        await this.#ensureConnected();
+        const account = this.#azguard.accounts.find((x) => x.endsWith(opts?.from?.toString()));
+        if (!account) {
+            throw new Error("Unauthorized 'from' account");
+        }
+        return await this.#execute(TxProfileResult.schema, {
+            kind: "aztec_profileTx",
+            account,
+            exec,
+            opts,
         });
     }
-    async getTxReceipt(txHash) {
-        return await this.#execute(TxReceipt.schema, {
-            kind: "aztec_getTxReceipt",
-            chain: this.#chain,
-            txHash,
+    async sendTx(exec, opts) {
+        await this.#ensureConnected();
+        const account = this.#azguard.accounts.find((x) => x.endsWith(opts?.from?.toString()));
+        if (!account) {
+            throw new Error("Unauthorized 'from' account");
+        }
+        return await this.#execute(TxHash.schema, {
+            kind: "aztec_sendTx",
+            account,
+            exec,
+            opts,
         });
     }
-    async getPrivateEvents(contractAddress, eventMetadata, from, numBlocks, recipients) {
-        return await this.#execute(z.any(), {
-            kind: "aztec_getPrivateEvents",
-            chain: this.#chain,
-            contractAddress,
-            eventMetadata,
-            from,
-            numBlocks,
-            recipients,
+    async createAuthWit(from, messageHashOrIntent) {
+        await this.#ensureConnected();
+        const account = this.#azguard.accounts.find((x) => x.endsWith(from?.toString()));
+        if (!account) {
+            throw new Error("Unauthorized 'from' account");
+        }
+        return await this.#execute(AuthWitness.schema, {
+            kind: "aztec_createAuthWit",
+            account,
+            messageHashOrIntent,
         });
     }
-    async getPublicEvents(eventMetadata, from, limit) {
-        return await this.#execute(z.any(), {
-            kind: "aztec_getPublicEvents",
-            chain: this.#chain,
-            eventMetadata,
-            from,
-            limit,
-        });
+    async batch(methods) {
+        await this.#ensureConnected();
+        const operations = [];
+        for (const method of methods) {
+            switch (method.name) {
+                case "registerContract": {
+                    const [instance, artifact, secretKey] = method.args;
+                    operations.push({
+                        kind: "aztec_registerContract",
+                        chain: this.#chain,
+                        instance,
+                        artifact,
+                        secretKey,
+                    });
+                    break;
+                }
+                case "registerSender": {
+                    const [address, alias] = method.args;
+                    operations.push({
+                        kind: "aztec_registerSender",
+                        chain: this.#chain,
+                        address,
+                        alias,
+                    });
+                    break;
+                }
+                case "sendTx": {
+                    const [exec, opts] = method.args;
+                    const account = this.#azguard.accounts.find((x) => x.endsWith(opts?.from?.toString()));
+                    if (!account) {
+                        throw new Error("Unauthorized 'from' account");
+                    }
+                    operations.push({
+                        kind: "aztec_sendTx",
+                        account,
+                        exec,
+                        opts,
+                    });
+                    break;
+                }
+                case "simulateTx": {
+                    const [exec, opts] = method.args;
+                    const account = this.#azguard.accounts.find((x) => x.endsWith(opts?.from?.toString()));
+                    if (!account) {
+                        throw new Error("Unauthorized 'from' account");
+                    }
+                    operations.push({
+                        kind: "aztec_simulateTx",
+                        account,
+                        exec,
+                        opts,
+                    });
+                    break;
+                }
+                case "simulateUtility": {
+                    const [call, authwits] = method.args;
+                    operations.push({
+                        kind: "aztec_simulateUtility",
+                        account: await this.#account(),
+                        call,
+                        authwits,
+                    });
+                    break;
+                }
+                default: {
+                    throw new Error("Unsupported batch method");
+                }
+            }
+        }
+        const results = await this.#azguard.execute(operations);
+        const output = [];
+        for (let i = 0; i < results.length; i++) {
+            const method = methods[i].name;
+            const result = results[i];
+            if (result.status === "failed") {
+                throw new Error(`${method} failed with '${result.error}'`);
+            }
+            if (result.status === "skipped") {
+                throw new Error(`${method} was skipped`);
+            }
+            switch (method) {
+                case "registerContract": {
+                    output.push({
+                        method,
+                        result: await ContractInstanceWithAddressSchema.parseAsync(result.result),
+                    });
+                    break;
+                }
+                case "registerSender": {
+                    output.push({
+                        method,
+                        result: await AztecAddress.schema.parseAsync(result.result),
+                    });
+                    break;
+                }
+                case "sendTx": {
+                    output.push({
+                        method,
+                        result: await TxHash.schema.parseAsync(result.result),
+                    });
+                    break;
+                }
+                case "simulateTx": {
+                    output.push({
+                        method,
+                        result: await TxSimulationResult.schema.parseAsync(result.result),
+                    });
+                    break;
+                }
+                case "simulateUtility": {
+                    output.push({
+                        method,
+                        result: await UtilitySimulationResult.schema.parseAsync(result.result),
+                    });
+                    break;
+                }
+                default: {
+                    throw new Error("Unsupported batch method");
+                }
+            }
+        }
+        return output;
     }
 }

package/dist/methods.js

@@ -1,27 +1,15 @@
 export const aztecMethods = [
+    "aztec_getContractClassMetadata",
+    "aztec_getContractMetadata",
+    "aztec_getPrivateEvents",
+    "aztec_getChainInfo",
+    "aztec_getTxReceipt",
+    "aztec_registerSender",
+    "aztec_getAddressBook",
+    "aztec_registerContract",
     "aztec_simulateTx",
     "aztec_simulateUtility",
     "aztec_profileTx",
     "aztec_sendTx",
-    "aztec_getContractClassMetadata",
-    "aztec_getContractMetadata",
-    "aztec_registerContract",
-    "aztec_registerContractClass",
-    "aztec_proveTx",
-    "aztec_getNodeInfo",
-    "aztec_getPXEInfo",
-    "aztec_getCurrentBaseFees",
-    "aztec_updateContract",
-    "aztec_registerSender",
-    "aztec_getSenders",
-    "aztec_removeSender",
-    "aztec_getTxReceipt",
-    "aztec_getPrivateEvents",
-    "aztec_getPublicEvents",
-    "aztec_getCompleteAddress",
-    "aztec_getAddress",
-    "aztec_getChainId",
-    "aztec_getVersion",
-    "aztec_createTxExecutionRequest",
     "aztec_createAuthWit",
 ];

package/dist/schemas.d.ts

@@ -1,227 +1,9 @@
-import { EventSelector } from "@aztec/stdlib/abi";
+import { Aliased } from "@aztec/aztec.js/wallet";
 import { ZodFor } from "@aztec/foundation/schemas";
-import z from "zod";
-export declare const ContractClassMetadataSchema: z.ZodObject<{
-    contractClass: z.ZodUnion<[z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        artifactHash: z.ZodType<import("@aztec/aztec.js").Fr, any, string>;
-        privateFunctions: z.ZodArray<z.ZodObject<{
-            selector: ZodFor<import("@aztec/aztec.js").FunctionSelector>;
-            vkHash: z.ZodType<import("@aztec/aztec.js").Fr, any, string>;
-        }, "strip", z.ZodTypeAny, {
-            selector: import("@aztec/aztec.js").FunctionSelector;
-            vkHash: import("@aztec/aztec.js").Fr;
-        }, {
-            vkHash: string;
-            selector?: any;
-        }>, "many">;
-        packedBytecode: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer<ArrayBuffer>, string>, z.ZodEffects<z.ZodObject<{
-            type: z.ZodLiteral<"Buffer">;
-            data: z.ZodArray<z.ZodNumber, "many">;
-        }, "strip", z.ZodTypeAny, {
-            type: "Buffer";
-            data: number[];
-        }, {
-            type: "Buffer";
-            data: number[];
-        }>, Buffer<ArrayBuffer>, {
-            type: "Buffer";
-            data: number[];
-        }>]>;
-    } & {
-        id: z.ZodType<import("@aztec/aztec.js").Fr, any, string>;
-    }, "strip", z.ZodTypeAny, {
-        version: 1;
-        id: import("@aztec/aztec.js").Fr;
-        artifactHash: import("@aztec/aztec.js").Fr;
-        packedBytecode: Buffer<ArrayBuffer>;
-        privateFunctions: {
-            selector: import("@aztec/aztec.js").FunctionSelector;
-            vkHash: import("@aztec/aztec.js").Fr;
-        }[];
-    }, {
-        version: 1;
-        id: string;
-        artifactHash: string;
-        packedBytecode: string | {
-            type: "Buffer";
-            data: number[];
-        };
-        privateFunctions: {
-            vkHash: string;
-            selector?: any;
-        }[];
-    }>, z.ZodUndefined]>;
-    isContractClassPubliclyRegistered: z.ZodBoolean;
-    artifact: z.ZodUnion<[ZodFor<import("@aztec/aztec.js").ContractArtifact>, z.ZodUndefined]>;
-}, "strip", z.ZodTypeAny, {
-    isContractClassPubliclyRegistered: boolean;
-    contractClass?: {
-        version: 1;
-        id: import("@aztec/aztec.js").Fr;
-        artifactHash: import("@aztec/aztec.js").Fr;
-        packedBytecode: Buffer<ArrayBuffer>;
-        privateFunctions: {
-            selector: import("@aztec/aztec.js").FunctionSelector;
-            vkHash: import("@aztec/aztec.js").Fr;
-        }[];
-    } | undefined;
-    artifact?: import("@aztec/aztec.js").ContractArtifact | undefined;
-}, {
-    isContractClassPubliclyRegistered: boolean;
-    contractClass?: {
-        version: 1;
-        id: string;
-        artifactHash: string;
-        packedBytecode: string | {
-            type: "Buffer";
-            data: number[];
-        };
-        privateFunctions: {
-            vkHash: string;
-            selector?: any;
-        }[];
-    } | undefined;
-    artifact?: any;
-}>;
-export declare const ContractMetadataSchema: z.ZodObject<{
-    contractInstance: z.ZodUnion<[z.ZodIntersection<z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        salt: ZodFor<import("@aztec/aztec.js").Fr>;
-        deployer: ZodFor<import("@aztec/aztec.js").AztecAddress>;
-        currentContractClassId: ZodFor<import("@aztec/aztec.js").Fr>;
-        originalContractClassId: ZodFor<import("@aztec/aztec.js").Fr>;
-        initializationHash: ZodFor<import("@aztec/aztec.js").Fr>;
-        publicKeys: z.ZodEffects<z.ZodObject<{
-            masterNullifierPublicKey: z.ZodType<import("@aztec/aztec.js").Point, any, string>;
-            masterIncomingViewingPublicKey: z.ZodType<import("@aztec/aztec.js").Point, any, string>;
-            masterOutgoingViewingPublicKey: z.ZodType<import("@aztec/aztec.js").Point, any, string>;
-            masterTaggingPublicKey: z.ZodType<import("@aztec/aztec.js").Point, any, string>;
-        }, "strip", z.ZodTypeAny, {
-            masterNullifierPublicKey: import("@aztec/aztec.js").Point;
-            masterIncomingViewingPublicKey: import("@aztec/aztec.js").Point;
-            masterOutgoingViewingPublicKey: import("@aztec/aztec.js").Point;
-            masterTaggingPublicKey: import("@aztec/aztec.js").Point;
-        }, {
-            masterNullifierPublicKey: string;
-            masterIncomingViewingPublicKey: string;
-            masterOutgoingViewingPublicKey: string;
-            masterTaggingPublicKey: string;
-        }>, import("@aztec/aztec.js").PublicKeys, {
-            masterNullifierPublicKey: string;
-            masterIncomingViewingPublicKey: string;
-            masterOutgoingViewingPublicKey: string;
-            masterTaggingPublicKey: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        version: 1;
-        salt: import("@aztec/aztec.js").Fr;
-        publicKeys: import("@aztec/aztec.js").PublicKeys;
-        deployer: import("@aztec/aztec.js").AztecAddress;
-        currentContractClassId: import("@aztec/aztec.js").Fr;
-        originalContractClassId: import("@aztec/aztec.js").Fr;
-        initializationHash: import("@aztec/aztec.js").Fr;
-    }, {
-        version: 1;
-        publicKeys: {
-            masterNullifierPublicKey: string;
-            masterIncomingViewingPublicKey: string;
-            masterOutgoingViewingPublicKey: string;
-            masterTaggingPublicKey: string;
-        };
-        salt?: any;
-        deployer?: any;
-        currentContractClassId?: any;
-        originalContractClassId?: any;
-        initializationHash?: any;
-    }>, z.ZodObject<{
-        address: ZodFor<import("@aztec/aztec.js").AztecAddress>;
-    }, "strip", z.ZodTypeAny, {
-        address: import("@aztec/aztec.js").AztecAddress;
-    }, {
-        address?: any;
-    }>>, z.ZodUndefined]>;
-    isContractInitialized: z.ZodBoolean;
-    isContractPublished: z.ZodBoolean;
-}, "strip", z.ZodTypeAny, {
-    isContractInitialized: boolean;
-    isContractPublished: boolean;
-    contractInstance?: ({
-        version: 1;
-        salt: import("@aztec/aztec.js").Fr;
-        publicKeys: import("@aztec/aztec.js").PublicKeys;
-        deployer: import("@aztec/aztec.js").AztecAddress;
-        currentContractClassId: import("@aztec/aztec.js").Fr;
-        originalContractClassId: import("@aztec/aztec.js").Fr;
-        initializationHash: import("@aztec/aztec.js").Fr;
-    } & {
-        address: import("@aztec/aztec.js").AztecAddress;
-    }) | undefined;
-}, {
-    isContractInitialized: boolean;
-    isContractPublished: boolean;
-    contractInstance?: ({
-        version: 1;
-        publicKeys: {
-            masterNullifierPublicKey: string;
-            masterIncomingViewingPublicKey: string;
-            masterOutgoingViewingPublicKey: string;
-            masterTaggingPublicKey: string;
-        };
-        salt?: any;
-        deployer?: any;
-        currentContractClassId?: any;
-        originalContractClassId?: any;
-        initializationHash?: any;
-    } & {
-        address?: any;
-    }) | undefined;
-}>;
-export declare const PXEInfoSchema: z.ZodObject<{
-    pxeVersion: z.ZodString;
-    protocolContractAddresses: z.ZodObject<{
-        classRegistry: import("@aztec/stdlib/schemas").ZodFor<import("@aztec/aztec.js").AztecAddress>;
-        feeJuice: import("@aztec/stdlib/schemas").ZodFor<import("@aztec/aztec.js").AztecAddress>;
-        instanceRegistry: import("@aztec/stdlib/schemas").ZodFor<import("@aztec/aztec.js").AztecAddress>;
-        multiCallEntrypoint: import("@aztec/stdlib/schemas").ZodFor<import("@aztec/aztec.js").AztecAddress>;
-    }, "strip", z.ZodTypeAny, {
-        classRegistry: import("@aztec/aztec.js").AztecAddress;
-        feeJuice: import("@aztec/aztec.js").AztecAddress;
-        instanceRegistry: import("@aztec/aztec.js").AztecAddress;
-        multiCallEntrypoint: import("@aztec/aztec.js").AztecAddress;
-    }, {
-        classRegistry?: any;
-        feeJuice?: any;
-        instanceRegistry?: any;
-        multiCallEntrypoint?: any;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    pxeVersion: string;
-    protocolContractAddresses: {
-        classRegistry: import("@aztec/aztec.js").AztecAddress;
-        feeJuice: import("@aztec/aztec.js").AztecAddress;
-        instanceRegistry: import("@aztec/aztec.js").AztecAddress;
-        multiCallEntrypoint: import("@aztec/aztec.js").AztecAddress;
-    };
-}, {
-    pxeVersion: string;
-    protocolContractAddresses: {
-        classRegistry?: any;
-        feeJuice?: any;
-        instanceRegistry?: any;
-        multiCallEntrypoint?: any;
-    };
-}>;
-export declare const EventMetadataDefinitionSchema: z.ZodObject<{
-    eventSelector: z.ZodType<EventSelector, any, string>;
-    abiType: z.ZodType<import("@aztec/aztec.js").AbiType, z.ZodTypeDef, import("@aztec/aztec.js").AbiType>;
-    fieldNames: z.ZodArray<z.ZodString, "many">;
-}, "strip", z.ZodTypeAny, {
-    eventSelector: EventSelector;
-    abiType: import("@aztec/aztec.js").AbiType;
-    fieldNames: string[];
-}, {
-    eventSelector: string;
-    abiType: import("@aztec/aztec.js").AbiType;
-    fieldNames: string[];
-}>;
+import { EventMetadataDefinition } from "@aztec/stdlib/abi";
+import { AztecAddress } from "@aztec/stdlib/aztec-address";
+import { ContractClassMetadata, ContractMetadata } from "@aztec/stdlib/contract";
+export declare const ContractClassMetadataSchema: ZodFor<ContractClassMetadata>;
+export declare const ContractMetadataSchema: ZodFor<ContractMetadata>;
+export declare const EventMetadataDefinitionSchema: ZodFor<EventMetadataDefinition>;
+export declare const AddressBookSchema: ZodFor<Aliased<AztecAddress>[]>;

package/dist/schemas.js

@@ -1,5 +1,6 @@
 import { AbiTypeSchema, ContractArtifactSchema, EventSelector } from "@aztec/stdlib/abi";
-import { ContractClassWithIdSchema, ContractInstanceWithAddressSchema, ProtocolContractAddressesSchema, } from "@aztec/stdlib/contract";
+import { AztecAddress } from "@aztec/stdlib/aztec-address";
+import { ContractClassWithIdSchema, ContractInstanceWithAddressSchema, } from "@aztec/stdlib/contract";
 import z from "zod";
 // copied from aztec.js, because it's not exported
 export const ContractClassMetadataSchema = z.object({
@@ -12,12 +13,12 @@ export const ContractMetadataSchema = z.object({
     isContractInitialized: z.boolean(),
     isContractPublished: z.boolean(),
 });
-export const PXEInfoSchema = z.object({
-    pxeVersion: z.string(),
-    protocolContractAddresses: ProtocolContractAddressesSchema,
-});
 export const EventMetadataDefinitionSchema = z.object({
     eventSelector: EventSelector.schema,
     abiType: AbiTypeSchema,
     fieldNames: z.array(z.string()),
 });
+export const AddressBookSchema = z.array(z.object({
+    alias: z.string(),
+    item: AztecAddress.schema,
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azguardwallet/aztec-wallet",
-    "version": "2.0.3",
+    "version": "3.0.0-devnet.20251212",
     "description": "Azguard Wallet client fully compatible with Aztec.js' Wallet interface",
     "author": "Azguard Wallet",
     "homepage": "https://github.com/AzguardWallet/aztec-wallet",
@@ -22,12 +22,12 @@
         "build": "rm -rf dist && tsc"
     },
     "dependencies": {
-        "@azguardwallet/client": "0.5.0",
-        "@azguardwallet/types": "0.5.0",
-		"@aztec/aztec.js": "2.0.3",
-		"@aztec/entrypoints": "2.0.3",
-		"@aztec/foundation": "2.0.3",
-		"@aztec/stdlib": "2.0.3",
-		"zod": "^3.23.8"
+        "@azguardwallet/client": "0.7.0",
+        "@azguardwallet/types": "0.7.0",
+        "@aztec/aztec.js": "3.0.0-devnet.20251212",
+        "@aztec/entrypoints": "3.0.0-devnet.20251212",
+        "@aztec/foundation": "3.0.0-devnet.20251212",
+        "@aztec/stdlib": "3.0.0-devnet.20251212",
+        "zod": "^3.23.8"
     }
 }