@aztec/aztec 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

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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"}

package/dest/deploy/reporter.js

@@ -0,0 +1,76 @@
+/**
+ * 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 { formatLayers, formatList } from './graph.js';
+const MS_PER_SECOND = 1000;
+const WEI_PER_FEE_JUICE = 10n ** 18n;
+const seconds = (ms)=>`${(ms / MS_PER_SECOND).toFixed(1)}s`;
+const feeJuice = (wei)=>`${wei / WEI_PER_FEE_JUICE} FJ`;
+function describeFunding(f) {
+    switch(f.kind){
+        case 'idle':
+            return 'idle (no work)';
+        case 'sponsored':
+            return 'sponsored';
+        case 'funded':
+            return `funded (${feeJuice(f.balance)})`;
+        case 'not-funded':
+            return `not funded (${feeJuice(f.balance)}) → will bridge ${feeJuice(f.fundAmount)}`;
+    }
+}
+/**
+ * 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 function consoleReporter() {
+    const log = (line)=>void process.stderr.write(`${line}\n`);
+    return {
+        onPlan (plan) {
+            log(`\n── Plan (${plan.label}) ──`);
+            log(formatList('accounts', plan.accounts.map((a)=>({
+                    name: a.alias,
+                    tag: describeFunding(a.funding)
+                }))));
+            log(formatList('steps', plan.steps.map((s)=>({
+                    name: s.id,
+                    tag: `${s.kind} · ${s.status}`,
+                    dependencies: s.dependsOn
+                }))));
+            log(formatLayers('execution layers', plan.layers.map((layer)=>layer.map((name)=>({
+                        name
+                    })))));
+        },
+        onNothingToDo (label) {
+            log(`\nNothing to do on ${label} — everything is already on-chain.`);
+        },
+        onBridge ({ recipient, amount, reused }) {
+            log(reused ? `Reusing a pending bridge claim for ${recipient} (resuming a top-up).` : `Bridging ${amount} Fee Juice to ${recipient} (this can take a few minutes)...`);
+        },
+        onUnitStart (unit) {
+            log(`→ ${unit.label}...`);
+        },
+        onUnitSettled (unit, result) {
+            const bits = [
+                result.txHash ? `tx ${result.txHash.toString().slice(0, 10)}…` : undefined,
+                result.blockNumber != null ? `block ${result.blockNumber}` : undefined,
+                seconds(result.durationMs)
+            ].filter(Boolean);
+            log(`✓ ${unit.label}  ${bits.join('  ')}`);
+        },
+        onUnitError (unit, error) {
+            log(`✗ ${unit.label}  failed: ${error instanceof Error ? error.message : String(error)}`);
+        },
+        onComplete (summary) {
+            log(`\n── Deployed to ${summary.label} ──`);
+            for (const c of summary.contracts){
+                log(`  ${c.alias.padEnd(16)} ${c.address}  (${c.status})`);
+            }
+            for (const a of summary.accounts){
+                log(`  account ${a.alias}: ${a.address}`);
+            }
+        }
+    };
+}

package/dest/deploy/runner.d.ts

@@ -0,0 +1,8 @@
+import type { DeploymentSpec, Steps } from './types.js';
+/**
+ * Runs a {@link DeploymentSpec}: resolves accounts and deterministic addresses, inventories what's
+ * already on-chain, reports the plan, funds the working accounts, and executes the missing steps in
+ * dependency layers. Idempotent — a re-run sends nothing when everything is already in place.
+ */
+export declare function runDeployment<C extends Steps>(spec: DeploymentSpec<C>): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGVwbG95L3J1bm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF3REEsT0FBTyxLQUFLLEVBSVYsY0FBYyxFQUtkLEtBQUssRUFDTixNQUFNLFlBQVksQ0FBQztBQWdEcEI7Ozs7R0FJRztBQUNILHdCQUFzQixhQUFhLENBQUMsQ0FBQyxTQUFTLEtBQUssRUFBRSxJQUFJLEVBQUUsY0FBYyxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FjM0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/deploy/runner.ts"],"names":[],"mappings":"AAwDA,OAAO,KAAK,EAIV,cAAc,EAKd,KAAK,EACN,MAAM,YAAY,CAAC;AAgDpB;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,CAAC,SAAS,KAAK,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAc3F"}