@aztec-labs/aztec.js 6.0.0-nightly.20260829

package/dest/test/fixtures.js

@@ -0,0 +1,185 @@
+import { MEGA_APP_VK_LENGTH_IN_FIELDS } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FunctionType } from '@aztec-labs/stdlib/abi';
+import { DEV_VERSION } from '@aztec-labs/stdlib/update-checker';
+/**
+ * A minimal but representative `ContractArtifact` shared by unit tests in this package. Covers
+ * every function shape the tests exercise: a private initializer (`constructor`), the standard
+ * `public_dispatch` entry, a private function with mixed-visibility params (`bar`), a utility
+ * function (`qux`), and two functions exercising Noir `Option<Field>` parameters (`optionEcho`,
+ * `mixedParams`).
+ *
+ * We deliberately do not depend on `@aztec-labs/noir-test-contracts.js` here: that package depends on
+ * `@aztec-labs/aztec.js`, so importing from it would create a workspace cycle.
+ */ export const testContractArtifact = {
+    name: 'TestContract',
+    aztecVersion: DEV_VERSION,
+    functions: [
+        {
+            name: 'constructor',
+            isInitializer: true,
+            functionType: FunctionType.PRIVATE,
+            isOnlySelf: false,
+            isStatic: false,
+            debugSymbols: '',
+            parameters: [],
+            errorTypes: {},
+            bytecode: Buffer.alloc(8, 0xfa),
+            verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64')
+        },
+        {
+            name: 'public_dispatch',
+            isInitializer: false,
+            isStatic: false,
+            functionType: FunctionType.PUBLIC,
+            isOnlySelf: false,
+            parameters: [
+                {
+                    name: 'selector',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'public'
+                }
+            ],
+            errorTypes: {},
+            bytecode: Buffer.alloc(8, 0xfb),
+            debugSymbols: ''
+        },
+        {
+            name: 'bar',
+            isInitializer: false,
+            functionType: FunctionType.PRIVATE,
+            isOnlySelf: false,
+            isStatic: false,
+            debugSymbols: '',
+            parameters: [
+                {
+                    name: 'value',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'public'
+                },
+                {
+                    name: 'value',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'private'
+                }
+            ],
+            errorTypes: {},
+            bytecode: Buffer.alloc(8, 0xfa),
+            verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64')
+        },
+        {
+            name: 'qux',
+            isInitializer: false,
+            isStatic: false,
+            functionType: FunctionType.UTILITY,
+            isOnlySelf: false,
+            parameters: [
+                {
+                    name: 'value',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'public'
+                }
+            ],
+            returnType: {
+                kind: 'integer',
+                sign: 'unsigned',
+                width: 32
+            },
+            bytecode: Buffer.alloc(8, 0xfc),
+            debugSymbols: '',
+            errorTypes: {}
+        },
+        {
+            name: 'optionEcho',
+            isInitializer: false,
+            functionType: FunctionType.PRIVATE,
+            isOnlySelf: false,
+            isStatic: false,
+            parameters: [
+                {
+                    name: 'value',
+                    type: {
+                        kind: 'struct',
+                        path: 'std::option::Option',
+                        fields: [
+                            {
+                                name: '_is_some',
+                                type: {
+                                    kind: 'boolean'
+                                }
+                            },
+                            {
+                                name: '_value',
+                                type: {
+                                    kind: 'field'
+                                }
+                            }
+                        ]
+                    },
+                    visibility: 'private'
+                }
+            ],
+            errorTypes: {},
+            bytecode: Buffer.alloc(8, 0xfd),
+            verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+            debugSymbols: ''
+        },
+        {
+            name: 'mixedParams',
+            isInitializer: false,
+            functionType: FunctionType.PRIVATE,
+            isOnlySelf: false,
+            isStatic: false,
+            parameters: [
+                {
+                    name: 'optValue',
+                    type: {
+                        kind: 'struct',
+                        path: 'std::option::Option',
+                        fields: [
+                            {
+                                name: '_is_some',
+                                type: {
+                                    kind: 'boolean'
+                                }
+                            },
+                            {
+                                name: '_value',
+                                type: {
+                                    kind: 'field'
+                                }
+                            }
+                        ]
+                    },
+                    visibility: 'private'
+                },
+                {
+                    name: 'aField',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'private'
+                }
+            ],
+            errorTypes: {},
+            bytecode: Buffer.alloc(8, 0xfe),
+            verificationKey: Buffer.alloc(MEGA_APP_VK_LENGTH_IN_FIELDS * Fr.SIZE_IN_BYTES).toString('base64'),
+            debugSymbols: ''
+        }
+    ],
+    nonDispatchPublicFunctions: [],
+    outputs: {
+        structs: {},
+        globals: {}
+    },
+    fileMap: {},
+    storageLayout: {}
+};

package/dest/utils/abi_types.d.ts

@@ -0,0 +1,32 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { EventSelector, FunctionSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+/** Any type that can be converted into a field for a contract call. */
+export type FieldLike = Fr | Buffer | bigint | number | {
+    toField: () => Fr;
+};
+/** Any type that can be converted into an EthAddress Aztec.nr struct. */
+export type EthAddressLike = {
+    address: FieldLike;
+} | EthAddress;
+/** Any type that can be converted into an AztecAddress Aztec.nr struct. */
+export type AztecAddressLike = {
+    address: FieldLike;
+} | AztecAddress;
+/** Any type that can be converted into a FunctionSelector Aztec.nr struct. */
+export type FunctionSelectorLike = FieldLike | FunctionSelector;
+/** Any type that can be converted into an EventSelector Aztec.nr struct. */
+export type EventSelectorLike = FieldLike | EventSelector;
+/** Any type that can be converted into a U128. */
+export type U128Like = bigint | number;
+/** Any type that can be converted into a struct with a single `inner` field. */
+export type WrappedFieldLike = {
+    inner: FieldLike;
+} | FieldLike;
+/** Noir `Option<T>` lowered ABI shape, plus ergonomic direct `T | null | undefined` inputs. */
+export type OptionLike<T> = T | null | undefined | {
+    _is_some: boolean; /** Wrapped value */
+    _value: T;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJpX3R5cGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYWJpX3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzlELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzlFLE9BQU8sS0FBSyxFQUFFLFlBQVksRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBRXJFLHVFQUF1RTtBQUN2RSxNQUFNLE1BQU0sU0FBUyxHQUFHLEVBQUUsR0FBRyxNQUFNLEdBQUcsTUFBTSxHQUFHLE1BQU0sR0FBRztJQUEyQixPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUE7Q0FBRSxDQUFDO0FBRXZHLHlFQUF5RTtBQUN6RSxNQUFNLE1BQU0sY0FBYyxHQUFHO0lBQXlCLE9BQU8sRUFBRSxTQUFTLENBQUE7Q0FBRSxHQUFHLFVBQVUsQ0FBQztBQUV4RiwyRUFBMkU7QUFDM0UsTUFBTSxNQUFNLGdCQUFnQixHQUFHO0lBQXlCLE9BQU8sRUFBRSxTQUFTLENBQUE7Q0FBRSxHQUFHLFlBQVksQ0FBQztBQUU1Riw4RUFBOEU7QUFDOUUsTUFBTSxNQUFNLG9CQUFvQixHQUFHLFNBQVMsR0FBRyxnQkFBZ0IsQ0FBQztBQUVoRSw0RUFBNEU7QUFDNUUsTUFBTSxNQUFNLGlCQUFpQixHQUFHLFNBQVMsR0FBRyxhQUFhLENBQUM7QUFFMUQsa0RBQWtEO0FBQ2xELE1BQU0sTUFBTSxRQUFRLEdBQUcsTUFBTSxHQUFHLE1BQU0sQ0FBQztBQUV2QyxnRkFBZ0Y7QUFDaEYsTUFBTSxNQUFNLGdCQUFnQixHQUFHO0lBQXVCLEtBQUssRUFBRSxTQUFTLENBQUE7Q0FBRSxHQUFHLFNBQVMsQ0FBQztBQUVyRiwrRkFBK0Y7QUFDL0YsTUFBTSxNQUFNLFVBQVUsQ0FBQyxDQUFDLElBQ3BCLENBQUMsR0FDRCxJQUFJLEdBQ0osU0FBUyxHQUNUO0lBQXlDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQyxvQkFBb0I7SUFBQyxNQUFNLEVBQUUsQ0FBQyxDQUFBO0NBQUUsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"abi_types.d.ts","sourceRoot":"","sources":["../../src/utils/abi_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,uEAAuE;AACvE,MAAM,MAAM,SAAS,GAAG,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG;IAA2B,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvG,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG;IAAyB,OAAO,EAAE,SAAS,CAAA;CAAE,GAAG,UAAU,CAAC;AAExF,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG;IAAyB,OAAO,EAAE,SAAS,CAAA;CAAE,GAAG,YAAY,CAAC;AAE5F,8EAA8E;AAC9E,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,gBAAgB,CAAC;AAEhE,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,aAAa,CAAC;AAE1D,kDAAkD;AAClD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvC,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG;IAAuB,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG,SAAS,CAAC;AAErF,+FAA+F;AAC/F,MAAM,MAAM,UAAU,CAAC,CAAC,IACpB,CAAC,GACD,IAAI,GACJ,SAAS,GACT;IAAyC,QAAQ,EAAE,OAAO,CAAC,CAAC,oBAAoB;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC"}

package/dest/utils/abi_types.js

@@ -0,0 +1 @@
+/** Noir `Option<T>` lowered ABI shape, plus ergonomic direct `T | null | undefined` inputs. */ export { };

package/dest/utils/authwit.d.ts

@@ -0,0 +1,119 @@
+import type { ChainInfo } from '@aztec-labs/entrypoints/interfaces';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type FunctionCall } from '@aztec-labs/stdlib/abi';
+import { AuthWitness } from '@aztec-labs/stdlib/auth-witness';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { TxProfileResult } from '@aztec-labs/stdlib/tx';
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+import type { InteractionWaitOptions, ProfileInteractionOptions, SendInteractionOptions, SendInteractionOptionsWithoutWait, SendReturn, SimulateInteractionOptions, SimulationResult, TxSendResultMined } from '../contract/interaction_options.js';
+import type { Wallet } from '../wallet/index.js';
+/** Intent with an inner hash */
+export type IntentInnerHash = {
+    /** The consumer   */
+    consumer: AztecAddress;
+    /** The action to approve */
+    innerHash: Fr;
+};
+/** Intent with a call */
+export type CallIntent = {
+    /** The caller to approve  */
+    caller: AztecAddress;
+    /** The call to approve */
+    call: FunctionCall;
+};
+/** Intent with a ContractFunctionInteraction */
+export type ContractFunctionInteractionCallIntent = {
+    /** The caller to approve  */
+    caller: AztecAddress;
+    /** The action to approve */
+    action: ContractFunctionInteraction;
+};
+/** Identifies ContractFunctionInteractionCallIntents */
+export declare function isContractFunctionInteractionCallIntent(messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent): messageHashOrIntent is ContractFunctionInteractionCallIntent;
+/**
+ * Compute an authentication witness message hash from an intent and metadata
+ *
+ * If using the `IntentInnerHash`, the consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ * The `innerHash` itself will be the message that a contract is allowed to execute.
+ * At the point of "approval checking", the validating contract (account for private and registry for public) will be computing the message hash
+ * (`H(consumer, chainid, version, inner_hash)`) where the all but the `inner_hash` is injected from the context (consumer = msg_sender),
+ * and use it for the authentication check.
+ * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
+ *
+ * If using the `CallIntent`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
+ *
+ *
+ * @param intent - The intent to approve (consumer and innerHash or caller and action)
+ *                 The consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ *                 The caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ *                 The caller becomes part of the `inner_hash` and is dealt with entirely in application logic.
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the action
+ */
+export declare const computeAuthWitMessageHash: (intent: CallIntent | ContractFunctionInteractionCallIntent | IntentInnerHash, metadata: ChainInfo) => Promise<Fr>;
+/**
+ * Compute an authentication witness message hash from an intent and metadata. This is just
+ * a wrapper around computeAuthwitMessageHash that allows receiving an already computed messageHash as input
+ * @param messageHashOrIntent - The precomputed messageHash or intent to approve (consumer and innerHash or caller and call/action)
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the intent
+ */
+export declare function getMessageHashFromIntent(messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, chainInfo: ChainInfo): Promise<Fr>;
+/**
+ * Computes the inner authwitness hash for either a function call or an action, for it to later be combined with the metadata
+ * required for the outer hash and eventually the full AuthWitness.
+ * @param caller - Who is going to be calling the function
+ * @param action - The action to compute the inner hash from
+ * @returns The inner hash for the action
+ **/
+export declare const computeInnerAuthWitHashFromAction: (caller: AztecAddress, action: ContractFunctionInteraction | FunctionCall) => Promise<Fr>;
+/**
+ * Lookup the validity of an authwit in private and public contexts.
+ *
+ * Uses the chain id and version of the wallet.
+ *
+ * @param wallet - The wallet use to simulate and read the public data
+ * @param onBehalfOf - The address of the "approver"
+ * @param intent - The consumer and inner hash or the caller and action to lookup
+ * @param witness - The computed authentication witness to check
+ * @returns - A struct containing the validity of the authwit in private and public contexts.
+ */
+export declare function lookupValidity(wallet: Wallet, onBehalfOf: AztecAddress, intent: IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, witness: AuthWitness): Promise<{
+    /** boolean flag indicating if the authwit is valid in private context */
+    isValidInPrivate: boolean;
+    /** boolean flag indicating if the authwit is valid in public context */
+    isValidInPublic: boolean;
+}>;
+/**
+ * Convenience class designed to wrap the very common interaction of setting a public authwit in the AuthRegistry contract
+ */
+export declare class SetPublicAuthwitContractInteraction extends ContractFunctionInteraction {
+    private from;
+    private constructor();
+    static create(wallet: Wallet, from: AztecAddress, messageHashOrIntent: Fr | IntentInnerHash | CallIntent | ContractFunctionInteractionCallIntent, authorized: boolean): Promise<SetPublicAuthwitContractInteraction>;
+    /**
+     * Overrides the simulate method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - An optional object containing additional configuration for the transaction.
+     * @returns The result of the transaction as returned by the contract function.
+     */
+    simulate(options?: Omit<SimulateInteractionOptions, 'from'>): Promise<SimulationResult>;
+    /**
+     * Overrides the profile method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - Same options as `simulate`, plus profiling method
+     * @returns An object containing the function return value and profile result.
+     */
+    profile(options?: Omit<ProfileInteractionOptions, 'from'>): Promise<TxProfileResult>;
+    /**
+     * Overrides the send method, adding the sender of the authwit (authorizer) as from
+     * and preventing misuse
+     * @param options - An optional object containing 'fee' options information
+     * @returns A TxReceipt (if wait is true/undefined) or TxHash (if wait is false)
+     */
+    send(options?: Omit<SendInteractionOptionsWithoutWait, 'from'>): Promise<TxSendResultMined>;
+    send<W extends InteractionWaitOptions>(options?: Omit<SendInteractionOptions<W>, 'from'>): Promise<SendReturn<W>>;
+    private static getSetAuthorizedAbi;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"authwit.d.ts","sourceRoot":"","sources":["../../src/utils/authwit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAiD,KAAK,YAAY,EAAgB,MAAM,wBAAwB,CAAC;AACxH,OAAO,EAAE,WAAW,EAAoD,MAAM,iCAAiC,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,iCAAiC,EACjC,UAAU,EACV,0BAA0B,EAC1B,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG;IAC5B,qBAAqB;IACrB,QAAQ,EAAE,YAAY,CAAC;IACvB,4BAA4B;IAC5B,SAAS,EAAE,EAAE,CAAC;CACf,CAAC;AAEF,yBAAyB;AACzB,MAAM,MAAM,UAAU,GAAG;IACvB,6BAA6B;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,0BAA0B;IAC1B,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,qCAAqC,GAAG;IAClD,6BAA6B;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,4BAA4B;IAC5B,MAAM,EAAE,2BAA2B,CAAC;CACrC,CAAC;AAEF,wDAAwD;AACxD,wBAAgB,uCAAuC,CACrD,mBAAmB,EAAE,EAAE,GAAG,eAAe,GAAG,UAAU,GAAG,qCAAqC,GAC7F,mBAAmB,IAAI,qCAAqC,CAM9D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,oHAmBrC,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,mBAAmB,EAAE,EAAE,GAAG,eAAe,GAAG,UAAU,GAAG,qCAAqC,EAC9F,SAAS,EAAE,SAAS,eAUrB;AAED;;;;;;IAMI;AACJ,eAAO,MAAM,iCAAiC,2FAM7C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,eAAe,GAAG,UAAU,GAAG,qCAAqC,EAC5E,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC;IACT,yEAAyE;IACzE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,wEAAwE;IACxE,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC,CA4ED;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,2BAA2B;IAGhF,OAAO,CAAC,IAAI;IAFd,OAAO,eAUN;IAED,OAAa,MAAM,CACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,EAClB,mBAAmB,EAAE,EAAE,GAAG,eAAe,GAAG,UAAU,GAAG,qCAAqC,EAC9F,UAAU,EAAE,OAAO,gDAKpB;IAED;;;;;OAKG;IACa,QAAQ,CACtB,OAAO,GAAE,IAAI,CAAC,0BAA0B,EAAE,MAAM,CAAkD,GACjG,OAAO,CAAC,gBAAgB,CAAC,CAE3B;IAED;;;;;OAKG;IACa,OAAO,CACrB,OAAO,GAAE,IAAI,CAAC,yBAAyB,EAAE,MAAM,CAA4B,GAC1E,OAAO,CAAC,eAAe,CAAC,CAE1B;IAED;;;;;OAKG;IACa,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,iCAAiC,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAG5F,IAAI,CAAC,CAAC,SAAS,sBAAsB,EACnD,OAAO,CAAC,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IAQ1B,OAAO,CAAC,MAAM,CAAC,mBAAmB;CAsBnC"}

package/dest/utils/authwit.js

@@ -0,0 +1,266 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { STANDARD_AUTH_REGISTRY_ADDRESS } from '@aztec-labs/standard-contracts/auth-registry/constants';
+import { FunctionType } from '@aztec-labs/stdlib/abi';
+import { computeInnerAuthWitHash, computeOuterAuthWitHash } from '@aztec-labs/stdlib/auth-witness';
+import { computeVarArgsHash } from '@aztec-labs/stdlib/hash';
+import { ContractFunctionInteraction } from '../contract/contract_function_interaction.js';
+/** Identifies ContractFunctionInteractionCallIntents */ export function isContractFunctionInteractionCallIntent(messageHashOrIntent) {
+    return 'caller' in messageHashOrIntent && 'action' in messageHashOrIntent && messageHashOrIntent.action instanceof ContractFunctionInteraction;
+}
+/**
+ * Compute an authentication witness message hash from an intent and metadata
+ *
+ * If using the `IntentInnerHash`, the consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ * The `innerHash` itself will be the message that a contract is allowed to execute.
+ * At the point of "approval checking", the validating contract (account for private and registry for public) will be computing the message hash
+ * (`H(consumer, chainid, version, inner_hash)`) where the all but the `inner_hash` is injected from the context (consumer = msg_sender),
+ * and use it for the authentication check.
+ * Therefore, any allowed `innerHash` will therefore also have information around where it can be spent (version, chainId) and who can spend it (consumer).
+ *
+ * If using the `CallIntent`, the caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ * The action is then used along with the `caller` to compute the `innerHash` and the consumer.
+ *
+ *
+ * @param intent - The intent to approve (consumer and innerHash or caller and action)
+ *                 The consumer is the address that can "consume" the authwit, for token approvals it is the token contract itself.
+ *                 The caller is the address that is making the call, for a token approval from Alice to Bob, this would be Bob.
+ *                 The caller becomes part of the `inner_hash` and is dealt with entirely in application logic.
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the action
+ */ export const computeAuthWitMessageHash = async (intent, metadata)=>{
+    const chainId = metadata.chainId;
+    const version = metadata.version;
+    if ('caller' in intent) {
+        const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+        return computeOuterAuthWitHash(call.to, chainId, version, await computeInnerAuthWitHashFromAction(intent.caller, call));
+    } else {
+        const inner = Buffer.isBuffer(intent.innerHash) ? Fr.fromBuffer(intent.innerHash) : intent.innerHash;
+        return computeOuterAuthWitHash(intent.consumer, chainId, version, inner);
+    }
+};
+/**
+ * Compute an authentication witness message hash from an intent and metadata. This is just
+ * a wrapper around computeAuthwitMessageHash that allows receiving an already computed messageHash as input
+ * @param messageHashOrIntent - The precomputed messageHash or intent to approve (consumer and innerHash or caller and call/action)
+ * @param metadata - The metadata for the intent (chainId, version)
+ * @returns The message hash for the intent
+ */ export async function getMessageHashFromIntent(messageHashOrIntent, chainInfo) {
+    let messageHash;
+    const { chainId, version } = chainInfo;
+    if (messageHashOrIntent instanceof Fr) {
+        messageHash = messageHashOrIntent;
+    } else {
+        messageHash = await computeAuthWitMessageHash(messageHashOrIntent, {
+            chainId,
+            version
+        });
+    }
+    return messageHash;
+}
+/**
+ * Computes the inner authwitness hash for either a function call or an action, for it to later be combined with the metadata
+ * required for the outer hash and eventually the full AuthWitness.
+ * @param caller - Who is going to be calling the function
+ * @param action - The action to compute the inner hash from
+ * @returns The inner hash for the action
+ **/ export const computeInnerAuthWitHashFromAction = async (caller, action)=>{
+    const call = action instanceof ContractFunctionInteraction ? await action.getFunctionCall() : action;
+    return computeInnerAuthWitHash([
+        caller.toField(),
+        call.selector.toField(),
+        await computeVarArgsHash(call.args)
+    ]);
+};
+/**
+ * Lookup the validity of an authwit in private and public contexts.
+ *
+ * Uses the chain id and version of the wallet.
+ *
+ * @param wallet - The wallet use to simulate and read the public data
+ * @param onBehalfOf - The address of the "approver"
+ * @param intent - The consumer and inner hash or the caller and action to lookup
+ * @param witness - The computed authentication witness to check
+ * @returns - A struct containing the validity of the authwit in private and public contexts.
+ */ export async function lookupValidity(wallet, onBehalfOf, intent, witness) {
+    let innerHash, consumer;
+    if ('caller' in intent) {
+        const call = isContractFunctionInteractionCallIntent(intent) ? await intent.action.getFunctionCall() : intent.call;
+        innerHash = await computeInnerAuthWitHashFromAction(intent.caller, call);
+        consumer = call.to;
+    } else {
+        ({ innerHash, consumer } = intent);
+    }
+    const chainInfo = await wallet.getChainInfo();
+    const messageHash = await getMessageHashFromIntent(intent, chainInfo);
+    const results = {
+        isValidInPrivate: false,
+        isValidInPublic: false
+    };
+    // Check private
+    const lookupValidityAbi = {
+        name: 'lookup_validity',
+        isInitializer: false,
+        functionType: FunctionType.UTILITY,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [
+            {
+                name: 'consumer',
+                type: {
+                    fields: [
+                        {
+                            name: 'inner',
+                            type: {
+                                kind: 'field'
+                            }
+                        }
+                    ],
+                    kind: 'struct',
+                    path: 'aztec::protocol_types::address::aztec_address::AztecAddress'
+                },
+                visibility: 'private'
+            },
+            {
+                name: 'inner_hash',
+                type: {
+                    kind: 'field'
+                },
+                visibility: 'private'
+            }
+        ],
+        returnType: {
+            kind: 'boolean'
+        },
+        errorTypes: {}
+    };
+    try {
+        results.isValidInPrivate = (await new ContractFunctionInteraction(wallet, onBehalfOf, lookupValidityAbi, [
+            consumer,
+            innerHash
+        ]).simulate({
+            from: onBehalfOf,
+            authWitnesses: [
+                witness
+            ]
+        })).result;
+    // TODO: Narrow down the error to make sure simulation failed due to an invalid authwit
+    // eslint-disable-next-line no-empty
+    } catch  {}
+    // check public
+    const isConsumableAbi = {
+        name: 'utility_is_consumable',
+        isInitializer: false,
+        functionType: FunctionType.UTILITY,
+        isOnlySelf: false,
+        isStatic: false,
+        parameters: [
+            {
+                name: 'address',
+                type: {
+                    fields: [
+                        {
+                            name: 'inner',
+                            type: {
+                                kind: 'field'
+                            }
+                        }
+                    ],
+                    kind: 'struct',
+                    path: 'authwit::aztec::protocol_types::address::aztec_address::AztecAddress'
+                },
+                visibility: 'private'
+            },
+            {
+                name: 'message_hash',
+                type: {
+                    kind: 'field'
+                },
+                visibility: 'private'
+            }
+        ],
+        returnType: {
+            kind: 'boolean'
+        },
+        errorTypes: {}
+    };
+    results.isValidInPublic = (await new ContractFunctionInteraction(wallet, STANDARD_AUTH_REGISTRY_ADDRESS, isConsumableAbi, [
+        onBehalfOf,
+        messageHash
+    ]).simulate({
+        from: onBehalfOf
+    })).result;
+    return results;
+}
+/**
+ * Convenience class designed to wrap the very common interaction of setting a public authwit in the AuthRegistry contract
+ */ export class SetPublicAuthwitContractInteraction extends ContractFunctionInteraction {
+    from;
+    constructor(wallet, from, messageHash, authorized){
+        super(wallet, STANDARD_AUTH_REGISTRY_ADDRESS, SetPublicAuthwitContractInteraction.getSetAuthorizedAbi(), [
+            messageHash,
+            authorized
+        ]), this.from = from;
+    }
+    static async create(wallet, from, messageHashOrIntent, authorized) {
+        const chainInfo = await wallet.getChainInfo();
+        const messageHash = await getMessageHashFromIntent(messageHashOrIntent, chainInfo);
+        return new SetPublicAuthwitContractInteraction(wallet, from, messageHash, authorized);
+    }
+    /**
+   * Overrides the simulate method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - An optional object containing additional configuration for the transaction.
+   * @returns The result of the transaction as returned by the contract function.
+   */ simulate(options = {}) {
+        return super.simulate({
+            ...options,
+            from: this.from
+        });
+    }
+    /**
+   * Overrides the profile method, adding the sender of the authwit (authorizer) as from
+   * and preventing misuse
+   * @param options - Same options as `simulate`, plus profiling method
+   * @returns An object containing the function return value and profile result.
+   */ profile(options = {
+        profileMode: 'gates'
+    }) {
+        return super.profile({
+            ...options,
+            from: this.from
+        });
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    send(options) {
+        return super.send({
+            ...options,
+            from: this.from
+        });
+    }
+    static getSetAuthorizedAbi() {
+        return {
+            name: 'set_authorized',
+            isInitializer: false,
+            functionType: FunctionType.PUBLIC,
+            isOnlySelf: true,
+            isStatic: false,
+            parameters: [
+                {
+                    name: 'message_hash',
+                    type: {
+                        kind: 'field'
+                    },
+                    visibility: 'private'
+                },
+                {
+                    name: 'authorize',
+                    type: {
+                        kind: 'boolean'
+                    },
+                    visibility: 'private'
+                }
+            ],
+            errorTypes: {}
+        };
+    }
+}

package/dest/utils/cross_chain.d.ts

@@ -0,0 +1,28 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { BlockTag } from '@aztec-labs/stdlib/block';
+import type { AztecNode } from '@aztec-labs/stdlib/interfaces/client';
+/**
+ * Waits for the L1 to L2 message to be ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param opts - Options
+ */
+export declare function waitForL1ToL2MessageReady(node: Pick<AztecNode, 'getBlockData' | 'getL1ToL2MessageIndex'>, l1ToL2MessageHash: Fr, opts: {
+    /** Timeout for the operation in seconds */ timeoutSeconds: number;
+    /**
+     * Chain tip to evaluate readiness against. Defaults to `'latest'`. Set this to the tip the consuming PXE syncs to
+     * (e.g. `'proven'`) so readiness answers whether the message is present at the same block the transaction
+     * simulation will anchor to, not at a newer tip.
+     */
+    chainTip?: BlockTag;
+}): Promise<boolean>;
+/**
+ * Returns whether the L1 to L2 message is ready to be consumed.
+ * @param node - Aztec node instance used to obtain the information about the message
+ * @param l1ToL2MessageHash - Hash of the L1 to L2 message
+ * @param chainTip - Chain tip to evaluate readiness against. Defaults to `'latest'`. Pass the tip the consuming PXE
+ * syncs to (e.g. `'proven'`) so readiness is checked at the block the transaction simulation will anchor to.
+ * @returns True if the message is ready to be consumed, false otherwise
+ */
+export declare function isL1ToL2MessageReady(node: Pick<AztecNode, 'getBlockData' | 'getL1ToL2MessageIndex'>, l1ToL2MessageHash: Fr, chainTip?: BlockTag): Promise<boolean>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3Jvc3NfY2hhaW4uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9jcm9zc19jaGFpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUU5RCxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxzQ0FBc0MsQ0FBQztBQUV0RTs7Ozs7R0FLRztBQUNILHdCQUFnQix5QkFBeUIsQ0FDdkMsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLEVBQUUsY0FBYyxHQUFHLHVCQUF1QixDQUFDLEVBQy9ELGlCQUFpQixFQUFFLEVBQUUsRUFDckIsSUFBSSxFQUFFO0lBQ0osMkNBQTJDLENBQUMsY0FBYyxFQUFFLE1BQU0sQ0FBQztJQUNuRTs7OztPQUlHO0lBQ0gsUUFBUSxDQUFDLEVBQUUsUUFBUSxDQUFDO0NBQ3JCLEdBQ0EsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQU9sQjtBQUVEOzs7Ozs7O0dBT0c7QUFDSCx3QkFBc0Isb0JBQW9CLENBQ3hDLElBQUksRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLGNBQWMsR0FBRyx1QkFBdUIsQ0FBQyxFQUMvRCxpQkFBaUIsRUFBRSxFQUFFLEVBQ3JCLFFBQVEsR0FBRSxRQUFtQixHQUM1QixPQUFPLENBQUMsT0FBTyxDQUFDLENBVWxCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"cross_chain.d.ts","sourceRoot":"","sources":["../../src/utils/cross_chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAEtE;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,GAAG,uBAAuB,CAAC,EAC/D,iBAAiB,EAAE,EAAE,EACrB,IAAI,EAAE;IACJ,2CAA2C,CAAC,cAAc,EAAE,MAAM,CAAC;IACnE;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB,GACA,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,cAAc,GAAG,uBAAuB,CAAC,EAC/D,iBAAiB,EAAE,EAAE,EACrB,QAAQ,GAAE,QAAmB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAUlB"}