@azguardwallet/aztec-wallet 2.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Azguard Wallet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# @azguardwallet/aztec-wallet
+
+[![GitHub License](https://img.shields.io/github/license/AzguardWallet/aztec-wallet)](https://github.com/AzguardWallet/aztec-wallet/blob/main/LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@azguardwallet/aztec-wallet)](https://www.npmjs.com/package/@azguardwallet/aztec-wallet)
+[![NPM Downloads](https://img.shields.io/npm/dt/@azguardwallet/aztec-wallet)](https://www.npmjs.com/package/@azguardwallet/aztec-wallet)
+
+Azguard Wallet client fully compatible with Aztec.js' `Wallet` interface, enabling seamless integration.
+
+## How to use
+
+Install the package:
+
+```shell
+npm install @azguardwallet/aztec-wallet
+```
+
+Connect the wallet:
+
+```js
+import { AztecWallet } from "@azguardwallet/aztec-wallet";
+
+// the simplest way
+const wallet = await AztecWallet.connect();
+
+// or you can additionally provide the dapp metadata and the chain
+const wallet = await AztecWallet.connect(
+    {
+        name: "My Dapp",
+        description: "The best dapp in the world",
+        logo: "...",
+        url: "..."
+    },
+    "testnet" // or "sandbox", or CAIP-string like "aztec:11155111"
+);
+```
+
+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';
+
+const address = wallet.getAddress();
+
+const tokenAddress = AztecAddress.fromString("0x...");
+const tokenContract = await TokenContract.at(tokenAddress, wallet);
+
+// get token private balance
+
+const prvBalance = await token.methods
+    .balance_of_private(address)
+    .simulate({from: address});
+
+console.log("Private balance", prvBalance);
+
+// get token public balance
+
+const pubBalance = await token.methods
+    .balance_of_public(address)
+    .simulate({from: address});
+
+console.log("Public balance", pubBalance);
+
+// send token
+
+const feeOptions = {
+    paymentMethod: new SponsoredFeePaymentMethod(
+        AztecAddress.fromString("0x..."),
+    ),
+};
+
+const txReceipt = await token.methods
+    .transfer(AztecAddress.fromString("0x..."), 100000000n)
+    .send({from: address, fee: feeOptions})
+    .wait();
+
+console.log("Tx hash", txReceipt.txHash);
+```
+
+That's pretty much it! See more Aztec.js examples at https://docs.aztec.network.
+
+## Connection state
+
+When Azguard user confirms connection from a dapp (`AztecWallet.connect()`), a dapp session is opened, and while this session is active, the dapp is allowed to interact with the wallet. If the dapp session is expired or closed (either by the dapp or by the user), the interaction is no longer allowed.
+
+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)
+await wallet.connect();
+
+// check if the wallet is connected
+console.log(wallet.connected);
+
+// track connection/disconnection events
+wallet.onConnected.addHandler(() => console.log("Azguard connected"));
+wallet.onDisconnected.addHandler(() => console.log("Azguard disconnected"));
+
+// in the end you can disconnect and close the session
+await wallet.disconnect();
+```
+
+## Support channels
+
+If you have any questions, feel free to contact us in:
+- Telegram: https://t.me/azguardwallet
+- Twitter: https://twitter.com/AzguardWallet
+
+Cheers! 🍺

package/dist/azguard.d.ts

@@ -0,0 +1,58 @@
+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";
+/** 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 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>;
+    /** Indicates whether the wallet is connected or not */
+    get connected(): boolean;
+    /** Event handlers invoked when the wallet is connected */
+    get onConnected(): import("@azguardwallet/client").IEventHandlers<void>;
+    /** Event handlers invoked when the wallet is disconnected */
+    get onDisconnected(): import("@azguardwallet/client").IEventHandlers<void>;
+    /** Connects to the wallet */
+    connect(): Promise<void>;
+    /** 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>;
+    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[]>;
+}

package/dist/azguard.js

@@ -0,0 +1,359 @@
+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 z from "zod";
+import { ContractClassMetadataSchema, ContractMetadataSchema, PXEInfoSchema } 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 timeout Timeout in ms for the `window.azguard` object lookup (default: 1000ms)
+     * @returns AztecWallet instance
+     */
+    static async connect(dapp, chain, timeout) {
+        if (!dapp?.name) {
+            dapp = { ...dapp, name: window.location.hostname };
+        }
+        if (!chain || chain === "testnet") {
+            chain = "aztec:11155111";
+        }
+        else if (chain === "sandbox") {
+            chain = "aztec:31337";
+        }
+        const azguard = await AzguardClient.create("aztec.js", timeout ?? 1000);
+        const wallet = new AztecWallet(azguard, chain, dapp);
+        await wallet.connect();
+        return wallet;
+    }
+    /** Indicates whether the wallet is connected or not */
+    get connected() {
+        return this.#azguard.connected;
+    }
+    /** Event handlers invoked when the wallet is connected */
+    get onConnected() {
+        return this.#azguard.onConnected;
+    }
+    /** Event handlers invoked when the wallet is disconnected */
+    get onDisconnected() {
+        return this.#azguard.onDisconnected;
+    }
+    /** Connects to the wallet */
+    async connect() {
+        await this.#ensureConnected();
+    }
+    /** Disconnects from the wallet */
+    async disconnect() {
+        await this.#azguard.disconnect();
+    }
+    #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();
+        }
+    };
+    #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, [
+                {
+                    chains: [this.#chain],
+                    methods: aztecMethods,
+                },
+            ]);
+        }
+        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();
+        return this.#azguard.accounts[0];
+    }
+    async #execute(schema, operation) {
+        await this.#ensureConnected();
+        const [result] = await this.#azguard.execute([operation]);
+        if (result.status === "failed") {
+            throw new Error(`Operation failed: ${result.error}`);
+        }
+        if (result.status === "skipped") {
+            throw new Error("Operation was skipped");
+        }
+        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",
+            chain: this.#chain,
+            id,
+            includeArtifact,
+        });
+    }
+    async getContractMetadata(address) {
+        return await this.#execute(ContractMetadataSchema, {
+            kind: "aztec_getContractMetadata",
+            chain: this.#chain,
+            address,
+        });
+    }
+    async registerContract(contract) {
+        return await this.#execute(z.void(), {
+            kind: "aztec_registerContract",
+            chain: this.#chain,
+            contract,
+        });
+    }
+    async registerContractClass(artifact) {
+        return await this.#execute(z.void(), {
+            kind: "aztec_registerContractClass",
+            chain: this.#chain,
+            artifact,
+        });
+    }
+    async proveTx(txRequest, privateExecutionResult) {
+        return await this.#execute(TxProvingResult.schema, {
+            kind: "aztec_proveTx",
+            chain: this.#chain,
+            txRequest,
+            privateExecutionResult,
+        });
+    }
+    async getNodeInfo() {
+        return await this.#execute(NodeInfoSchema, {
+            kind: "aztec_getNodeInfo",
+            chain: this.#chain,
+        });
+    }
+    async getPXEInfo() {
+        return await this.#execute(PXEInfoSchema, {
+            kind: "aztec_getPXEInfo",
+            chain: this.#chain,
+        });
+    }
+    async getCurrentBaseFees() {
+        return await this.#execute(GasFees.schema, {
+            kind: "aztec_getCurrentBaseFees",
+            chain: this.#chain,
+        });
+    }
+    async updateContract(contractAddress, artifact) {
+        return await this.#execute(z.void(), {
+            kind: "aztec_updateContract",
+            chain: this.#chain,
+            contractAddress,
+            artifact,
+        });
+    }
+    async registerSender(address) {
+        return await this.#execute(AztecAddress.schema, {
+            kind: "aztec_registerSender",
+            chain: this.#chain,
+            address,
+        });
+    }
+    async getSenders() {
+        return await this.#execute(z.array(AztecAddress.schema), {
+            kind: "aztec_getSenders",
+            chain: this.#chain,
+        });
+    }
+    async removeSender(address) {
+        return await this.#execute(z.void(), {
+            kind: "aztec_removeSender",
+            chain: this.#chain,
+            address,
+        });
+    }
+    async getTxReceipt(txHash) {
+        return await this.#execute(TxReceipt.schema, {
+            kind: "aztec_getTxReceipt",
+            chain: this.#chain,
+            txHash,
+        });
+    }
+    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 getPublicEvents(eventMetadata, from, limit) {
+        return await this.#execute(z.any(), {
+            kind: "aztec_getPublicEvents",
+            chain: this.#chain,
+            eventMetadata,
+            from,
+            limit,
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AztecWallet } from "./azguard";

package/dist/index.js

@@ -0,0 +1 @@
+export { AztecWallet } from "./azguard";

package/dist/methods.d.ts

@@ -0,0 +1,2 @@
+import { OperationKind } from "@azguardwallet/types";
+export declare const aztecMethods: OperationKind[];

package/dist/methods.js

@@ -0,0 +1,27 @@
+export const aztecMethods = [
+    "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

@@ -0,0 +1,227 @@
+import { EventSelector } from "@aztec/stdlib/abi";
+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[];
+}>;

package/dist/schemas.js

@@ -0,0 +1,23 @@
+import { AbiTypeSchema, ContractArtifactSchema, EventSelector } from "@aztec/stdlib/abi";
+import { ContractClassWithIdSchema, ContractInstanceWithAddressSchema, ProtocolContractAddressesSchema, } from "@aztec/stdlib/contract";
+import z from "zod";
+// copied from aztec.js, because it's not exported
+export const ContractClassMetadataSchema = z.object({
+    contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
+    isContractClassPubliclyRegistered: z.boolean(),
+    artifact: z.union([ContractArtifactSchema, z.undefined()]),
+});
+export const ContractMetadataSchema = z.object({
+    contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
+    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()),
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@azguardwallet/aztec-wallet",
+    "version": "2.0.3",
+    "description": "Azguard Wallet client fully compatible with Aztec.js' Wallet interface",
+    "author": "Azguard Wallet",
+    "homepage": "https://github.com/AzguardWallet/aztec-wallet",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/AzguardWallet/aztec-wallet.git"
+    },
+    "license": "MIT",
+    "exports": {
+        ".": {
+            "default": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "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"
+    }
+}