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

package/dest/wallet/deploy_account_method.js

@@ -0,0 +1,127 @@
+import { DefaultMultiCallEntrypoint } from '@aztec-labs/entrypoints/multicall';
+import { mergeExecutionPayloads } from '@aztec-labs/stdlib/tx';
+import { UniversalDeployMethod } from '../contract/deploy_method.js';
+import { NO_FROM } from '../contract/interaction_options.js';
+import { AccountEntrypointMetaPaymentMethod } from './account_entrypoint_meta_payment_method.js';
+/**
+ * Modified version of the DeployMethod used to deploy account contracts. Supports deploying
+ * contracts that can pay for their own fee, plus some preconfigured options to avoid errors.
+ */ export class DeployAccountMethod extends UniversalDeployMethod {
+    account;
+    constructor(publicKeys, wallet, artifact, postDeployCtor, salt, immutablesHash, account, args = [], constructorNameOrArtifact, authWitnesses = [], capsules = [], extraHashedArgs = []){
+        super(wallet, {
+            artifact,
+            postDeployCtor,
+            args,
+            constructorNameOrArtifact
+        }, // Account contracts are always deployed universally.
+        {
+            salt,
+            universalDeploy: true,
+            publicKeys,
+            immutablesHash
+        }, {
+            authWitnesses,
+            capsules,
+            extraHashedArgs
+        }), this.account = account;
+    }
+    /**
+   * Returns a FeePaymentMethod that routes the original one provided as an argument
+   * through the account's entrypoint. This allows an account contract to pay
+   * for its own deployment and initialization.
+   *
+   * For more details on how the fee payment routing works see documentation of AccountEntrypointMetaPaymentMethod class.
+   *
+   * @param originalPaymentMethod - originalPaymentMethod The original payment method to be wrapped.
+   * @param feeEntrypointOptions - Optional entrypoint-specific options for wrapping. If not provided, will be auto-computed based on the payment method.
+   * @returns A FeePaymentMethod that routes the original one through the account's entrypoint (AccountEntrypointMetaPaymentMethod)
+   */ async getSelfFeePaymentMethod(originalPaymentMethod, feeEntrypointOptions) {
+        const chainInfo = await this.wallet.getChainInfo();
+        return new AccountEntrypointMetaPaymentMethod(this.account, chainInfo, originalPaymentMethod, feeEntrypointOptions);
+    }
+    /**
+   * Returns the execution payload that allows this operation to happen on chain.
+   * For self-deployments (from === NO_FROM), the payload is wrapped through the
+   * multicall entrypoint on the app side so the wallet can execute it directly.
+   * @param opts - Configuration options.
+   * @returns The execution payload for this operation
+   */ async request(opts) {
+        const optionsWithDefaults = {
+            ...opts,
+            skipClassPublication: opts?.skipClassPublication ?? true,
+            skipInstancePublication: opts?.skipInstancePublication ?? true,
+            skipInitialization: opts?.skipInitialization ?? false
+        };
+        // Override the fee to undefined, since we'll replace it
+        const deploymentExecutionPayload = await super.request({
+            ...optionsWithDefaults,
+            fee: undefined
+        });
+        const executionPayloads = [
+            deploymentExecutionPayload
+        ];
+        // If this is a self-paid deployment (the to-be-deployed account pays for its own deploy),
+        // wrap the payload through the multicall entrypoint after attaching the fee.
+        if (opts?.from === NO_FROM) {
+            const feePaymentMethod = await this.getSelfFeePaymentMethod(opts?.fee?.paymentMethod, opts?.fee?.feeEntrypointOptions);
+            const feeExecutionPayload = await feePaymentMethod.getExecutionPayload();
+            // Notice they are reversed (fee payment usually goes first):
+            // this is because we need to construct the contract BEFORE it can pay for its own fee
+            executionPayloads.push(feeExecutionPayload);
+            // Wrap the merged payload through the multicall entrypoint,
+            // producing a single-call payload that DefaultEntrypoint can execute directly.
+            const multicall = new DefaultMultiCallEntrypoint();
+            const chainInfo = await this.wallet.getChainInfo();
+            return multicall.wrapExecutionPayload(mergeExecutionPayloads(executionPayloads), chainInfo);
+        } else {
+            const feeExecutionPayload = opts?.fee?.paymentMethod ? await opts.fee.paymentMethod.getExecutionPayload() : undefined;
+            if (feeExecutionPayload) {
+                executionPayloads.unshift(feeExecutionPayload);
+            }
+            return mergeExecutionPayloads(executionPayloads);
+        }
+    }
+    convertDeployOptionsToSendOptions(options) {
+        return super.convertDeployOptionsToSendOptions(this.prepareDeployOptions(options));
+    }
+    convertDeployOptionsToSimulateOptions(options) {
+        return super.convertDeployOptionsToSimulateOptions(this.prepareDeployOptions(options));
+    }
+    convertDeployOptionsToProfileOptions(options) {
+        return super.convertDeployOptionsToProfileOptions(this.prepareDeployOptions(options));
+    }
+    /**
+   * Augments deploy options so that the PXE has the context it needs to simulate/prove the deploy.
+   *
+   * - Injects the contract's own address into scopes so the constructor can access its own keys.
+   * - When `from === NO_FROM` (self-paid deploy), supplies the to-be-deployed address as `sendMessagesAs`. Without
+   *   this, fee-payment calls would have no sender for message tagging, and any private log they emit would fail
+   *   the "Sender for tags is not set" assertion.
+   *
+   * Note: this reads the cached instance synchronously via `getCachedInstance()`. Because every code path that
+   * calls `prepareDeployOptions` (send/simulate/profile) flows through `request()` first, which calls
+   * `getInstance()`, the cache is always populated by the time we get here.
+   *
+   * @param options - The deploy options to augment.
+   */ prepareDeployOptions(options) {
+        const { address } = this.getCachedInstanceOrThrow();
+        const existing = options.additionalScopes ?? [];
+        const sendMessagesAs = options.sendMessagesAs ?? (options.from === NO_FROM ? address : undefined);
+        return {
+            ...options,
+            additionalScopes: [
+                ...existing,
+                address
+            ],
+            sendMessagesAs
+        };
+    }
+    /**
+   * Augments this DeployAccountMethod with additional metadata, such as authWitnesses and capsules.
+   * @param options - An object containing the metadata to add to the interaction
+   * @returns A new DeployAccountMethod with the added metadata
+   */ with({ authWitnesses = [], capsules = [], extraHashedArgs = [] }) {
+        return new DeployAccountMethod(this.publicKeys, this.wallet, this.artifact, this.postDeployCtor, this.salt, this.immutablesHash, this.account, this.args, this.constructorArtifact?.name, this.authWitnesses.concat(authWitnesses), this.capsules.concat(capsules), this.extraHashedArgs.concat(extraHashedArgs));
+    }
+}

package/dest/wallet/index.d.ts

@@ -0,0 +1,5 @@
+export * from './wallet.js';
+export * from './account_manager.js';
+export * from './capabilities.js';
+export * from './tx_simulation_result_with_app_offset.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy93YWxsZXQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMkNBQTJDLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wallet/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2CAA2C,CAAC"}

package/dest/wallet/index.js

@@ -0,0 +1,4 @@
+export * from './wallet.js';
+export * from './account_manager.js';
+export * from './capabilities.js';
+export * from './tx_simulation_result_with_app_offset.js';

package/dest/wallet/tx_simulation_result_with_app_offset.d.ts

@@ -0,0 +1,40 @@
+import type { ZodFor } from '@aztec-labs/foundation/schemas';
+import { PrivateKernelTailCircuitPublicInputs } from '@aztec-labs/stdlib/kernel';
+import { type NestedProcessReturnValues, PrivateExecutionResult, PublicSimulationOutput, type SimulationStats, TxSimulationResult } from '@aztec-labs/stdlib/tx';
+/**
+ * Extends TxSimulationResult with the app call offset, which tracks where the app's calls begin in the flattened
+ * array of calls. Tracking of app call offset is a wallet-level concern: the wallet may wrap the app payload in an
+ * entrypoint or may prepend calls (this is typically done for fee payments).
+ */
+export declare class TxSimulationResultWithAppOffset extends TxSimulationResult {
+    /**
+     * Index of the app's first call in a flattened array of calls.
+     *   0 = app call is the root execution itself (DefaultEntrypoint / NO_FROM).
+     *   1..N = wallet prepended calls before the app call.
+     *   undefined = wallet did not send the field; use heuristic fallback.
+     */
+    readonly appCallOffset: number | undefined;
+    constructor(privateExecutionResult: PrivateExecutionResult, publicInputs: PrivateKernelTailCircuitPublicInputs, publicOutput?: PublicSimulationOutput, stats?: SimulationStats, 
+    /**
+     * Index of the app's first call in a flattened array of calls.
+     *   0 = app call is the root execution itself (DefaultEntrypoint / NO_FROM).
+     *   1..N = wallet prepended calls before the app call.
+     *   undefined = wallet did not send the field; use heuristic fallback.
+     */
+    appCallOffset?: number | undefined);
+    /**
+     * Returns the private return values that correspond to the provided app call.
+     * @param appCallIndex - Index of the app call within the app calls.
+     */
+    getPrivateReturnValuesOfAppCall(appCallIndex?: number): NestedProcessReturnValues | undefined;
+    /**
+     * Creates a TxSimulationResultWithAppOffset from an existing TxSimulationResult, attaching the app call offset
+     * computed by the wallet (i.e. how many calls precede the first app call in the flattened execution tree).
+     * @param result - The simulation result to wrap.
+     * @param appCallOffset - The index of the app's first call in the flattened execution tree.
+     */
+    static fromResultAndOffset(result: TxSimulationResult, appCallOffset: number): TxSimulationResultWithAppOffset;
+    static random(): Promise<TxSimulationResultWithAppOffset>;
+    static get schema(): ZodFor<TxSimulationResultWithAppOffset>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfc2ltdWxhdGlvbl9yZXN1bHRfd2l0aF9hcHBfb2Zmc2V0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L3R4X3NpbXVsYXRpb25fcmVzdWx0X3dpdGhfYXBwX29mZnNldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUU3RCxPQUFPLEVBQUUsb0NBQW9DLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRixPQUFPLEVBQ0wsS0FBSyx5QkFBeUIsRUFDOUIsc0JBQXNCLEVBQ3RCLHNCQUFzQixFQUN0QixLQUFLLGVBQWUsRUFFcEIsa0JBQWtCLEVBQ25CLE1BQU0sdUJBQXVCLENBQUM7QUFHL0I7Ozs7R0FJRztBQUNILHFCQUFhLCtCQUFnQyxTQUFRLGtCQUFrQjtJQU1uRTs7Ozs7T0FLRzthQUNhLGFBQWEsRUFBRSxNQUFNLEdBQUcsU0FBUztJQVhuRCxZQUNFLHNCQUFzQixFQUFFLHNCQUFzQixFQUM5QyxZQUFZLEVBQUUsb0NBQW9DLEVBQ2xELFlBQVksQ0FBQyxFQUFFLHNCQUFzQixFQUNyQyxLQUFLLENBQUMsRUFBRSxlQUFlO0lBQ3ZCOzs7OztPQUtHO0lBQ2EsYUFBYSxHQUFFLE1BQU0sR0FBRyxTQUFxQixFQUc5RDtJQUVEOzs7T0FHRztJQUNILCtCQUErQixDQUFDLFlBQVksR0FBRSxNQUFVLEdBQUcseUJBQXlCLEdBQUcsU0FBUyxDQXVCL0Y7SUFFRDs7Ozs7T0FLRztJQUNILE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsYUFBYSxFQUFFLE1BQU0sR0FBRywrQkFBK0IsQ0FRN0c7SUFFRCxPQUFzQixNQUFNLDZDQUczQjtJQUVELFdBQW9CLE1BQU0sSUFBSSxNQUFNLENBQUMsK0JBQStCLENBQUMsQ0FhcEU7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_simulation_result_with_app_offset.d.ts","sourceRoot":"","sources":["../../src/wallet/tx_simulation_result_with_app_offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAE7D,OAAO,EAAE,oCAAoC,EAAE,MAAM,2BAA2B,CAAC;AACjF,OAAO,EACL,KAAK,yBAAyB,EAC9B,sBAAsB,EACtB,sBAAsB,EACtB,KAAK,eAAe,EAEpB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAG/B;;;;GAIG;AACH,qBAAa,+BAAgC,SAAQ,kBAAkB;IAMnE;;;;;OAKG;aACa,aAAa,EAAE,MAAM,GAAG,SAAS;IAXnD,YACE,sBAAsB,EAAE,sBAAsB,EAC9C,YAAY,EAAE,oCAAoC,EAClD,YAAY,CAAC,EAAE,sBAAsB,EACrC,KAAK,CAAC,EAAE,eAAe;IACvB;;;;;OAKG;IACa,aAAa,GAAE,MAAM,GAAG,SAAqB,EAG9D;IAED;;;OAGG;IACH,+BAA+B,CAAC,YAAY,GAAE,MAAU,GAAG,yBAAyB,GAAG,SAAS,CAuB/F;IAED;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,MAAM,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,GAAG,+BAA+B,CAQ7G;IAED,OAAsB,MAAM,6CAG3B;IAED,WAAoB,MAAM,IAAI,MAAM,CAAC,+BAA+B,CAAC,CAapE;CACF"}

package/dest/wallet/tx_simulation_result_with_app_offset.js

@@ -0,0 +1,65 @@
+import { optional } from '@aztec-labs/foundation/schemas';
+import { PrivateKernelTailCircuitPublicInputs } from '@aztec-labs/stdlib/kernel';
+import { PrivateExecutionResult, PublicSimulationOutput, SimulationStatsSchema, TxSimulationResult } from '@aztec-labs/stdlib/tx';
+import { z } from 'zod';
+/**
+ * Extends TxSimulationResult with the app call offset, which tracks where the app's calls begin in the flattened
+ * array of calls. Tracking of app call offset is a wallet-level concern: the wallet may wrap the app payload in an
+ * entrypoint or may prepend calls (this is typically done for fee payments).
+ */ export class TxSimulationResultWithAppOffset extends TxSimulationResult {
+    appCallOffset;
+    constructor(privateExecutionResult, publicInputs, publicOutput, stats, /**
+     * Index of the app's first call in a flattened array of calls.
+     *   0 = app call is the root execution itself (DefaultEntrypoint / NO_FROM).
+     *   1..N = wallet prepended calls before the app call.
+     *   undefined = wallet did not send the field; use heuristic fallback.
+     */ appCallOffset = undefined){
+        super(privateExecutionResult, publicInputs, publicOutput, stats), this.appCallOffset = appCallOffset;
+    }
+    /**
+   * Returns the private return values that correspond to the provided app call.
+   * @param appCallIndex - Index of the app call within the app calls.
+   */ getPrivateReturnValuesOfAppCall(appCallIndex = 0) {
+        const all = this.getPrivateReturnValues();
+        if (this.appCallOffset === undefined) {
+            // appCallOffset was not sent. Apply the pre-offset heuristic for backwards compatibility.
+            // If there are nested calls, the app was wrapped in an account contract entrypoint and its return values
+            // live in nested[appCallIndex]. Otherwise the app call is the root execution.
+            if ((all?.nested?.length ?? 0) > 0) {
+                return all?.nested?.[appCallIndex];
+            }
+            if (appCallIndex !== 0) {
+                throw new Error('App call index cannot be defined when there is single root app call');
+            }
+            return all;
+        }
+        // appCallOffset is defined on the flattened array of calls where entrypoint occupies index 0 and the app's
+        // first call occupies index appCallOffset. appCallIndex 0 with appCallOffset 0 means the root itself.
+        if (this.appCallOffset === 0 && appCallIndex === 0) {
+            return all;
+        }
+        // For all other cases, index into nested: subtract 1 because nested[0] corresponds to flat index 1 (first nested).
+        return all?.nested?.[appCallIndex + this.appCallOffset - 1];
+    }
+    /**
+   * Creates a TxSimulationResultWithAppOffset from an existing TxSimulationResult, attaching the app call offset
+   * computed by the wallet (i.e. how many calls precede the first app call in the flattened execution tree).
+   * @param result - The simulation result to wrap.
+   * @param appCallOffset - The index of the app's first call in the flattened execution tree.
+   */ static fromResultAndOffset(result, appCallOffset) {
+        return new TxSimulationResultWithAppOffset(result.privateExecutionResult, result.publicInputs, result.publicOutput, result.stats, appCallOffset);
+    }
+    static async random() {
+        const base = await TxSimulationResult.random();
+        return TxSimulationResultWithAppOffset.fromResultAndOffset(base, 0);
+    }
+    static get schema() {
+        return z.object({
+            privateExecutionResult: PrivateExecutionResult.schema,
+            publicInputs: PrivateKernelTailCircuitPublicInputs.schema,
+            publicOutput: PublicSimulationOutput.schema.optional(),
+            stats: optional(SimulationStatsSchema),
+            appCallOffset: optional(z.number())
+        }).transform(({ privateExecutionResult, publicInputs, publicOutput, stats, appCallOffset })=>new TxSimulationResultWithAppOffset(privateExecutionResult, publicInputs, publicOutput, stats, appCallOffset));
+    }
+}