@avaprotocol/sdk-js 2.17.0 → 3.0.0

package/dist/v4/resources/executions.js

@@ -0,0 +1,132 @@
+/**
+ * `client.executions.*` — read-only access to past workflow runs and
+ * a live SSE stream for in-flight ones. Workflow executions are
+ * created by the operator when a trigger fires (or by `workflows.trigger`
+ * for manual runs); this resource never creates them, only reads.
+ */
+export class ExecutionsResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** GET /executions */
+    list(params) {
+        return this.transport.request({
+            path: "/executions",
+            query: params,
+        });
+    }
+    /** GET /workflows/{id}/executions — convenience nested form. */
+    listForWorkflow(workflowId, params) {
+        return this.transport.request({
+            path: `/workflows/${encodeURIComponent(workflowId)}/executions`,
+            query: params,
+        });
+    }
+    /** GET /executions/{id}?workflowId=... */
+    retrieve(id, params) {
+        return this.transport.request({
+            path: `/executions/${encodeURIComponent(id)}`,
+            query: { workflowId: params.workflowId },
+        });
+    }
+    /** GET /executions/{id}:getStatus?workflowId=... */
+    getStatus(id, params) {
+        return this.transport.request({
+            path: `/executions/${encodeURIComponent(id)}:getStatus`,
+            query: { workflowId: params.workflowId },
+        });
+    }
+    /** GET /executions:count */
+    count(params) {
+        return this.transport.request({
+            path: "/executions:count",
+            query: params,
+        });
+    }
+    /** GET /executions:stats */
+    stats(params) {
+        return this.transport.request({
+            path: "/executions:stats",
+            query: params,
+        });
+    }
+    /**
+     * GET /executions/{id}:stream — yields one `ExecutionStatusSummary`
+     * per status change. The stream closes on terminal status, when
+     * `signal` aborts, or when the connection drops. Implementation
+     * uses fetch streaming + a minimal SSE parser so it works in Node
+     * 20+ and browsers without an external EventSource polyfill.
+     */
+    async *stream(id, params) {
+        const response = await this.transport.stream({
+            path: `/executions/${encodeURIComponent(id)}:stream`,
+            query: { workflowId: params.workflowId, interval: params.interval },
+            headers: { Accept: "text/event-stream" },
+            signal: params.signal,
+            // SSE streams are long-lived — disable the default per-request
+            // timeout so we don't kill the stream after 30s. The caller's
+            // signal is the right cancellation channel.
+            timeoutMs: 0,
+        });
+        if (!response.body) {
+            throw new Error("SSE response has no body");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    return;
+                buffer += decoder.decode(value, { stream: true });
+                // SSE frames are separated by a blank line.
+                let idx = buffer.indexOf("\n\n");
+                while (idx !== -1) {
+                    const frame = buffer.slice(0, idx);
+                    buffer = buffer.slice(idx + 2);
+                    const data = parseSSEData(frame);
+                    if (data !== null) {
+                        yield JSON.parse(data);
+                    }
+                    idx = buffer.indexOf("\n\n");
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Poll-and-wait helper — yields the final ExecutionStatusSummary
+     * once the execution reaches a terminal status. Use `stream()`
+     * when you want every intermediate status update.
+     */
+    async waitForTerminal(id, params) {
+        let last;
+        for await (const event of this.stream(id, params)) {
+            last = event;
+            if (event.status === "success" || event.status === "failed" || event.status === "error") {
+                return event;
+            }
+        }
+        if (!last) {
+            throw new Error(`execution ${id} stream ended without a status event`);
+        }
+        return last;
+    }
+}
+/**
+ * Extract the `data:` payload from one SSE frame. Returns null when
+ * the frame is a heartbeat / comment / lacks a data line.
+ */
+function parseSSEData(frame) {
+    const lines = frame.split("\n");
+    const data = [];
+    for (const line of lines) {
+        if (line.startsWith("data:")) {
+            data.push(line.slice(5).trimStart());
+        }
+    }
+    return data.length === 0 ? null : data.join("\n");
+}

package/dist/v4/resources/health.d.ts

@@ -0,0 +1,19 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.health.*` — gateway liveness + version probes.
+ *
+ * Anonymous (no Bearer token required) — safe to call from
+ * unauthenticated browser code or external monitors.
+ */
+export declare class HealthResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * GET /health — returns `{ status, chainId, version }` when the
+     * gateway is up. Use for liveness checks; do not rely on it for
+     * deep readiness (it doesn't probe worker connectivity).
+     */
+    check(): Promise<v4.HealthStatus>;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/v4/resources/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/health.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;GAKG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC;CAGlC"}

package/dist/v4/resources/health.js

@@ -0,0 +1,19 @@
+/**
+ * `client.health.*` — gateway liveness + version probes.
+ *
+ * Anonymous (no Bearer token required) — safe to call from
+ * unauthenticated browser code or external monitors.
+ */
+export class HealthResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * GET /health — returns `{ status, chainId, version }` when the
+     * gateway is up. Use for liveness checks; do not rely on it for
+     * deep readiness (it doesn't probe worker connectivity).
+     */
+    check() {
+        return this.transport.request({ path: "/health" });
+    }
+}

package/dist/v4/resources/nodes.d.ts

@@ -0,0 +1,29 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.nodes.*` — execute a single node definition in isolation,
+ * without persisting a workflow. Used by the Studio UI's per-node
+ * "Run once" affordance and by SDK test suites that exercise a node
+ * shape against a live gateway.
+ */
+export declare class NodesResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * POST /nodes:run — execute one node against inline `inputVariables`.
+     *
+     * The request shape mirrors a single entry from `workflows.simulate`:
+     * a complete node definition + the variables the node would have seen
+     * inside a workflow. The gateway runs the node in-process (no worker
+     * delegation, no persistence) and returns the raw output keyed by
+     * node type — `{ success, output: { <nodeType>: {...} } }`.
+     *
+     * Chain context: the gateway resolves the target chain in this order:
+     * `body.chainId` → `inputVariables.settings.chain_id` → the JWT's
+     * `aud` claim → the gateway's default chain. Specify `chainId`
+     * explicitly when calling a contract that lives on a non-default
+     * chain (e.g. a sepolia oracle when the gateway defaults to mainnet).
+     */
+    run(req: v4.RunNodeRequest): Promise<v4.RunNodeResponse>;
+}
+//# sourceMappingURL=nodes.d.ts.map

package/dist/v4/resources/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;GAKG;AACH,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,cAAc,GAAG,OAAO,CAAC,EAAE,CAAC,eAAe,CAAC;CAOzD"}

package/dist/v4/resources/nodes.js

@@ -0,0 +1,33 @@
+/**
+ * `client.nodes.*` — execute a single node definition in isolation,
+ * without persisting a workflow. Used by the Studio UI's per-node
+ * "Run once" affordance and by SDK test suites that exercise a node
+ * shape against a live gateway.
+ */
+export class NodesResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * POST /nodes:run — execute one node against inline `inputVariables`.
+     *
+     * The request shape mirrors a single entry from `workflows.simulate`:
+     * a complete node definition + the variables the node would have seen
+     * inside a workflow. The gateway runs the node in-process (no worker
+     * delegation, no persistence) and returns the raw output keyed by
+     * node type — `{ success, output: { <nodeType>: {...} } }`.
+     *
+     * Chain context: the gateway resolves the target chain in this order:
+     * `body.chainId` → `inputVariables.settings.chain_id` → the JWT's
+     * `aud` claim → the gateway's default chain. Specify `chainId`
+     * explicitly when calling a contract that lives on a non-default
+     * chain (e.g. a sepolia oracle when the gateway defaults to mainnet).
+     */
+    run(req) {
+        return this.transport.request({
+            path: "/nodes:run",
+            method: "POST",
+            body: req,
+        });
+    }
+}

package/dist/v4/resources/operators.d.ts

@@ -0,0 +1,23 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.operators.*` — read-only view of the operator pool the
+ * gateway is currently dispatching to. Used by dashboards and the
+ * Studio sidebar's network-health widget; not part of the workflow
+ * lifecycle.
+ */
+export declare class OperatorsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * GET /operators — every operator currently connected to the
+     * gateway, plus their advertised capabilities (block / time /
+     * event monitoring) and the timestamp of their last heartbeat.
+     *
+     * An empty array means no operators are connected — workflows will
+     * still accept, but won't execute until at least one operator
+     * comes online.
+     */
+    list(): Promise<v4.OperatorList>;
+}
+//# sourceMappingURL=operators.d.ts.map

package/dist/v4/resources/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;GAKG;AACH,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;;;;;OAQG;IACH,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC;CAGjC"}

package/dist/v4/resources/operators.js

@@ -0,0 +1,23 @@
+/**
+ * `client.operators.*` — read-only view of the operator pool the
+ * gateway is currently dispatching to. Used by dashboards and the
+ * Studio sidebar's network-health widget; not part of the workflow
+ * lifecycle.
+ */
+export class OperatorsResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * GET /operators — every operator currently connected to the
+     * gateway, plus their advertised capabilities (block / time /
+     * event monitoring) and the timestamp of their last heartbeat.
+     *
+     * An empty array means no operators are connected — workflows will
+     * still accept, but won't execute until at least one operator
+     * comes online.
+     */
+    list() {
+        return this.transport.request({ path: "/operators" });
+    }
+}

package/dist/v4/resources/secrets.d.ts

@@ -0,0 +1,34 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+export interface ListSecretsParams {
+    workflowId?: string;
+    orgId?: string;
+    before?: string;
+    after?: string;
+    limit?: number;
+}
+export interface DeleteSecretParams {
+    workflowId?: string;
+    orgId?: string;
+}
+/**
+ * `client.secrets.*` — write-only secret store, scoped to the
+ * authenticated user. Values are referenced from workflow nodes via
+ * `{{secrets.NAME}}` template variables and are decrypted server-side
+ * at execution time; the SDK never receives the plaintext value back.
+ *
+ * `put` is a single idempotent endpoint replacing v3's create + update
+ * split — sending the same name twice rotates the value silently
+ * rather than erroring.
+ */
+export declare class SecretsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** GET /secrets — metadata only; values are write-only. */
+    list(params?: ListSecretsParams): Promise<v4.SecretList>;
+    /** PUT /secrets/{name} — idempotent create-or-replace. */
+    put(name: string, body: v4.PutSecretRequest): Promise<void>;
+    /** DELETE /secrets/{name} */
+    delete(name: string, params?: DeleteSecretParams): Promise<void>;
+}
+//# sourceMappingURL=secrets.d.ts.map

package/dist/v4/resources/secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/secrets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD,2DAA2D;IAC3D,IAAI,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC;IAOxD,0DAA0D;IAC1D,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ3D,6BAA6B;IAC7B,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAOjE"}

package/dist/v4/resources/secrets.js

@@ -0,0 +1,38 @@
+/**
+ * `client.secrets.*` — write-only secret store, scoped to the
+ * authenticated user. Values are referenced from workflow nodes via
+ * `{{secrets.NAME}}` template variables and are decrypted server-side
+ * at execution time; the SDK never receives the plaintext value back.
+ *
+ * `put` is a single idempotent endpoint replacing v3's create + update
+ * split — sending the same name twice rotates the value silently
+ * rather than erroring.
+ */
+export class SecretsResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** GET /secrets — metadata only; values are write-only. */
+    list(params) {
+        return this.transport.request({
+            path: "/secrets",
+            query: params,
+        });
+    }
+    /** PUT /secrets/{name} — idempotent create-or-replace. */
+    put(name, body) {
+        return this.transport.request({
+            path: `/secrets/${encodeURIComponent(name)}`,
+            method: "PUT",
+            body,
+        });
+    }
+    /** DELETE /secrets/{name} */
+    delete(name, params) {
+        return this.transport.request({
+            path: `/secrets/${encodeURIComponent(name)}`,
+            method: "DELETE",
+            query: params,
+        });
+    }
+}

package/dist/v4/resources/tokens.d.ts

@@ -0,0 +1,28 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.tokens.*` — ERC-20 metadata resolution backed by the
+ * aggregator's curated whitelist plus an on-chain `name/symbol/decimals`
+ * fallback. Used by the Studio token-picker, transfer-preview UI, and
+ * the notification cost-line renderer.
+ */
+export declare class TokensResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * GET /tokens/{address} — resolve a token by contract address.
+     *
+     * Returns `{ found: false, address }` (not 404) when the token
+     * isn't on the whitelist and the on-chain probe also fails — the
+     * partial response keeps the caller's UI from breaking on
+     * unrecognized tokens.
+     *
+     * `opts.chainId` picks which chain's whitelist + RPC to consult.
+     * Omit it to fall back to the JWT's `aud` chain (the gateway's
+     * default chain context for the authenticated user).
+     */
+    retrieve(address: string, opts?: {
+        chainId?: number;
+    }): Promise<v4.TokenMetadataResponse>;
+}
+//# sourceMappingURL=tokens.d.ts.map

package/dist/v4/resources/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;GAKG;AACH,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,EAAE,CAAC,qBAAqB,CAAC;CAM1F"}

package/dist/v4/resources/tokens.js

@@ -0,0 +1,29 @@
+/**
+ * `client.tokens.*` — ERC-20 metadata resolution backed by the
+ * aggregator's curated whitelist plus an on-chain `name/symbol/decimals`
+ * fallback. Used by the Studio token-picker, transfer-preview UI, and
+ * the notification cost-line renderer.
+ */
+export class TokensResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * GET /tokens/{address} — resolve a token by contract address.
+     *
+     * Returns `{ found: false, address }` (not 404) when the token
+     * isn't on the whitelist and the on-chain probe also fails — the
+     * partial response keeps the caller's UI from breaking on
+     * unrecognized tokens.
+     *
+     * `opts.chainId` picks which chain's whitelist + RPC to consult.
+     * Omit it to fall back to the JWT's `aud` chain (the gateway's
+     * default chain context for the authenticated user).
+     */
+    retrieve(address, opts) {
+        return this.transport.request({
+            path: `/tokens/${encodeURIComponent(address)}`,
+            query: opts,
+        });
+    }
+}

package/dist/v4/resources/triggers.d.ts

@@ -0,0 +1,29 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.triggers.*` — evaluate a trigger config in isolation,
+ * mirroring the per-node `nodes.run` shape. Use when designing or
+ * debugging a trigger before wiring it into a full workflow — e.g.
+ * confirming that an `eventTrigger` topic filter matches a known
+ * historical event, or that a cron expression parses.
+ */
+export declare class TriggersResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * POST /triggers:run — evaluate a trigger config against inline
+     * input and return the same shape an executor would see.
+     *
+     * For event triggers, the gateway uses Tenderly to simulate a
+     * matching event log against the request's `addresses` + `topics`
+     * filter, then returns the decoded log under `output.data` and
+     * the raw log under `output.metadata`.
+     *
+     * For time-based triggers (cron, fixedTime, block), the response
+     * carries the next scheduled fire time / block height.
+     *
+     * No workflow record is created and no execution is persisted.
+     */
+    run(req: v4.RunTriggerRequest): Promise<v4.RunTriggerResponse>;
+}
+//# sourceMappingURL=triggers.d.ts.map

package/dist/v4/resources/triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/triggers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;GAMG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;;;;;;;;;;OAaG;IACH,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,iBAAiB,GAAG,OAAO,CAAC,EAAE,CAAC,kBAAkB,CAAC;CAO/D"}

package/dist/v4/resources/triggers.js

@@ -0,0 +1,33 @@
+/**
+ * `client.triggers.*` — evaluate a trigger config in isolation,
+ * mirroring the per-node `nodes.run` shape. Use when designing or
+ * debugging a trigger before wiring it into a full workflow — e.g.
+ * confirming that an `eventTrigger` topic filter matches a known
+ * historical event, or that a cron expression parses.
+ */
+export class TriggersResource {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /**
+     * POST /triggers:run — evaluate a trigger config against inline
+     * input and return the same shape an executor would see.
+     *
+     * For event triggers, the gateway uses Tenderly to simulate a
+     * matching event log against the request's `addresses` + `topics`
+     * filter, then returns the decoded log under `output.data` and
+     * the raw log under `output.metadata`.
+     *
+     * For time-based triggers (cron, fixedTime, block), the response
+     * carries the next scheduled fire time / block height.
+     *
+     * No workflow record is created and no execution is persisted.
+     */
+    run(req) {
+        return this.transport.request({
+            path: "/triggers:run",
+            method: "POST",
+            body: req,
+        });
+    }
+}

package/dist/v4/resources/wallets.d.ts

@@ -0,0 +1,72 @@
+import type { v4 } from "@avaprotocol/types";
+import { Transport } from "../internal/transport";
+/**
+ * `client.wallets.*` — smart-wallet CRUD plus the UserOp-driven
+ * withdraw action. A "wallet" here is an ERC-6900 / ERC-4337 smart
+ * account derived deterministically from `(owner, factory, salt)` —
+ * the SDK never creates an EOA, it ensures-and-registers smart
+ * accounts owned by the authenticated user's EOA.
+ *
+ * All endpoints require auth and operate on wallets owned by the
+ * JWT's subject EOA.
+ */
+export declare class WalletsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * GET /wallets — every smart wallet owned by the authenticated
+     * EOA on the JWT's audience chain.
+     *
+     * Hidden wallets (`isHidden=true`) are excluded by default. The
+     * response is an envelope `{ data: Wallet[] }`, not a bare array.
+     */
+    list(): Promise<v4.WalletList>;
+    /**
+     * POST /wallets — idempotent "ensure exists". Derives the CREATE2
+     * address from `(owner, salt, factory)` and persists the record;
+     * calling twice with the same triple returns the same address.
+     *
+     * The on-chain account is **not** deployed by this call — deployment
+     * happens lazily as part of the first UserOp (workflow execution or
+     * `withdraw`) via the `initCode` field, so the smart wallet costs
+     * zero gas until it's first used.
+     *
+     * Per-owner cap is enforced by `max_wallets_per_owner` in the
+     * aggregator config; the call returns 429 `WALLETS_LIMIT_REACHED`
+     * when exceeded.
+     */
+    create(req: v4.CreateWalletRequest): Promise<v4.Wallet>;
+    /**
+     * PATCH /wallets/{address} — partial update. The only mutable
+     * field today is `isHidden`, used by the Studio UI's hide/unhide
+     * wallet action. Keyed by **address**, not salt — callers that
+     * still think in salts must look up the address first via
+     * `create({ salt })`.
+     */
+    update(address: string, body: {
+        isHidden?: boolean;
+    }): Promise<v4.Wallet>;
+    /**
+     * POST /wallets/{address}:withdraw — transfer ETH or an ERC-20 out
+     * of the smart wallet via a UserOp through the bundler + paymaster.
+     *
+     * Per-chain config (bundler URL, paymaster address, RPC) is resolved
+     * by the gateway from the JWT's `aud` claim or `body.chainId`.
+     * The response's `status` is one of `pending | confirmed | failed`:
+     * `confirmed` means the bundler returned a receipt synchronously,
+     * `pending` means it accepted the UserOp but the receipt hasn't
+     * landed yet, `failed` means the bundler rejected the op or it
+     * reverted before inclusion.
+     */
+    withdraw(address: string, req: v4.WithdrawRequest): Promise<v4.WithdrawResponse>;
+    /**
+     * GET /wallets/{address}:getNonce — current AA nonce for the wallet.
+     *
+     * Used when an external signer needs to assemble a UserOp outside
+     * the SDK's bundler path. Most callers don't need this directly —
+     * `workflows.simulate` and `wallets.withdraw` handle nonce sourcing
+     * internally.
+     */
+    getNonce(address: string): Promise<v4.NonceResponse>;
+}
+//# sourceMappingURL=wallets.d.ts.map

package/dist/v4/resources/wallets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallets.d.ts","sourceRoot":"","sources":["../../../src/v4/resources/wallets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,oBAAoB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;;;;GASG;AACH,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD;;;;;;OAMG;IACH,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC;IAI9B;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC,mBAAmB,GAAG,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC;IAQvD;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC;IAQzE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,eAAe,GAAG,OAAO,CAAC,EAAE,CAAC,gBAAgB,CAAC;IAQhF;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC,aAAa,CAAC;CAKrD"}