@aztec/aztec 0.0.1-commit.42ee6df9b → 0.0.1-commit.431c48d

package/dest/deploy/fees.js

@@ -0,0 +1,278 @@
+/**
+ * Fee handling for the deploy framework. Each account pays per its own {@link FeePolicy} — which
+ * may override the spec-wide default:
+ *
+ * - `sponsored`  → a SponsoredFPC pays (the local-network default). All sponsored accounts share
+ *   one payment method.
+ * - `fee-juice`  → the account pays from its own Fee Juice; if below `threshold` with work to do,
+ *   bridge `fundAmount` from L1. The bridge claim is single-use: the first paying tx claims it
+ *   (`FeeJuicePaymentMethodWithClaim`) and the rest spend the balance. Pending claims are persisted
+ *   (see ./state.ts) so a crash between bridge and claim resumes.
+ */ import { FeeJuicePaymentMethodWithClaim, SponsoredFeePaymentMethod } from '@aztec/aztec.js/fee';
+import { Fr } from '@aztec/aztec.js/fields';
+import { FeeJuiceContract } from '@aztec/aztec.js/protocol';
+import { registerDeployedSponsoredFPCInWalletAndGetAddress } from '../local-network/sponsored_fpc.js';
+import { bridgeFeeJuice, waitForL1ToL2Message } from './bridging.js';
+/** Anvil's first pre-funded dev key — used as the local-network L1 funder. Published, non-secret. */ const ANVIL_DEV_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const DEFAULT_LOCAL_L1_RPC_URL = 'http://localhost:8545';
+const DEFAULT_LOCAL_L1_CHAIN_ID = 31337;
+/**
+ * Sane fee defaults: local pays via SponsoredFPC; every other network pays from bridged Fee Juice.
+ * The threshold/fundAmount pair trades off L1 round-trips (too low → frequent re-bridges) against
+ * stranding Fee Juice, which is non-transferable, on the account (too high).
+ */ export function defaultFeePolicy(local) {
+    if (local) {
+        return {
+            kind: 'sponsored'
+        };
+    }
+    return {
+        kind: 'fee-juice',
+        threshold: 100n * 10n ** 18n,
+        fundAmount: 1000n * 10n ** 18n
+    };
+}
+/** The public Fee Juice balance of `address` (any address — contract or account), read via `from`. */ export async function publicFeeJuiceBalance(wallet, address, from) {
+    const { result } = await FeeJuiceContract.at(wallet).methods.balance_of_public(address).simulate({
+        from
+    });
+    return BigInt(result.toString());
+}
+/**
+ * Resolves an account's funding posture under `policy` — what the plan reports and what
+ * {@link prepareFeeSession} acts on. `idle` accounts (no pending work) are never funded; sponsored
+ * accounts never read a balance; fee-juice accounts are `funded` iff their balance clears the
+ * threshold, else `not-funded` (a bridge will top them up).
+ */ export async function accountFunding(policy, wallet, account, hasWork) {
+    if (!hasWork) {
+        return {
+            kind: 'idle'
+        };
+    }
+    if (policy.kind === 'sponsored') {
+        return {
+            kind: 'sponsored'
+        };
+    }
+    const balance = await publicFeeJuiceBalance(wallet, account, account);
+    return balance >= policy.threshold ? {
+        kind: 'funded',
+        balance
+    } : {
+        kind: 'not-funded',
+        balance,
+        fundAmount: policy.fundAmount
+    };
+}
+/**
+ * Resolves the L1 connection + funder for a bridge from caller-supplied config, defaulting to anvil
+ * on local. The funder key falls back to anvil's dev key on local (its faucet `mint` is owner-gated,
+ * so an ephemeral key is rejected there); elsewhere an omitted key means an ephemeral key + the
+ * public faucet. Deliberately no env fallback — the framework never reads the environment.
+ */ function resolveL1Config(local, cfg) {
+    const l1RpcUrl = cfg.l1RpcUrl ?? (local ? DEFAULT_LOCAL_L1_RPC_URL : undefined);
+    const l1ChainId = cfg.l1ChainId ?? (local ? DEFAULT_LOCAL_L1_CHAIN_ID : undefined);
+    if (l1RpcUrl === undefined || l1ChainId === undefined) {
+        throw new Error('Bridging on a non-local network requires `l1RpcUrl` and `l1ChainId` (no hardcoded defaults).');
+    }
+    return {
+        l1RpcUrl,
+        l1ChainId,
+        l1PrivateKey: cfg.l1FunderKey ?? (local ? ANVIL_DEV_KEY : undefined)
+    };
+}
+/**
+ * A single-use Fee Juice claim for `recipient` (used by `fund` steps): resumes the persisted claim
+ * when present, else bridges `amount` from L1 and waits for the L1→L2 message. The claim persists
+ * before the wait, so a crash mid-wait resumes it instead of stranding the bridged funds. The
+ * caller consumes it (e.g. via `FeeJuice.claim`) and calls `onConsumed` once that tx mines.
+ */ export async function obtainFeeJuiceClaim(opts) {
+    const { local, node, nodeUrl, recipient, state, persist, reporter } = opts;
+    // Prefixed so a recipient that is also an auto-funded sender doesn't collide with its account claim.
+    const key = `fund:${recipient.toString()}`;
+    let claim;
+    const stored = state.pendingClaims[key];
+    if (stored) {
+        reporter.onBridge?.({
+            recipient,
+            amount: BigInt(stored.claimAmount),
+            reused: true
+        });
+        claim = {
+            claimAmount: BigInt(stored.claimAmount),
+            claimSecret: Fr.fromString(stored.claimSecret),
+            messageLeafIndex: BigInt(stored.messageLeafIndex)
+        };
+    } else {
+        reporter.onBridge?.({
+            recipient,
+            amount: opts.amount,
+            reused: false
+        });
+        const { l1RpcUrl, l1ChainId, l1PrivateKey } = resolveL1Config(local, opts.l1);
+        const bridged = await bridgeFeeJuice({
+            node,
+            recipient,
+            l1RpcUrl,
+            l1ChainId,
+            amount: opts.amount,
+            l1PrivateKey
+        });
+        state.pendingClaims[key] = {
+            claimAmount: bridged.claimAmount.toString(),
+            claimSecret: bridged.claimSecret.toString(),
+            messageLeafIndex: bridged.messageLeafIndex.toString()
+        };
+        persist();
+        await waitForL1ToL2Message({
+            node,
+            messageHash: Fr.fromHexString(bridged.messageHash),
+            mode: local ? 'warp' : 'poll',
+            ...nodeUrl ? {
+                warpOpts: {
+                    nodeUrl
+                }
+            } : {}
+        });
+        claim = {
+            claimAmount: bridged.claimAmount,
+            claimSecret: bridged.claimSecret,
+            messageLeafIndex: bridged.messageLeafIndex
+        };
+    }
+    return {
+        ...claim,
+        onConsumed: ()=>{
+            delete state.pendingClaims[key];
+            persist();
+        }
+    };
+}
+/**
+ * Resolves fees ahead of execution, per account: registers the shared SponsoredFPC (for sponsored
+ * accounts), or tops up a fee-juice account via a bridge (reusing a persisted pending claim when
+ * present). Returns a {@link FeeSession} that dispenses the right fee per tx, by sending account.
+ */ export async function prepareFeeSession(opts) {
+    const { local, node, nodeUrl, wallet, accounts, state, persist, reporter } = opts;
+    // Shared sponsored payment method: register the SponsoredFPC + read gas once, if anyone uses it.
+    let sponsoredFee;
+    if (accounts.some((a)=>a.policy.kind === 'sponsored')) {
+        const sponsoredFPCAddress = await registerDeployedSponsoredFPCInWalletAndGetAddress(wallet);
+        sponsoredFee = {
+            paymentMethod: new SponsoredFeePaymentMethod(sponsoredFPCAddress),
+            // 10x headroom because this one quote is reused for every tx in the run (the wallet's default would re-quote
+            // per tx at 1.5x min): congestion pricing can push the min fee well past the starting quote over a run of
+            // parallel layers. Overstating the cap is free — txs pay the going rate, not the cap, and the FPC pays anyway.
+            gasSettings: {
+                maxFeesPerGas: (await node.getCurrentMinFees()).mul(10)
+            }
+        };
+    }
+    // Bridge fee-juice top-ups. The L1 sends stay sequential — a shared funder key would collide on
+    // nonces — but the L1→L2 availability waits (the minutes-long part on a real network) run
+    // concurrently afterwards. Warp-mode waits run inline instead: warping manipulates global time,
+    // so concurrent warps would fight. Each claim persists as soon as it exists on L1, so a crash
+    // mid-wait resumes it instead of stranding the bridged funds; a resumed claim skips the wait (by
+    // resume time the message is available on any live network).
+    const claims = new Map();
+    const messageWaits = [];
+    for (const { address, policy, funding } of accounts){
+        if (policy.kind !== 'fee-juice' || funding.kind === 'funded') {
+            continue;
+        }
+        const key = address.toString();
+        let stored = state.pendingClaims[key];
+        if (stored) {
+            reporter.onBridge?.({
+                recipient: address,
+                amount: BigInt(stored.claimAmount),
+                reused: true
+            });
+        } else {
+            reporter.onBridge?.({
+                recipient: address,
+                amount: policy.fundAmount,
+                reused: false
+            });
+            // Local defaults to anvil; a non-local network must supply L1 connection details.
+            const { l1ChainId, l1RpcUrl, l1PrivateKey } = resolveL1Config(local, policy);
+            const bridged = await bridgeFeeJuice({
+                node,
+                recipient: address,
+                l1RpcUrl,
+                l1ChainId,
+                amount: policy.fundAmount,
+                l1PrivateKey
+            });
+            stored = {
+                claimAmount: bridged.claimAmount.toString(),
+                claimSecret: bridged.claimSecret.toString(),
+                messageLeafIndex: bridged.messageLeafIndex.toString()
+            };
+            state.pendingClaims[key] = stored;
+            persist();
+            const wait = waitForL1ToL2Message({
+                node,
+                messageHash: Fr.fromHexString(bridged.messageHash),
+                mode: local ? 'warp' : 'poll',
+                ...nodeUrl ? {
+                    warpOpts: {
+                        nodeUrl
+                    }
+                } : {}
+            });
+            if (local) {
+                await wait;
+            } else {
+                messageWaits.push(wait);
+            }
+        }
+        claims.set(key, new FeeJuicePaymentMethodWithClaim(address, {
+            claimAmount: BigInt(stored.claimAmount),
+            claimSecret: Fr.fromString(stored.claimSecret),
+            messageLeafIndex: BigInt(stored.messageLeafIndex)
+        }));
+    }
+    await Promise.all(messageWaits);
+    // Per-account dispenser state. A claim is single-use: the first `next()` for its account carries
+    // it, and `onConsumed` (invoked by the runner once that tx mines) drops the persisted resume entry.
+    const sessions = new Map();
+    for (const { address, policy } of accounts){
+        const key = address.toString();
+        sessions.set(key, {
+            sponsored: policy.kind === 'sponsored',
+            claim: claims.get(key)
+        });
+    }
+    return {
+        next: (account)=>{
+            const key = account.toString();
+            const session = sessions.get(key);
+            if (session?.sponsored) {
+                return {
+                    fee: sponsoredFee ?? {},
+                    onConsumed: ()=>{}
+                };
+            }
+            if (session?.claim) {
+                const claim = session.claim;
+                session.claim = undefined; // single-use: only this first tx carries it
+                return {
+                    fee: {
+                        paymentMethod: claim
+                    },
+                    onConsumed: ()=>{
+                        // claim is now spent on-chain; drop its resume entry
+                        delete state.pendingClaims[key];
+                        persist();
+                    }
+                };
+            }
+            return {
+                fee: {},
+                onConsumed: ()=>{}
+            }; // later txs (or already-funded): pay from the account's balance
+        },
+        hasPendingClaim: (account)=>sessions.get(account.toString())?.claim !== undefined
+    };
+}

package/dest/deploy/graph.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Dependency-graph utilities for the deploy framework: topological layering (which steps
+ * can run together) and a pretty-printer for the resulting plan.
+ */
+/**
+ * Group `nodes` into dependency layers (Kahn's algorithm). Each layer contains nodes whose
+ * dependencies all sit in earlier layers, so a layer's nodes are mutually independent and
+ * may run in parallel. Dependencies pointing outside `nodes` (e.g. already-satisfied work)
+ * are treated as satisfied. Throws on a cycle.
+ */
+export declare function topologicalLayers(nodes: string[], dependencies: Map<string, string[]>): string[][];
+/**
+ * Like {@link topologicalLayers}, but nodes for which `floatLate(node)` is true are scheduled as
+ * LATE as their dependents allow (ALAP) instead of as early as possible. Used to push batchable
+ * actions into the latest layer they can share, so same-account actions in adjacent layers coalesce
+ * into one tx. Fixed nodes (e.g. contract publishes, which unblock dependents and don't batch) keep
+ * their earliest layer; the relative order — and so the critical-path length — is unchanged. Throws
+ * on a cycle (via {@link topologicalLayers}).
+ */
+export declare function scheduleLayers(nodes: string[], dependencies: Map<string, string[]>, floatLate: (node: string) => boolean): string[][];
+/** One node in the printed plan. */
+export interface PlanRow {
+    /** e.g. "goCoin" */
+    name: string;
+    /** short tag, e.g. "Token · publishes class" */
+    tag?: string;
+    /** dependency names to show as `← a, b` */
+    dependencies?: string[];
+}
+/**
+ * Render a titled flat list of plan rows (no layer grouping). Use for the declared-contracts
+ * overview, whose `← ...` arrows are constructor-arg references — not an execution order.
+ */
+export declare function formatList(title: string, rows: PlanRow[]): string;
+/**
+ * Render a titled, layer-grouped section of the plan as an indented tree. Each layer's txs are
+ * submitted in parallel.
+ */
+export declare function formatLayers(title: string, layers: PlanRow[][]): string;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhcGguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZXBsb3kvZ3JhcGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUg7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsaUJBQWlCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxFQUFFLFlBQVksRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxDQUFDLEdBQUcsTUFBTSxFQUFFLEVBQUUsQ0FpQmxHO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILHdCQUFnQixjQUFjLENBQzVCLEtBQUssRUFBRSxNQUFNLEVBQUUsRUFDZixZQUFZLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsQ0FBQyxFQUNuQyxTQUFTLEVBQUUsQ0FBQyxJQUFJLEVBQUUsTUFBTSxLQUFLLE9BQU8sR0FDbkMsTUFBTSxFQUFFLEVBQUUsQ0ErQ1o7QUFFRCxvQ0FBb0M7QUFDcEMsTUFBTSxXQUFXLE9BQU87SUFDdEIsb0JBQW9CO0lBQ3BCLElBQUksRUFBRSxNQUFNLENBQUM7SUFDYixpREFBZ0Q7SUFDaEQsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ2IsNkNBQTJDO0lBQzNDLFlBQVksQ0FBQyxFQUFFLE1BQU0sRUFBRSxDQUFDO0NBQ3pCO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLFVBQVUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsR0FBRyxNQUFNLENBV2pFO0FBRUQ7OztHQUdHO0FBQ0gsd0JBQWdCLFlBQVksQ0FBQyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsRUFBRSxHQUFHLE1BQU0sQ0FjdkUifQ==

package/dest/deploy/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/deploy/graph.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAiBlG;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACnC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACnC,MAAM,EAAE,EAAE,CA+CZ;AAED,oCAAoC;AACpC,MAAM,WAAW,OAAO;IACtB,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,6CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAWjE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,GAAG,MAAM,CAcvE"}

package/dest/deploy/graph.js

@@ -0,0 +1,120 @@
+/**
+ * Dependency-graph utilities for the deploy framework: topological layering (which steps
+ * can run together) and a pretty-printer for the resulting plan.
+ */ /**
+ * Group `nodes` into dependency layers (Kahn's algorithm). Each layer contains nodes whose
+ * dependencies all sit in earlier layers, so a layer's nodes are mutually independent and
+ * may run in parallel. Dependencies pointing outside `nodes` (e.g. already-satisfied work)
+ * are treated as satisfied. Throws on a cycle.
+ */ export function topologicalLayers(nodes, dependencies) {
+    const remaining = new Set(nodes);
+    const layers = [];
+    while(remaining.size > 0){
+        // A node is ready when every dependency already sits in an earlier layer (i.e. is no longer in `remaining`).
+        const layer = [
+            ...remaining
+        ].filter((node)=>(dependencies.get(node) ?? []).every((dependency)=>!remaining.has(dependency)));
+        if (layer.length === 0) {
+            throw new Error(`Dependency cycle among: ${[
+                ...remaining
+            ].join(', ')}`);
+        }
+        for (const node of layer){
+            remaining.delete(node);
+        }
+        layers.push(layer);
+    }
+    return layers;
+}
+/**
+ * Like {@link topologicalLayers}, but nodes for which `floatLate(node)` is true are scheduled as
+ * LATE as their dependents allow (ALAP) instead of as early as possible. Used to push batchable
+ * actions into the latest layer they can share, so same-account actions in adjacent layers coalesce
+ * into one tx. Fixed nodes (e.g. contract publishes, which unblock dependents and don't batch) keep
+ * their earliest layer; the relative order — and so the critical-path length — is unchanged. Throws
+ * on a cycle (via {@link topologicalLayers}).
+ */ export function scheduleLayers(nodes, dependencies, floatLate) {
+    const asap = topologicalLayers(nodes, dependencies);
+    if (asap.length === 0) {
+        return [];
+    }
+    const lastLayer = asap.length - 1;
+    const nodeSet = new Set(nodes);
+    const layerOf = new Map();
+    for (const [index, layer] of asap.entries()){
+        for (const node of layer){
+            layerOf.set(node, index);
+        }
+    }
+    // Reverse adjacency: which in-set nodes depend on each node.
+    const dependents = new Map();
+    for (const node of nodes){
+        for (const dependency of dependencies.get(node) ?? []){
+            if (!nodeSet.has(dependency)) {
+                continue;
+            }
+            const list = dependents.get(dependency);
+            if (list) {
+                list.push(node);
+            } else {
+                dependents.set(dependency, [
+                    node
+                ]);
+            }
+        }
+    }
+    // Push floating nodes as late as possible, visiting in reverse topological order (the flattened
+    // ASAP order reversed) so every node is placed after all of its dependents are placed.
+    for (const node of asap.flat().reverse()){
+        if (!floatLate(node)) {
+            continue;
+        }
+        const deps = dependents.get(node) ?? [];
+        const latest = deps.length === 0 ? lastLayer : Math.min(...deps.map((d)=>layerOf.get(d))) - 1;
+        layerOf.set(node, Math.max(layerOf.get(node), latest));
+    }
+    const layers = Array.from({
+        length: asap.length
+    }, ()=>[]);
+    for (const node of nodes){
+        layers[layerOf.get(node)].push(node);
+    }
+    return layers.filter((layer)=>layer.length > 0);
+}
+/**
+ * Render a titled flat list of plan rows (no layer grouping). Use for the declared-contracts
+ * overview, whose `← ...` arrows are constructor-arg references — not an execution order.
+ */ export function formatList(title, rows) {
+    if (rows.length === 0) {
+        return `${title}: (none)`;
+    }
+    const lines = [
+        `${title}:`
+    ];
+    for (const row of rows){
+        const dependencies = row.dependencies && row.dependencies.length ? `  ← ${row.dependencies.join(', ')}` : '';
+        const tag = row.tag ? `  [${row.tag}]` : '';
+        lines.push(`  ${row.name}${tag}${dependencies}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Render a titled, layer-grouped section of the plan as an indented tree. Each layer's txs are
+ * submitted in parallel.
+ */ export function formatLayers(title, layers) {
+    if (layers.length === 0) {
+        return `${title}: (none)`;
+    }
+    const lines = [
+        `${title}:`
+    ];
+    for (const [index, layer] of layers.entries()){
+        lines.push(`  layer ${index + 1}${layer.length > 1 ? '  (parallel)' : ''}`);
+        for (const row of layer){
+            const dependencies = row.dependencies && row.dependencies.length ? `  ← ${row.dependencies.join(', ')}` : '';
+            const tag = row.tag ? `  [${row.tag}]` : '';
+            lines.push(`    ${row.name}${tag}${dependencies}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dest/deploy/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A minimal, declarative deployment framework for Aztec.
+ *
+ * Describe the accounts you send from and a graph of steps — contracts that must end up on-chain
+ * (deterministic addresses, interdependencies via `initializerArgs`) and the txs to send — plus how
+ * fees are paid; then {@link runDeployment} resolves, takes an on-chain inventory, funds, and
+ * executes only what's missing in dependency order — idempotently and resumably. The framework
+ * never reads the environment; callers pipe in secrets and config.
+ *
+ * Node-only: pulls in the PXE-backed `EmbeddedWallet`, `@aztec/noir-contracts.js`, and (for the
+ * `fee-juice` policy) L1 bridging — none browser-safe. Lives under the `@aztec/aztec/deploy` subpath
+ * so it stays out of any browser bundle.
+ */
+export { runDeployment } from './runner.js';
+export { defaultFeePolicy } from './fees.js';
+export { consoleReporter } from './reporter.js';
+export type { DeployReporter, DeployPlan, DeployPlanAccount, DeployPlanStep, AccountFunding, DeploySummary, DeployUnitInfo, DeployUnitResult, DeployUnitKind, BridgeEvent, } from './reporter.js';
+export type { DeploymentSpec, AccountSpec, ContractStep, ActionStep, FundStep, StepSpec, Steps, GeneratedContractClass, FeePolicy, Resolver, Ctx, } from './types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kZXBsb3kvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM1QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDN0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNoRCxZQUFZLEVBQ1YsY0FBYyxFQUNkLFVBQVUsRUFDVixpQkFBaUIsRUFDakIsY0FBYyxFQUNkLGNBQWMsRUFDZCxhQUFhLEVBQ2IsY0FBYyxFQUNkLGdCQUFnQixFQUNoQixjQUFjLEVBQ2QsV0FBVyxHQUNaLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLFlBQVksRUFDVixjQUFjLEVBQ2QsV0FBVyxFQUNYLFlBQVksRUFDWixVQUFVLEVBQ1YsUUFBUSxFQUNSLFFBQVEsRUFDUixLQUFLLEVBQ0wsc0JBQXNCLEVBQ3RCLFNBQVMsRUFDVCxRQUFRLEVBQ1IsR0FBRyxHQUNKLE1BQU0sWUFBWSxDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/deploy/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,YAAY,EACV,cAAc,EACd,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,WAAW,GACZ,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,cAAc,EACd,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,sBAAsB,EACtB,SAAS,EACT,QAAQ,EACR,GAAG,GACJ,MAAM,YAAY,CAAC"}

package/dest/deploy/index.js

@@ -0,0 +1,15 @@
+/**
+ * A minimal, declarative deployment framework for Aztec.
+ *
+ * Describe the accounts you send from and a graph of steps — contracts that must end up on-chain
+ * (deterministic addresses, interdependencies via `initializerArgs`) and the txs to send — plus how
+ * fees are paid; then {@link runDeployment} resolves, takes an on-chain inventory, funds, and
+ * executes only what's missing in dependency order — idempotently and resumably. The framework
+ * never reads the environment; callers pipe in secrets and config.
+ *
+ * Node-only: pulls in the PXE-backed `EmbeddedWallet`, `@aztec/noir-contracts.js`, and (for the
+ * `fee-juice` policy) L1 bridging — none browser-safe. Lives under the `@aztec/aztec/deploy` subpath
+ * so it stays out of any browser bundle.
+ */ export { runDeployment } from './runner.js';
+export { defaultFeePolicy } from './fees.js';
+export { consoleReporter } from './reporter.js';

package/dest/deploy/reporter.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Observability for the deploy framework. {@link runDeployment} emits structured lifecycle events
+ * to a {@link DeployReporter} instead of writing to the console directly, so callers control where
+ * the signal goes: the default ({@link consoleReporter}) renders human-readably to **stderr** —
+ * keeping stdout clear for the deploy scripts' `export KEY=VAL` lines, which an orchestrator evals —
+ * while e2e, a progress UI, or structured CI logging can inject their own reporter and consume the
+ * events as data. Every hook is optional; an empty `{}` is a valid (silent) reporter.
+ */
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { TxHash } from '@aztec/stdlib/tx';
+/** What a unit did: publish a contract, send an action's tx, or fund an address with Fee Juice. */
+export type DeployUnitKind = 'publish' | 'action' | 'fund';
+/** Identity of one execution unit (a single tx), as reported by the unit lifecycle hooks. */
+export interface DeployUnitInfo {
+    /** Human label, e.g. `publish goCoin`, `action mintGoCoin`. */
+    label: string;
+    kind: DeployUnitKind;
+    /** The account that sends and pays for this tx. */
+    account: AztecAddress;
+}
+/** What a unit produced once its tx settled. Fields beyond `durationMs` come from the receipt. */
+export interface DeployUnitResult {
+    txHash?: TxHash;
+    blockNumber?: number;
+    feePaid?: bigint;
+    status?: string;
+    durationMs: number;
+}
+/** An account's funding posture for this run, as resolved at planning time. */
+export type AccountFunding = {
+    kind: 'idle';
+} | {
+    kind: 'sponsored';
+} | {
+    kind: 'funded';
+    balance: bigint;
+} | {
+    kind: 'not-funded';
+    balance: bigint;
+    fundAmount: bigint;
+};
+export interface DeployPlanAccount {
+    alias: string;
+    address: AztecAddress;
+    funding: AccountFunding;
+}
+export interface DeployPlanStep {
+    id: string;
+    kind: 'contract' | 'action' | 'fund';
+    /**
+     * Status at the start of the run: a contract is `published` / `to publish` (public) or
+     * `registered` (private); an action is `done` / `to run`; a fund step is `funded` / `to fund`.
+     */
+    status: 'published' | 'to publish' | 'registered' | 'done' | 'to run' | 'funded' | 'to fund';
+    /** Steps it depends on (constructor-arg refs and explicit `dependsOn`). */
+    dependsOn: string[];
+}
+export interface DeployPlan {
+    /** Human label for the target (e.g. `local`, or a caller-chosen name). */
+    label: string;
+    accounts: DeployPlanAccount[];
+    steps: DeployPlanStep[];
+    /** Execution layers (step ids) — what will actually run, in dependency order. A layer runs parallel. */
+    layers: string[][];
+}
+export interface DeploySummary {
+    label: string;
+    contracts: {
+        alias: string;
+        address: AztecAddress;
+        status: 'published' | 'registered';
+    }[];
+    accounts: {
+        alias: string;
+        address: AztecAddress;
+    }[];
+}
+export interface BridgeEvent {
+    recipient: AztecAddress;
+    amount: bigint;
+    /** True when resuming a persisted claim instead of bridging anew. */
+    reused: boolean;
+}
+/** Lifecycle hooks the framework emits during a run. All optional — implement only what you need. */
+export interface DeployReporter {
+    /** The resolved plan, before execution. */
+    onPlan?(plan: DeployPlan): void;
+    /** Everything is already on-chain; nothing will be sent. */
+    onNothingToDo?(label: string): void;
+    /** An account's Fee Juice is being topped up (or a persisted claim is being resumed). */
+    onBridge?(event: BridgeEvent): void;
+    /** A unit's tx is about to be sent. */
+    onUnitStart?(unit: DeployUnitInfo): void;
+    /** A unit's tx settled successfully. */
+    onUnitSettled?(unit: DeployUnitInfo, result: DeployUnitResult): void;
+    /** A unit's tx threw; the run will abort after this. */
+    onUnitError?(unit: DeployUnitInfo, error: unknown): void;
+    /** The run finished; `summary` holds the final resolved state. */
+    onComplete?(summary: DeploySummary): void;
+}
+/**
+ * The default reporter: renders events human-readably to **stderr**. Stderr (not stdout) so the
+ * traces survive an orchestrator that captures stdout for the scripts' `export` lines.
+ */
+export declare function consoleReporter(): DeployReporter;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/deploy/reporter.d.ts.map

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