@owney/sdk 0.7.32-beta.1 → 0.7.32-beta.4

package/dist/index.d.ts

@@ -275,6 +275,13 @@ type FundingOperationLeg = {
      * "definitely not booked".
      */
     providerBookedAt: string | null;
+    /** The provider's own id for this leg (e.g. a withdrawal or deposit id), as stored; null when none. */
+    providerRef: string | null;
+    /**
+     * The server stopped checking this in-flight leg (no outcome was proven).
+     * Present only when true; a new fact reported for the leg reopens it.
+     */
+    closed?: true;
 };
 /** One ledger operation, as the API returns it. */
 type FundingOperationRow = {
@@ -380,6 +387,32 @@ interface OwneySDKConfig {
      * `OWNEY_WITHDRAWAL_RESERVATION_DISABLED=1` in the environment acts as `"off"`.
      */
     withdrawalReservation?: "fail-open" | "fail-closed" | "off";
+    /**
+     * Hand Zyfai withdrawals and deposit registrations, with the user's Zyfai
+     * session, to the Owney routing API, which then sends them itself (default
+     * off). Only `true`, or a function that returns `true`, opts in.
+     *
+     * A function is called for each operation, at the moment it would first
+     * hand a withdrawal or a registration off, so an app can turn the handoff on
+     * or off in open tabs without a reload. A function that throws counts as
+     * off.
+     *
+     * Off, the SDK hands no new operation off, never sends the Zyfai session to
+     * Owney for it, and behaves as before. Turning it off never makes the
+     * browser send what the server may already hold: an operation this SDK
+     * instance already handed off keeps going through the server (its nudges,
+     * re-runs, retries and registration recovery). Recovery of a deposit handed
+     * off by an earlier page waits until it is on again.
+     */
+    zyfaiServerTasks?: boolean | (() => boolean);
+    /**
+     * Hand each signed cross-chain (Fusion+) order's secrets to the Owney
+     * routing API, which publishes them once 1inch is ready, so the swap
+     * completes even if the tab closes (default false). Only `true` opts in.
+     * Off, the secrets never leave the browser and swaps behave as before. On,
+     * the browser still publishes them too.
+     */
+    fusionSecretHandoff?: boolean;
 }
 interface ConnectionState {
     provider: any;
@@ -426,6 +459,44 @@ type OrgAgentConfig = {
     poolPolicy?: OrgPoolPolicy | null;
 };
 
+/** Capability flag: this SDK can hand Zyfai withdrawals and deposit
+ * registrations to the server, and marks such legs with evidence `serverTask`.
+ * Older builds do not export this. */
+declare const ZYFAI_SERVER_TASKS: 1;
+/** A `zyfai_withdrawal` task that failed with one of these codes never sent
+ * the withdrawal to Zyfai. */
+declare const ZYFAI_WITHDRAWAL_NOT_SENT_CODES: ReadonlySet<string>;
+/** A `zyfai_deposit_registration` task that failed with one of these codes
+ * never registered the deposit with Zyfai, so the browser may register it. */
+declare const ZYFAI_REGISTRATION_NOT_SENT_CODES: ReadonlySet<string>;
+type ZyfaiTaskResult = {
+    providerWithdrawalId?: string;
+    providerDepositId?: string;
+    txHash?: string;
+    asyncPending?: true;
+    handedOff?: "reconciler";
+    lifecycle?: "failed";
+};
+/**
+ * - accepted: the server has a task for this leg (its state and code);
+ * - declined: the server proved no task was created (a 200 decline, or a 400,
+ *   401, 403, 404, 409 or 429; or `ZYFAI_SERVER_TASKS_OFF_CODE` without the
+ *   opt-in);
+ * - unknown: anything else. The server may have a task.
+ */
+type ZyfaiHandoffAnswer = {
+    type: "accepted";
+    taskId: string;
+    state: string;
+    code?: string;
+    result: ZyfaiTaskResult;
+} | {
+    type: "declined";
+    code: string;
+} | {
+    type: "unknown";
+};
+
 type DepositCallback = (smartWalletAddress: string, chainId: number, amount: string) => Promise<`0x${string}`> | `0x${string}`;
 /**
  * Read access to the funding ledger, given to agents by the client so they can
@@ -466,6 +537,33 @@ interface IAgent {
      * rejected wallet request cannot happen after another leg has committed.
      */
     readonly withdrawalRequiresWalletApproval?: boolean;
+    /**
+     * Settles this agent's own wallet prompts (a login, a session key) so that a
+     * following `withdraw` needs none. A multi-agent withdrawal calls it before a
+     * wallet-approval agent's owner signature, so two prompts never overlap and
+     * this agent can start as soon as that signature was accepted. Never submits
+     * a withdrawal. A rejected prompt throws; other failures are left to `withdraw`.
+     */
+    prepareWithdrawal?(state: ConnectionState, chainId: number, token: OwneySupportedTokens): Promise<void>;
+    /**
+     * The adapter can hand its withdrawal to our server (part 4, Zyfai). Only
+     * such agents get the plan-time handoff and a `planned` withdraw context;
+     * every other agent keeps today's calls.
+     */
+    readonly supportsServerTasks?: true;
+    /**
+     * Hands a planned withdrawal leg to our server before an earlier
+     * wallet-approval leg is signed (`after`: those legs' keys). The server sends
+     * it once those legs are accepted. Never throws; never withdraws locally.
+     * `amount` is the leg's planned share, or "MAX". `beforeRequest` runs right
+     * before the request leaves (never when none is sent), so the caller can
+     * save the leg's server mark first.
+     */
+    handOffPlannedWithdrawal?(state: ConnectionState, chainId: number, token: OwneySupportedTokens, amount: string, ctx: {
+        operationId: string;
+        after: string[];
+        beforeRequest?: () => void;
+    }): Promise<ZyfaiHandoffAnswer>;
     disconnect(): Promise<void>;
     activateAgent(state: ConnectionState, chainId: number, asset?: OwneySupportedTokens): Promise<void>;
     /**
@@ -481,8 +579,23 @@ interface IAgent {
      * unchanged rather than break the connect.
      */
     applyOrgPolicy?(state: ConnectionState, chainId: number, policy: OrgAgentConfig): Promise<void>;
-    deposit(state: ConnectionState, chainId: number, amount: string, asset: OwneySupportedTokens, depositCallback?: DepositCallback, onProgress?: FundingProgress, onBeforeSubmission?: (evidence: FundingEvidence) => void | Promise<void>): Promise<OwneyDepositResult>;
-    withdraw(state: ConnectionState, chainId: number, token: OwneySupportedTokens, amount?: string, onProgress?: FundingProgress, gasMode?: "auto" | "sponsored" | "paid", onBeforeSubmission?: FundingProgress, assertCurrent?: () => void): Promise<AgentWithdrawResult>;
+    deposit(state: ConnectionState, chainId: number, amount: string, asset: OwneySupportedTokens, depositCallback?: DepositCallback, onProgress?: FundingProgress, onBeforeSubmission?: (evidence: FundingEvidence) => void | Promise<void>, 
+    /** `operationId`: the funding ledger operation. Zyfai hands the deposit's
+     * registration to the server with it (only agents with
+     * `supportsServerTasks` get it; every other agent keeps today's call). */
+    context?: {
+        operationId?: string;
+    }): Promise<OwneyDepositResult>;
+    withdraw(state: ConnectionState, chainId: number, token: OwneySupportedTokens, amount?: string, onProgress?: FundingProgress, gasMode?: "auto" | "sponsored" | "paid", onBeforeSubmission?: FundingProgress, assertCurrent?: () => void, 
+    /** `operationId`: the funding ledger operation (Yieldseeker opts in to the
+     * server-owned send of its sponsored userOp with it; Zyfai hands its
+     * withdrawal to the server with it). `planned`: the leg was handed to the
+     * server at plan time, so this call nudges that task (only for agents with
+     * `supportsServerTasks`). */
+    context?: {
+        operationId?: string;
+        planned?: true;
+    }): Promise<AgentWithdrawResult>;
     /** Read-only MAX proof at the owner payout block; never sends another withdrawal. */
     verifyWithdrawalCompletion?(state: ConnectionState, evidence: FundingEvidence): Promise<WithdrawalCompletion>;
     /** A newly observed pool allocation invalidates this asset's portfolio cache only. */
@@ -693,6 +806,10 @@ type DepositOptions = {
     assertSubmissionCurrent?: () => void;
     /** Resume only these already signed relayer bytes; never create a new authorization. */
     resumeTxHash?: `0x${string}`;
+    /** Resume only the saved signed batch of a deposit the server may be sending
+     * (its prepare got no answer, so no transaction hash is known); never create
+     * a new authorization. Check it first with `canResumePendingDeposit`. */
+    resumeSavedBatch?: true;
     onProgress?: FundingProgress;
     /** Awaited immediately before dispatch. Throwing prevents submission.
      * All legs of an atomic batch are checkpointed together. */
@@ -752,21 +869,68 @@ interface FundingEvidence {
     maxCompletion?: WithdrawalCompletionContext;
     maxCompletionCheck?: WithdrawalCompletion;
     intendedAmount: string;
+    /** A multi-agent withdrawal recorded this leg's planned amount (`intendedAmount`:
+     * the leg's share, or "MAX") before any agent was dispatched. A plan, not a
+     * submission: it never says the leg was sent. */
+    planned?: true;
+    /** The owner-authorized call of a wallet-approval withdrawal was accepted: the
+     * bundler accepted the signed userOp (`userOpHash`), the wallet returned a
+     * calls ID (`callsId`), or `eth_sendTransaction` returned a hash (`txHash`).
+     * Not confirmation: the call can still revert. */
+    ownerAuthorization?: "accepted";
     confirmedAmount?: string;
     /** Receipt delivery and fulfillment of a typed requested amount are separate facts. */
     amountCompletion?: "complete" | "shortfall";
     /** Verified difference between the typed request and the actual owner payout. */
     shortfallAmount?: string;
     txHash?: string;
+    /** Zyfai's id for this deposit, from its registration (1-128 chars); reads its placement status. */
+    providerDepositId?: string;
     /** Persisted before a sponsored EOA operation is sent. */
     userOpHash?: string;
     /** Lets recovery verify a consumed nonce even if a bundler forgets the operation. */
     userOperation?: UnsignedUserOperationEvidence;
     /** Base Account calls ID used to recover an uncertain wallet submission. */
     callsId?: string;
+    /** The server owns this sponsored Yieldseeker userOp's send (true), or may
+     * own it ("unknown": the opted-in send got no definitive answer). Either way
+     * the leg is never "not sent". Not acceptance, not confirmation. Never sent
+     * to the ledger. */
+    serverSubmit?: true | "unknown";
+    /** Zyfai server tasks. On a withdrawal leg: the server sends this withdrawal
+     * (true), or may send it ("unknown": the handoff got no definitive answer),
+     * so the browser never sends it. `false`: the server proved it has no task
+     * for this leg, so the browser sends it; it clears an earlier mark (a
+     * handoff checkpoint), and a merge must let it win over true and "unknown".
+     * On a deposit leg: the server registers this deposit. Not acceptance, not
+     * confirmation. Never sent to the ledger. */
+    serverTask?: true | "unknown" | false;
+    /** With `serverTask` on a Zyfai deposit leg: the client operation id of the
+     * server's registration task, so registration recovery can nudge that task
+     * after a reload. Not a secret. Never sent to the ledger. */
+    serverTaskOperationId?: string;
+    /** With `serverTask: "unknown"` on a Zyfai deposit leg: what the server
+     * answered to the registration handoff. "lost": no answer (the server may
+     * or may not have a task), so a later proof of no task lets the browser
+     * register it. "declined": the server declined it with a code that does not
+     * prove no task (e.g. ALREADY_REGISTERED), so the browser never registers
+     * it. Local only: never sent to the ledger. */
+    serverTaskCreate?: "declined" | "lost";
     /** Deposit execution was attempted, rather than only prepared. Not confirmation. */
     depositSubmission?: "started";
     depositAuthorization?: DepositAuthorizationReference;
+    /** The server accepted this sponsored deposit and sends it itself if the
+     * browser does not (true), or may have accepted it ("unknown": the prepare
+     * got no definitive answer, no hash is known yet). Either way it is never
+     * "not sent". Not confirmation. */
+    serverBroadcast?: true | "unknown";
+    /** With `serverBroadcast: "unknown"`: the deposit authorization's Permit2
+     * deadline (unix seconds). After it no deposit of that authorization can
+     * execute. */
+    authorizationDeadline?: number;
+    /** With `serverBroadcast`: the deposit authorization's Permit2 nonce
+     * (decimal); see `checkDepositAuthorization`. */
+    permit2Nonce?: string;
     blockNumber?: string;
     logIndexes?: number[];
     transferLogs?: {
@@ -777,13 +941,16 @@ interface FundingEvidence {
     withdrawalRequest?: {
         attempted: boolean;
         method?: "GET" | "POST";
-        path?: "/users/withdraw" | "/users/partial-withdraw";
+        /** The route that answered. v1 paths appear only in evidence saved before @zyfai/sdk 0.10.0. */
+        path?: "/users/withdraw" | "/users/partial-withdraw" | "/users/withdraw/v2" | "/users/partial-withdraw/v2";
         elapsedMs?: number;
         /** Actual response status captured before the vendor replaces the HTTP error. */
         httpStatus?: number;
         failure?: "network" | "unauthorized" | "forbidden" | "rate-limited" | "insufficient-balance" | "session-key-missing" | "withdrawal-in-progress" | "other";
         /** When the provider accepted the request without a hash (ms since epoch). */
         acceptedAt?: number;
+        /** Zyfai's v2 withdrawal id, for the lifecycle lookup (1-128 chars). */
+        providerWithdrawalId?: string;
     };
     /** Where an on-chain payout search may start, for a hashless acceptance.
      * `fromBlock` is the chain head read just before the request (decimal string). */
@@ -795,6 +962,34 @@ interface FundingEvidence {
     delivery: FundingStage;
 }
 type FundingProgress = (evidence: FundingEvidence) => void;
+/** The part of Zyfai's withdrawal lifecycle (`GET /users/withdrawals/{id}`) that Owney acts on. */
+type ZyfaiWithdrawalLifecycle = {
+    status: string;
+    /** The synchronous payout leg has settled. */
+    syncSettled: boolean;
+    /** Hash of the synchronous payout transaction; present only when well formed. */
+    syncTxHash?: `0x${string}`;
+    /** Delayed (protocol-cooldown) redemption legs; empty when none or unreadable. */
+    asyncLegs: {
+        id: string;
+        status: string;
+        estimatedClaimAt?: string;
+        claimTxHash?: `0x${string}`;
+    }[];
+    /** Ids of delayed legs Zyfai reports as failed. */
+    failedAsyncIds: string[];
+    /** When the delayed part is expected to arrive; present only when a valid date. */
+    estimatedClaimAt?: string;
+    /** Zyfai recorded an error for this withdrawal. Its text is never carried. */
+    hasError: boolean;
+};
+/** The part of Zyfai's deposit status (`GET /users/deposits/{id}/v2`) that Owney acts on. */
+type ZyfaiDepositPlacement = {
+    /** `handover_pending | credited | position_pending | positioned | recovered_to_eoa`. */
+    status: string;
+    /** `pending | positioned | skipped | failed`. */
+    positionOutcome?: string;
+};
 interface AssetReadMetadata {
     chainId: number;
     asset: string;
@@ -906,6 +1101,19 @@ interface OwneyPendingAllocation {
     /** ISO timestamp from Zyfai's `updatedAt`, when the payload carries one. */
     since?: string;
 }
+/**
+ * A Zyfai delayed redemption in flight (`REQUESTED` or `CLAIMABLE`). Its funds
+ * are in neither `positions` nor `tokens`; display-only, never added to a total.
+ */
+interface OwneyPendingWithdrawal {
+    id: string;
+    status: string;
+    chainId: number;
+    /** Token symbol as Zyfai reports it. */
+    asset: string;
+    /** Redeemed amount in least units, as a decimal string. */
+    amountRaw: string;
+}
 interface AgentBalance {
     readMetadata?: AssetReadMetadata[];
     /** Authoritative native balances per asset/network, including idle and invested funds. */
@@ -929,7 +1137,23 @@ interface AgentBalance {
     positions?: OwneyPosition[];
     /** Funds received but not yet deployed. Omitted when nothing is pending. */
     pendingAllocations?: OwneyPendingAllocation[];
+    /** Zyfai only: delayed redemptions still in flight. Omitted when none. Never part of a total. */
+    pendingWithdrawals?: OwneyPendingWithdrawal[];
+    /**
+     * Zyfai only: every delayed redemption Zyfai lists except FAILED, recently
+     * CLAIMED ones included (Zyfai keeps them about a day). Present, possibly
+     * empty, whenever Zyfai sent the list; absent when it did not. Empty means no
+     * older delayed payout can be landing now. Never part of a total.
+     */
+    recentAsyncWithdrawals?: OwneyRecentAsyncWithdrawal[];
 }
+/** A delayed Zyfai redemption by status, for telling a new payout from an older remainder. */
+type OwneyRecentAsyncWithdrawal = {
+    id: string;
+    status: string;
+    chainId: number;
+    asset: string;
+};
 interface OwneyBalances {
     totalBalance: string;
     /** Asset that `totalBalance` is denominated in. Currently always `"usdc"`. */
@@ -1039,7 +1263,14 @@ interface AgentHistoryPosition {
     protocol: string;
     pool?: string;
     tokenSymbol?: string;
+    /** The position balance after the action (decimal string, token units). */
     amount?: string;
+    /**
+     * The amount the action actually moved (decimal string, token units), as
+     * opposed to `amount`, the resulting position balance. Present only when the
+     * provider reports it; withheld on withdrawals.
+     */
+    deltaAmount?: string;
 }
 interface AgentHistoryEntry {
     /** Stable provider/transfer identity, independent of row order. */
@@ -1168,6 +1399,9 @@ type WithdrawalPayoutScan = {
     candidates: WithdrawalPayoutCandidate[];
     /** Last block scanned (inclusive, decimal). Pass it back as the next `cursor`. */
     scannedTo: string;
+    /** False when the call stopped at its request limit before the scan end (the
+     * head minus the reorg margin), so more blocks are already waiting. */
+    caughtUp: boolean;
 };
 
 type OwneyErrorCode = "NOT_CONNECTED" | "NO_ACTIVE_CHAIN" | "WALLET_NO_ACCOUNTS" | "WALLET_ADDRESS_REQUIRED" | "WALLET_NOT_DEPLOYED" | "AGENT_NOT_FOUND" | "AGENT_CHAIN_INCOMPATIBLE" | "AGENT_EMPTY_LIST" | "AGENT_DISABLED" | "AGENT_ACTIVATION_PARTIAL_FAILURE" | "YIELDSEEKER_AGENT_MISSING" | "YIELDSEEKER_WALLET_UNVERIFIED" | "CHAIN_UNSUPPORTED" | "CHAIN_NO_COMPATIBLE_AGENTS" | "CHAIN_MISMATCH" | "ASSET_UNSUPPORTED" | "ASSET_NO_COMPATIBLE_AGENTS" | "DEPOSIT_BALANCE_UNAVAILABLE" | "DEPOSIT_PARTIAL_FAILURE" | "DEPOSIT_IN_PROGRESS" | "DEPOSIT_CHECKPOINT_FAILED" | "DEPOSIT_AMOUNT_BELOW_MINIMUM" | "DEPOSIT_INVALID_AMOUNT" | "DEPOSIT_CALLBACK_REQUIRED" | "DEPOSIT_CALLBACK_INVALID" | "DEPOSIT_NO_PERMITTED_TOKENS" | "DEPOSIT_INSUFFICIENT_BALANCE" | "WITHDRAW_IN_PROGRESS" | "WITHDRAW_NO_PERMITTED_TOKENS" | "WITHDRAW_BALANCE_UNAVAILABLE" | "WITHDRAW_INSUFFICIENT_BALANCE" | "WITHDRAW_ALL_FAILED" | "WITHDRAW_UNCONFIRMED" | "WITHDRAW_PARTIAL_FAILURE" | "WITHDRAW_SWAP_INCOMPLETE" | "WITHDRAW_FAILED" | "WITHDRAW_INVALID_AMOUNT" | "WITHDRAW_RESERVATION_UNAVAILABLE" | "AGENT_RATE_LIMITED" | "API_ROUTING_ERROR" | "API_ROUTING_FAILED" | "API_NO_AGENTS" | "AGENT_API_ERROR" | "AGENT_AUTH_FAILED" | "AGENT_INVALID_RESPONSE" | "AGENT_TIMEOUT" | "AGENT_TRANSACTION_REVERTED" | "AGENT_APY_PERIOD_UNSUPPORTED" | "SPONSOR_REQUEST_FAILED" | "PERMIT2_APPROVAL_REQUIRED" | "SPONSORED_CALLS_UNSUPPORTED" | "SPONSORED_CALLS_NO_ID" | "SPONSORED_CALLS_NO_RECEIPT" | "SWAP_DISABLED" | "SWAP_RATE_LIMITED" | "SWAP_REQUEST_FAILED" | "SWAP_QUOTE_FAILED" | "SWAP_UNSUPPORTED_PAIR" | "SWAP_APPROVAL_REQUIRED" | "SWAP_BELOW_DEPOSIT_MINIMUM" | "SWAP_DEPOSIT_PENDING" | "SWAP_WALLET_PROMPT_TIMEOUT" | "SWAP_INSUFFICIENT_GAS" | "SWAP_NATIVE_UNSUPPORTED" | "SWAP_ORDER_EXPIRED" | "SWAP_ORDER_REFUNDED" | "SWAP_ORDER_CANCELLED" | "WITHDRAW_ARRIVAL_TIMEOUT" | "WITHDRAW_SWAP_FAILED" | "BALANCE_ALL_FAILED" | "EARNINGS_ALL_FAILED" | "ALLOCATION_ALL_FAILED" | "VALIDATION_INVALID_DAYS";
@@ -1345,12 +1579,20 @@ declare class OwneySDK {
     private readonly ledger;
     private readonly reservationMode;
     private readonly reservationTransport;
+    /** The caller's Zyfai server tasks opt-in: `true`, a function read each
+     * time a handoff would start (F-I2(iii)), or undefined (off). */
+    private readonly zyfaiServerTasks;
+    /** The caller opted in to the Fusion+ secret handoff (`fusionSecretHandoff: true`). */
+    private readonly fusionSecretHandoff;
     private cachedSponsoredCallback;
     private cachedWethSponsoredCallback;
     private paymasterServiceUrl?;
     private cachedSponsoredCallsCallbacks;
     private readonly agentReads;
     private readonly depositFamilyReads;
+    /** Movements (owner, chain, agent, token, tx hash) whose balance refresh this
+     * session started: true when it armed the refresh, false when its deadline
+     * had passed (it only dropped the cache and forced one snapshot read). */
     private readonly recoveredFundingReads;
     private fundingBalanceChecks;
     private readonly activationChecks;
@@ -1383,8 +1625,16 @@ declare class OwneySDK {
     /** Starts a swap's operation and opens it to the swap's inner deposit or
      * withdrawal. Never throws: reporting never blocks a swap. */
     private openSwapLedger;
+    /**
+     * Part 5: the swap's ledger identity, for the executor's Fusion+ secret
+     * handoff. Only with the `fusionSecretHandoff` opt-in and an open operation;
+     * otherwise undefined, and the executor sends nothing. Owner and token are
+     * lowercased, as the ledger reports them.
+     */
+    private secretHandoffFor;
     private closeSwapLedger;
-    /** Reports one agent's withdrawal evidence as its leg. Never throws. */
+    /** Reports one agent's withdrawal evidence as its leg (with `errorCode`, when
+     * given). Never throws. */
     private ledgerWithdrawalLeg;
     /** Operation/leg/tx keys whose provider samples are already scheduled. */
     private readonly providerSampleKeys;
@@ -1584,6 +1834,24 @@ declare class OwneySDK {
         refreshBalance?: boolean;
         requireAmountMatch?: boolean;
     }): Promise<FundingEvidence>;
+    private noteFundingRefresh;
+    /**
+     * Re-arms an agent's balance refresh after a confirmed deposit or withdrawal
+     * the caller already verified (e.g. after a page reload, which loses the
+     * refresh the SDK started in memory). Same refresh as receipt recovery
+     * (`inspectFunding`), without a receipt read, and shared with it: once per
+     * movement (`txHash`) in this SDK session, unless that recovery came after
+     * its own deadline and so armed nothing. `until` bounds it (the agent caps
+     * it further). Returns false when the agent has no such refresh or `until`
+     * has passed; throws when not connected or on another chain. Never prompts.
+     */
+    refreshAgentBalanceAfterMovement(input: {
+        agentId: AgentId;
+        chainId: number;
+        token: OwneySupportedTokens;
+        txHash?: string;
+        until: number;
+    }): boolean;
     /**
      * Lists on-chain payout candidates for a withdrawal the provider accepted
      * without a hash: ERC-20 `Transfer` logs on the evidence's token that reach
@@ -1611,6 +1879,26 @@ declare class OwneySDK {
     /** Whether a foreground deposit can resume the same signed batch, never a
      * fresh authorization. The batch rail independently rechecks the exact plan. */
     canResumePendingDeposit(evidences: FundingEvidence[], amount: string): Promise<boolean>;
+    /** Whether a Permit2 deposit authorization can still execute and whether it
+     * did: `expired` when the finalized block is more than 300 s past
+     * `deadline` (chain time), `used` when the owner's Permit2 nonce bit is set
+     * at that block. Null when anything cannot be read. Never throws. */
+    checkDepositAuthorization(input: {
+        chainId: number;
+        owner: string;
+        token?: string;
+        permit2Nonce: string;
+        deadline: number;
+    }): Promise<{
+        expired: boolean;
+        used: boolean;
+    } | null>;
+    /** Drops the saved signed body of a hashless deposit the server may have
+     * been sending (`serverBroadcast` 'unknown'/true, no hash) once the app has
+     * settled it another way: by the ledger's hash or its expired deadline.
+     * Only the body with this Permit2 deadline and these exact shares is
+     * dropped, so it never resumes or blocks a different deposit. Never throws. */
+    discardSavedDepositBatch(evidences: FundingEvidence[]): Promise<boolean>;
     /** Validate signed journal membership, never just a caller-supplied family ID. */
     validateDepositReplacement(previous: FundingEvidence[], next: FundingEvidence[]): Promise<DepositReplacementValidation | undefined>;
     /** Optional post-payout display proof; receipt verification and the provider
@@ -1621,6 +1909,12 @@ declare class OwneySDK {
     /** History lookup for receipt recovery; adapters may not authenticate or sign here. */
     getFundingHistory(evidence: FundingEvidence, fromDate: string, options?: Pick<HistoryFilters, "cursor" | "toDate">): Promise<OwneyAgentHistory>;
     recoverDepositRegistration(evidence: FundingEvidence): Promise<FundingEvidence>;
+    /** A Zyfai withdrawal's lifecycle by the id recorded on its evidence. Never signs,
+     * prompts or authenticates; `null` when unavailable or not this wallet's Zyfai withdrawal. */
+    getZyfaiWithdrawal(evidence: FundingEvidence): Promise<ZyfaiWithdrawalLifecycle | null>;
+    /** A Zyfai deposit's placement status by the id recorded on its evidence. Never signs,
+     * prompts or authenticates; `null` when unavailable or not this wallet's Zyfai deposit. */
+    getZyfaiDeposit(evidence: FundingEvidence): Promise<ZyfaiDepositPlacement | null>;
     /** On-chain version and ownership status for this owner's Yieldseeker agent. */
     getYieldseekerWalletStatus(asset: OwneySupportedTokens): Promise<YieldseekerWalletStatus | null>;
     /** Deployment gate; an unavailable response keeps the current paid path. */
@@ -2057,6 +2351,13 @@ declare class OwneySDK {
      * hold this SDK does not know about is left to the server's expiry.
      */
     releaseWithdrawalReservation(operationId: string, reason: ReservationReleaseReason, agents?: ReservationAgent[]): Promise<void>;
+    /**
+     * Reports a withdrawal step the app closed as never sent (a reload before its
+     * request was saved) as a failed ledger leg with `NOT_SUBMITTED`, so other
+     * devices and later recovery stop treating it as in flight. Refuses any step
+     * with a hash or a saved request. Never touches the hold; never throws.
+     */
+    reportWithdrawalNotSubmitted(operationId: string, evidence: FundingEvidence): Promise<void>;
     /**
      * Reports a withdrawal leg that was proven after its call ended (a hashless
      * Zyfai payout found on chain or in history) to the funding ledger, then
@@ -2067,6 +2368,15 @@ declare class OwneySDK {
      * the server re-verifies the hash. Never throws.
      */
     reportWithdrawalRecovery(operationId: string, evidence: FundingEvidence): Promise<void>;
+    /**
+     * Reports a deposit leg that the app's recovery verified on chain after its
+     * call ended to the funding ledger. Only evidence whose transfer is confirmed
+     * with a transaction hash is reported; anything else is ignored. The ledger
+     * PATCHes the existing operation (creating it only on a 404) and the server
+     * re-verifies the hash. Deposits hold no reservation, so nothing is released.
+     * Never throws.
+     */
+    reportDepositRecovery(operationId: string, evidence: FundingEvidence): Promise<void>;
     private withdrawFromAgents;
     /** Read-only invalidation after new pool-deposit activity. Does not restart
      * funding reconciliation, bypass cooldowns, or authorize a transaction. */
@@ -2276,6 +2586,9 @@ declare class YieldseekerAgent implements IAgent {
     private readonly endpointReadFailures;
     private readonly reconcileUntil;
     private readonly allocationRefresh;
+    /** Contexts whose next permitted snapshot read is forced once: a funding
+     * invalidation with a tx hash (receipt recovery, a re-armed refresh). */
+    private readonly forceNextSnapshot;
     private readonly activityRefreshUntil;
     private readonly snapshotMovements;
     private readonly movementEpochs;
@@ -2327,7 +2640,9 @@ declare class YieldseekerAgent implements IAgent {
     disconnect(): Promise<void>;
     activateAgent(state: ConnectionState, chainId: number, asset?: OwneySupportedTokens): Promise<void>;
     deposit(state: ConnectionState, chainId: number, amount: string, asset: OwneySupportedTokens, depositCallback?: DepositCallback, onProgress?: FundingProgress, onBeforeSubmission?: (evidence: FundingEvidence) => void | Promise<void>): Promise<OwneyDepositResult>;
-    withdraw(state: ConnectionState, chainId: number, asset: OwneySupportedTokens, amount?: string, onProgress?: FundingProgress, gasMode?: "auto" | "sponsored" | "paid", onBeforeSubmission?: FundingProgress, assertOperation?: () => void): Promise<AgentWithdrawResult>;
+    withdraw(state: ConnectionState, chainId: number, asset: OwneySupportedTokens, amount?: string, onProgress?: FundingProgress, gasMode?: "auto" | "sponsored" | "paid", onBeforeSubmission?: FundingProgress, assertOperation?: () => void, submission?: {
+        operationId?: string;
+    }): Promise<AgentWithdrawResult>;
     private withdrawInternal;
     /** Fresh position amounts for withdrawal planning, net of reserved fees. */
     getWithdrawableBalance(state: ConnectionState, chainId: number, asset: OwneySupportedTokens, minimumAmount?: bigint): Promise<bigint>;
@@ -2464,6 +2779,10 @@ declare class YieldseekerAgent implements IAgent {
     private snapshotMovement;
     private advancePortfolioVersion;
     private requestPortfolioSnapshot;
+    private snapshotPath;
+    /** True while `walletRequest` would refuse a read of `path`: this user's
+     * rate-limit cooldown or that endpoint's outage cooldown. */
+    private readCoolingDown;
     private portfolioSnapshot;
     private loadPortfolioContext;
     private loadActivityContext;
@@ -2610,6 +2929,24 @@ type StoredOrder = {
     amount: string;
     /** Epoch ms, for ordering recovery records. */
     createdAt: number;
+    /**
+     * A swap-deposit's deposit half, so a resume that finishes the swap can
+     * record it (ROUT-625). `received` is the quote's guaranteed minimum. Absent
+     * on plain swaps and on records written by an older SDK.
+     */
+    pendingDeposit?: {
+        received: string;
+        symbol: string;
+        chainId: number;
+        agentId?: string;
+        operationId?: string;
+    };
+    /**
+     * Our routing API accepted these secrets (part 5's opt-in handoff) and
+     * publishes them itself once 1inch is ready. Informational: this browser
+     * still publishes and resumes as before. Absent when no handoff was accepted.
+     */
+    serverSecrets?: true;
 };
 /**
  * Every unresolved stored order, newest first.
@@ -2617,6 +2954,13 @@ type StoredOrder = {
  */
 declare function listOrders(_now?: number): StoredOrder[];
 
+/**
+ * Capability flag (part 5): this SDK can hand a signed Fusion+ order's secrets
+ * to the routing API (`handoffSecrets`), which then publishes each one when
+ * 1inch is ready, even if this tab is gone. Older builds do not export this.
+ */
+declare const FUSION_SECRET_SERVER_PUBLISH: 1;
+
 /**
  * Non-blocking funding ledger reporter.
  *
@@ -2642,6 +2986,8 @@ type LedgerLegReport = {
     userOpHash?: string;
     callsId?: string;
     orderHash?: string;
+    /** The provider's own id for this leg's request (Zyfai's v2 withdrawal id). */
+    providerRef?: string;
     confirmedAmountRaw?: string;
     blockNumber?: string;
     errorCode?: string;
@@ -2660,4 +3006,26 @@ type LedgerLegReport = {
     };
 };
 
-export { type AccountAgentApy, type AccountApyOptions, type AccountDailyEarnings, type AgentApy, type AgentApyDetails, type AgentBalance, AgentChainIncompatibleError, type AgentEarnings, type AgentFundingLedgerAccess, type AgentHistoryEntry, type AgentHistoryPosition, type AgentId, AgentNotFoundError, type AgentSupportedAsset, type AgentSupportedAssets, type AgentUserProfile, type AgentWithdrawResult, type AgentsApyOptions, type AllocationAgentApy, type AllocationApyOptions, type ApyByChainAndAsset, type ApyHistoryPoint, type Asset, type AssetDailyEarnings, type AssetReadMetadata, type AvailableAgent, type AvailableAgentsOptions, type ConnectionState, type DailyApyDays, type DailyEarningsOptions, type DailyEarningsPoint, type DepositAuthorizationReference, type DepositCallback, type DepositOptions, type DepositReplacementValidation, type FundingEvidence, type FundingOperationKind, type FundingOperationLeg, type FundingOperationRow, type FundingProgress, type FundingStage, type HistoryAction, type HistoryFilters, type HistoryOptions, type HistoryTransaction, type IAgent, InvalidHistoryCursorError, type LedgerLegReport, type LookbackDays, NotConnectedError, type OwneyAccountApy, type OwneyAgentApy, type OwneyAgentHistory, type OwneyAllocationApy, type OwneyBalances, type OwneyDepositResult, type OwneyEarnings, OwneyError, type OwneyErrorCode, type OwneyMultiDepositResult, type OwneyPosition, OwneySDK, type OwneySDKConfig, type OwneySIWXConfig, type OwneySupportedChainId, type OwneySupportedChains, type OwneySupportedTokens, type OwneyToken, type OwneyUserProfile, type OwneyWithdrawResult, type PendingDeposit, type ProviderSnapshotSample, type RebalanceLog, type ReservationAgent, type ReservationReleaseReason, type RpcUrlsConfig, SDK_VERSION, type SwapChainTokens, type SwapDirection, type SwapOrderStatus, type SwapQuote, type SwapQuoteParams, type SwapRail, type SwapStage, type SwapTokenInfo, type SwapTokenSearchResult, type UnsignedUserOperationEvidence, type WithdrawOptions, type WithdrawSwapRecord, type WithdrawSwapStatus, type WithdrawalCompletion, type WithdrawalCompletionContext, type WithdrawalPayoutCandidate, type WithdrawalPayoutScan, type WithdrawalReservationConflict, type WithdrawalReservationMode, type WithdrawalReservationOptions, type WithdrawalSwapRecovery, YieldseekerAgent, type YieldseekerWalletStatus, type ZyfaiRpcUrlsConfig, clearWithdrawSwap, createOwneySIWX, listPendingDeposits, listOrders as listPendingSwaps, listWithdrawSwaps, saveWithdrawSwap, setOwneyDebug, subscribeWithdrawSwaps, updateWithdrawSwap };
+/** This SDK hands every Zyfai withdrawal request to the caller's
+ * `onBeforeSubmission` before sending it, and a failed checkpoint stops it.
+ * A caller that persisted nothing for a dead run can therefore conclude the
+ * request was never sent. Older builds do not export this. */
+declare const ZYFAI_WITHDRAW_DISPATCH_CHECKPOINT: 1;
+
+/** Capability flag: this SDK opts in to the server sending an accepted
+ * sponsored deposit itself (prepare `serverBroadcast: true`) and reports such a
+ * deposit as pending, never "not sent". Older builds do not export this. */
+declare const SPONSORED_DEPOSIT_SERVER_BROADCAST: 1;
+
+/** Capability flag: this SDK opts in to the server sending its signed sponsored
+ * Yieldseeker withdrawal userOp itself (`serverSubmit=1` on its own
+ * `eth_sendUserOperation`) and reports such a leg as pending, never "not sent".
+ * Older builds do not export this. */
+declare const YIELDSEEKER_WITHDRAW_SERVER_SUBMIT: 1;
+
+/** Capability flag: this SDK has `reportDepositRecovery`, which reports a
+ * deposit leg the app's recovery verified on chain to the funding ledger.
+ * Older builds do not export this. */
+declare const FUNDING_DEPOSIT_RECOVERY_REPORT: 1;
+
+export { type AccountAgentApy, type AccountApyOptions, type AccountDailyEarnings, type AgentApy, type AgentApyDetails, type AgentBalance, AgentChainIncompatibleError, type AgentEarnings, type AgentFundingLedgerAccess, type AgentHistoryEntry, type AgentHistoryPosition, type AgentId, AgentNotFoundError, type AgentSupportedAsset, type AgentSupportedAssets, type AgentUserProfile, type AgentWithdrawResult, type AgentsApyOptions, type AllocationAgentApy, type AllocationApyOptions, type ApyByChainAndAsset, type ApyHistoryPoint, type Asset, type AssetDailyEarnings, type AssetReadMetadata, type AvailableAgent, type AvailableAgentsOptions, type ConnectionState, type DailyApyDays, type DailyEarningsOptions, type DailyEarningsPoint, type DepositAuthorizationReference, type DepositCallback, type DepositOptions, type DepositReplacementValidation, FUNDING_DEPOSIT_RECOVERY_REPORT, FUSION_SECRET_SERVER_PUBLISH, type FundingEvidence, type FundingOperationKind, type FundingOperationLeg, type FundingOperationRow, type FundingProgress, type FundingStage, type HistoryAction, type HistoryFilters, type HistoryOptions, type HistoryTransaction, type IAgent, InvalidHistoryCursorError, type LedgerLegReport, type LookbackDays, NotConnectedError, type OwneyAccountApy, type OwneyAgentApy, type OwneyAgentHistory, type OwneyAllocationApy, type OwneyBalances, type OwneyDepositResult, type OwneyEarnings, OwneyError, type OwneyErrorCode, type OwneyMultiDepositResult, type OwneyPosition, OwneySDK, type OwneySDKConfig, type OwneySIWXConfig, type OwneySupportedChainId, type OwneySupportedChains, type OwneySupportedTokens, type OwneyToken, type OwneyUserProfile, type OwneyWithdrawResult, type PendingDeposit, type ProviderSnapshotSample, type RebalanceLog, type ReservationAgent, type ReservationReleaseReason, type RpcUrlsConfig, SDK_VERSION, SPONSORED_DEPOSIT_SERVER_BROADCAST, type SwapChainTokens, type SwapDirection, type SwapOrderStatus, type SwapQuote, type SwapQuoteParams, type SwapRail, type SwapStage, type SwapTokenInfo, type SwapTokenSearchResult, type UnsignedUserOperationEvidence, type WithdrawOptions, type WithdrawSwapRecord, type WithdrawSwapStatus, type WithdrawalCompletion, type WithdrawalCompletionContext, type WithdrawalPayoutCandidate, type WithdrawalPayoutScan, type WithdrawalReservationConflict, type WithdrawalReservationMode, type WithdrawalReservationOptions, type WithdrawalSwapRecovery, YIELDSEEKER_WITHDRAW_SERVER_SUBMIT, YieldseekerAgent, type YieldseekerWalletStatus, ZYFAI_REGISTRATION_NOT_SENT_CODES, ZYFAI_SERVER_TASKS, ZYFAI_WITHDRAWAL_NOT_SENT_CODES, ZYFAI_WITHDRAW_DISPATCH_CHECKPOINT, type ZyfaiDepositPlacement, type ZyfaiRpcUrlsConfig, type ZyfaiWithdrawalLifecycle, clearWithdrawSwap, createOwneySIWX, listPendingDeposits, listOrders as listPendingSwaps, listWithdrawSwaps, saveWithdrawSwap, setOwneyDebug, subscribeWithdrawSwaps, updateWithdrawSwap };