@zkp2p/cash 0.4.9 → 0.4.11-rc.0

package/AGENTS.md

@@ -4,9 +4,10 @@
 > contribute to the SDK itself (layout, ground rules, CI, releasing), start at
 > [CLAUDE.md](https://github.com/zkp2p/peer-cash/blob/main/CLAUDE.md).
 
-You are integrating Peer Cash: an offramp that routes any Relay-supported EVM
-source asset into Base USDC, then converts Base USDC to fiat (Venmo, Revolut,
-Wise, Zelle, ...) at the live Chainlink market rate. The user whose USDC you
+You are integrating Peer Cash: an offramp that routes Relay-supported EVM
+assets or NEAR Intents 1Click external deposits into Base USDC, then converts
+Base USDC to fiat (Venmo, Revolut, Wise, Zelle, ...) at the live Chainlink
+market rate. The user whose USDC you
 manage is the **maker**; a buyer pays them fiat and proves it with TEE-TLS; the
 protocol releases the USDC. Funds are held by the protocol, and only the maker
 can withdraw an unmatched deposit.
@@ -30,7 +31,10 @@ can withdraw an unmatched deposit.
    mutating tools return unsigned transactions. `cash_source_quote` is a quote,
    not an execution tool; the host must execute and confirm Relay through its
    signer/runtime, use `cash_source_status` to monitor it, then call the
-   Base-USDC `cash_cashout` tool. Never pass `source` into `prepare()`.
+   Base-USDC `cash_cashout` tool. For NEAR Intents, persist
+   `cash_near_intents_quote`, fund its deposit address externally exactly once,
+   and poll `cash_near_intents_status` to `SUCCESS` before the Base cash-out.
+   Never pass `source` into `prepare()`.
 
 Every transaction (including approves) carries ERC-8021 attribution:
 `peer-cash`, then optional `peer-ref-XXXXXX` from the six-character
@@ -70,6 +74,8 @@ const cash = createCashClient({ environment: 'production' });
 const caps = cash.capabilities();
 // Optional: live Relay EVM source chains/tokens.
 const relayCaps = await cash.capabilities({ includeRelaySources: true });
+// Optional: live NEAR Intents 1Click external-deposit assets.
+const nearCaps = await cash.capabilities({ includeNearIntentsSources: true });
 
 // 2. Estimate - idempotent, cacheable, no side effects. Includes rolling ETA.
 const est = await cash.estimate({ amount: usdc(500), currency: 'EUR' });
@@ -148,6 +154,32 @@ console.log(routed.source?.amount);
 console.log(routed.source?.transactions?.origin, routed.source?.transactions?.destination);
 ```
 
+External-deposit source route (NEAR Intents / Zcash example):
+
+```ts
+const quote = await cash.quoteNearIntentsSource({
+  sourceAsset: 'nep141:zec.omft.near',
+  amount: usdc(1), // EXACT_OUTPUT is denominated in Base USDC units
+  recipient: signer.account.address,
+  refundTo: transparentZcashAddress,
+  tradeType: 'EXACT_OUTPUT',
+  deadline: new Date(Date.now() + 3 * 60_000).toISOString(),
+});
+persist(quote); // do this before the origin send
+const txHash = await zcashWallet.send(quote.depositAddress!, quote.inputAmount);
+await cash.submitNearIntentsDeposit({
+  depositAddress: quote.depositAddress!,
+  ...(quote.depositMemo ? { depositMemo: quote.depositMemo } : {}),
+  txHash,
+});
+const route = await cash.nearIntentsStatus({
+  depositAddress: quote.depositAddress!,
+  ...(quote.depositMemo ? { depositMemo: quote.depositMemo } : {}),
+  expectedQuote: quote,
+});
+// Reconcile the Base receipt/output when route.status === 'SUCCESS', then cash out Base-only.
+```
+
 ## Rules that prevent wrong behavior
 
 - **Never promise a rate.** `estimate()` is `kind: 'oracle-estimate'`; the
@@ -165,6 +197,15 @@ console.log(routed.source?.transactions?.origin, routed.source?.transactions?.de
   `sourceSigner`. Use `EXACT_INPUT` in high-level cash-out flows so `amount`
   remains source-token base units. `source.amount` is Relay's guaranteed
   minimum output and the exact Base USDC deposit amount.
+- **Treat NEAR Intents as an external-deposit route.** Discover asset ids with
+  `capabilities({ includeNearIntentsSources: true })`. Persist the signed quote,
+  deposit address, optional memo, and deadline before sending. Browser code
+  uses a same-origin proxy so the 1Click JWT remains server-side. Never reuse
+  an expired route or resend after an uncertain wallet submission.
+- **A failed NEAR deposit notification is not a failed send.** Retry only
+  `submitNearIntentsDeposit()` with the same address and hash; 1Click also
+  detects source deposits on-chain. Wait for `nearIntentsStatus()` `SUCCESS`
+  and reconcile its destination evidence before a Base-only cash-out.
 - **Use a nonce-managed source signer for routed cashouts.** Relay routes
   with more than one source-chain transaction (approve, then route) are
   refused preflight with `SOURCE_NONCE_MANAGER_REQUIRED` on plain local
@@ -236,6 +277,7 @@ Every `CashError` carries `code`, `retryable`, `remediation`. Behavior:
 | `SOURCE_QUOTE_FAILED`                   | yes       | Refresh capabilities and request a new canonical Base-USDC quote                           |
 | `SOURCE_NONCE_MANAGER_REQUIRED`         | no        | Preflight; recreate the source signer with viem's `nonceManager`, then quote again         |
 | `SOURCE_EXECUTION_FAILED`               | no        | Inspect source transactions and Relay status before any retry                              |
+| `SOURCE_DEPOSIT_SUBMISSION_FAILED`      | yes       | Retry only the 1Click notification; never resend source funds                              |
 | `SOURCE_STATUS_FAILED`                  | yes       | Retry only the status read                                                                 |
 | `SOURCE_ROUTE_COMPLETED_CASHOUT_FAILED` | no        | Do not route again; retry Base-only with `recovery.amount`                                 |
 | `SOURCE_CASHOUT_SUBMISSION_UNKNOWN`     | no        | Inspect Base activity and orders; prove no deposit exists before retrying                  |

package/README.md

@@ -1,8 +1,9 @@
 # @zkp2p/cash
 
-Route any Relay-supported EVM source asset into Base USDC, then cash out to
-fiat on Venmo, Revolut, Wise, Zelle, and more at the live Chainlink market
-rate, with zero spread and no centralized off-ramp provider.
+Route Relay-supported EVM assets or NEAR Intents 1Click external deposits into
+Base USDC, then cash out to fiat on Venmo, Revolut, Wise, Zelle, and more at the
+live Chainlink market rate, with zero spread and no centralized off-ramp
+provider.
 
 Peer Cash is an **offramp-only** SDK for the [ZKP2P](https://peer.xyz)
 protocol. The cashing-out user is the maker: their USDC becomes a deposit in
@@ -100,9 +101,12 @@ arbitrary protocol operations.
 | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
 | `capabilities()`                                               | Sync discovery: Base USDC destination/default source, platforms × currencies × payee hints × amount bounds                      |
 | `capabilities({ includeRelaySources: true })`                  | Async discovery: adds live Relay SDK EVM source chains/tokens                                                                   |
+| `capabilities({ includeNearIntentsSources: true })`            | Async discovery: adds live NEAR Intents 1Click source assets                                                                    |
 | `fillStats()`                                                  | Cached 30-day fill counts and median first-fill time per exact `platform:currency` pair or sorted multi-currency set            |
 | `quoteSource(input)` / `executeSourceQuote(quote, { signer })` | Relay SDK EVM source routing into Base USDC before cashout                                                                      |
 | `relayStatus(requestId)`                                       | Relay request status from the Relay SDK request path                                                                            |
+| `quoteNearIntentsSource(input)`                                | Signed 1Click quote with an origin-chain deposit address and optional memo                                                      |
+| `submitNearIntentsDeposit(input)` / `nearIntentsStatus(input)` | Optionally register an origin tx, then track 1Click delivery/refund evidence                                                    |
 | `estimate({ amount, currency }, { includeEta? })`              | Base USDC oracle estimate; optionally skip the historical ETA for progressive rendering                                         |
 | `cashout(input, { signer })`                                   | Creates the order with any viem wallet; Venmo, Cash App, and PayPal then attach the canonical access groups                     |
 | `prepare(input)` / `finalizePreparedCashout(receipt)`          | Prepare external signing, resolve the deposit, then check `accessPolicyRequired` for the follow-up                              |
@@ -176,7 +180,9 @@ extension. An already-registered Wise or PayPal handle can be reused with bare
 payee data. A new handle without its signed attestation fails during curator
 registration with `PAYEE_VERIFICATION_REQUIRED`, before funds move on-chain.
 
-## Source routing (any EVM asset in)
+## Source routing
+
+### Relay (signed EVM route)
 
 The default/minimal flow is unchanged: pass Base USDC base units to
 `estimate()` and `cashout()`. For any other source asset, pass `source` to
@@ -216,6 +222,58 @@ refuses the route preflight with `SOURCE_NONCE_MANAGER_REQUIRED` instead of
 letting the route transaction reuse the approval's nonce and revert
 mid-route. Browser wallets are unaffected.
 
+### NEAR Intents (external-deposit route)
+
+NEAR Intents 1Click supports non-EVM origins such as Zcash, so the SDK does
+not pretend a viem wallet can execute the source transfer. It returns a signed
+quote with an origin-chain `depositAddress` and optional `depositMemo`; your
+wallet sends exactly once, then the SDK tracks the provider route into
+canonical Base USDC. Use `EXACT_OUTPUT` when the Peer order amount must be
+known before the origin send.
+
+```ts
+const cash = createCashClient({
+  environment: 'production',
+  nearIntents: {
+    // Browser-safe same-origin proxy; it keeps the 1Click JWT server-side.
+    apiUrl: '/api/v1/near',
+    transport: 'proxy',
+  },
+});
+
+const sources = await cash.capabilities({ includeNearIntentsSources: true });
+const zec = sources.source.nearIntents?.assets.find((asset) => asset.symbol === 'ZEC');
+const quote = await cash.quoteNearIntentsSource({
+  sourceAsset: zec!.assetId,
+  amount: 1_000_000n, // exact 1 Base USDC output
+  recipient: baseSigner.account.address,
+  refundTo: transparentZcashRefundAddress,
+  tradeType: 'EXACT_OUTPUT',
+  deadline: new Date(Date.now() + 3 * 60_000).toISOString(),
+});
+
+persist(quote); // before sending: address, memo, signed response, deadline
+const originTxHash = await zcashWallet.send(quote.depositAddress!, quote.inputAmount);
+await cash.submitNearIntentsDeposit({
+  depositAddress: quote.depositAddress!,
+  ...(quote.depositMemo ? { depositMemo: quote.depositMemo } : {}),
+  txHash: originTxHash,
+});
+const route = await cash.nearIntentsStatus({
+  depositAddress: quote.depositAddress!,
+  ...(quote.depositMemo ? { depositMemo: quote.depositMemo } : {}),
+  expectedQuote: quote,
+});
+// On SUCCESS, reconcile the Base receipt/balance, then call Base-only cashout().
+```
+
+Direct server integrations may pass `nearIntents: { token }`. Browser code
+must use a same-origin proxy and must never receive the 1Click JWT. Never reuse
+an expired deposit address, resend funds after an uncertain wallet submission,
+or infer success from a wallet-wide balance alone. If optional deposit
+registration fails, retry only `submitNearIntentsDeposit()` with the same hash;
+1Click can also detect the transfer on-chain.
+
 ## Source-route recovery
 
 Persist `depositId`, transaction hashes, and the Relay `requestId` as soon as
@@ -227,6 +285,9 @@ they are available. A source-routed result includes both a flat
   can stay in `relayStatus` `waiting` indefinitely. Decide from the error's
   recovery payload and origin transactions, never by waiting for a terminal
   Relay status.
+- `SOURCE_DEPOSIT_SUBMISSION_FAILED`: the NEAR Intents origin transaction may
+  already be final. Retry only the provider notification with the same address
+  and hash; never resend source funds.
 - `SOURCE_ROUTE_COMPLETED_CASHOUT_FAILED`: Relay completed, but the Base
   cashout was not created. Do not route again. Retry a Base-USDC-only
   `cashout()` with `BigInt(error.recovery.amount)`.
@@ -363,6 +424,7 @@ Runnable first-party examples in [`examples/`](examples):
 
 - [`node-cashout.ts`](examples/node-cashout.ts) - server-side cash-out with a private-key signer, plus order tracking.
 - [`agent-tool-use.ts`](examples/agent-tool-use.ts) - wiring the verbs into an agent tool-use loop with host-side signing.
+- [`mpp-merchant-cashout`](examples/mpp-merchant-cashout) - turn confirmed MPP merchant revenue into an unsigned Peer Cash plan while the merchant keeps custody and signing.
 
 ## Trust model, honestly
 

package/dist/{chunk-4LPWKZMW.js → chunk-3PAHKWJ2.js}

@@ -217,21 +217,21 @@ var errors = {
     retryable: false,
     remediation: `For one-call source cashout, deliver Relay output to the depositor address. For a different recipient, bridge first and then cash out from that recipient's signer.`
   }),
-  sourceCapabilitiesFailed: (cause) => new CashError(
+  sourceCapabilitiesFailed: (cause, provider = "Relay", capabilityMethod = "sourceCapabilities") => new CashError(
     {
       code: "SOURCE_CAPABILITIES_FAILED",
-      message: `Relay source-chain discovery failed.`,
+      message: `${provider} source discovery failed.`,
       retryable: true,
-      remediation: `Retry sourceCapabilities() shortly, or use the default Base USDC path.`
+      remediation: `Retry ${capabilityMethod}() shortly, or use the default Base USDC path.`
     },
     { cause }
   ),
-  sourceQuoteFailed: (cause) => new CashError(
+  sourceQuoteFailed: (cause, provider = "Relay", quoteMethod = "quoteSource") => new CashError(
     {
       code: "SOURCE_QUOTE_FAILED",
-      message: `Relay did not return a valid route to canonical Base USDC.`,
+      message: `${provider} did not return a valid route to canonical Base USDC.`,
       retryable: true,
-      remediation: `Refresh source capabilities and request a new quote. Do not submit transactions from this response.`
+      remediation: `Refresh source capabilities and call ${quoteMethod}() again. Do not submit transactions from this response.`
     },
     { cause }
   ),
@@ -258,12 +258,21 @@ var errors = {
     },
     { cause }
   ),
-  sourceStatusFailed: (requestId, cause) => new CashError(
+  sourceDepositSubmissionFailed: (depositAddress, cause) => new CashError(
+    {
+      code: "SOURCE_DEPOSIT_SUBMISSION_FAILED",
+      message: `NEAR Intents could not register the origin transaction for deposit ${depositAddress}.`,
+      retryable: true,
+      remediation: `Retry only submitNearIntentsDeposit() with the same deposit address and origin transaction hash. Never resend the source funds; 1Click can also detect the deposit on-chain.`
+    },
+    { cause }
+  ),
+  sourceStatusFailed: (requestId, cause, provider = "Relay", statusMethod = "relayStatus") => new CashError(
     {
       code: "SOURCE_STATUS_FAILED",
-      message: `Relay status is unavailable for request ${requestId}.`,
+      message: `${provider} status is unavailable for route ${requestId}.`,
       retryable: true,
-      remediation: `Retry relayStatus(requestId) shortly; keep the request id and transaction hashes for recovery.`
+      remediation: `Retry ${statusMethod}() shortly; keep the route identifier and transaction hashes for recovery.`
     },
     { cause }
   ),

package/dist/{createCashClient-Br7uu4lQ.d.cts → createCashClient-BDp6CSBD.d.cts}

@@ -293,6 +293,178 @@ interface RelayStatus {
     raw: unknown;
 }
 
+/**
+ * Peer Cash - engine constants.
+ *
+ * Peer Cash is an async crypto→fiat offramp built on the maker/deposit side of
+ * the protocol: the cashing-out user IS the maker. They create a deposit at the
+ * live oracle/market rate (0% spread); a buyer (a standard taker) signals an
+ * intent, pays fiat, and proves it via the standard TEE-TLS flow, releasing the
+ * user's crypto. The protocol is reused in its existing direction - no proof
+ * inversion, no sell-side quote.
+ */
+
+/** Base chain id - Peer Cash settles in Base USDC. */
+declare const BASE_CHAIN_ID = 8453;
+/** Canonical USDC on Base (6 decimals). The deposit asset for every cash-out. */
+declare const BASE_USDC_ADDRESS: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+/** USDC has 6 decimals. */
+declare const USDC_DECIMALS = 6;
+/**
+ * Market rate = the live Chainlink oracle with **zero spread**. The user sets no
+ * rate; selling at market is the fast-fill incentive (the deposit is the best
+ * deal on the book, so buyers have reason to take it quickly).
+ */
+declare const MARKET_SPREAD_BPS = 0;
+/**
+ * EscrowV2 rejects a zero `minConversionRate` even when an oracle-backed rate
+ * config is attached. Use the smallest non-zero sentinel so the oracle rate
+ * still fully determines pricing while satisfying the on-chain invariant.
+ */
+declare const ORACLE_MIN_CONVERSION_RATE_SENTINEL = 1n;
+/**
+ * The full intent-status set a cash-out order can pass through. The indexer's
+ * `getIntentsForDeposits` defaults to `['SIGNALED']` only - passing this
+ * explicit set is REQUIRED, otherwise `delivered`/`returned` states are
+ * silently filtered out.
+ */
+declare const CASH_ORDER_STATUSES: IntentStatus[];
+/** Default polling cadence for an in-flight order (ms). Matches the protocol's active-intent polling. */
+declare const CASH_ORDER_POLL_INTERVAL_MS = 5000;
+/**
+ * Default deposit config for every Peer Cash deposit: a one-shot cash-out
+ * cleans up when fully filled rather than lingering empty.
+ */
+declare const CASH_RETAIN_ON_EMPTY = false;
+
+declare const NEAR_INTENTS_API_URL = "https://1click.chaindefuser.com";
+declare const NEAR_INTENTS_BASE_USDC_ASSET_ID = "nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near";
+declare const NEAR_INTENTS_DEFAULT_SLIPPAGE_BPS = 100;
+interface NearIntentsToken {
+    [key: string]: unknown;
+    assetId: string;
+    symbol: string;
+    decimals: number;
+    blockchain: string;
+    price?: string | number | null | undefined;
+    priceUpdatedAt?: string | undefined;
+    contractAddress?: string | null | undefined;
+}
+interface NearIntentsSourceCapabilities {
+    destination: {
+        assetId: typeof NEAR_INTENTS_BASE_USDC_ASSET_ID;
+        chainId: typeof BASE_CHAIN_ID;
+        address: typeof BASE_USDC_ADDRESS;
+        symbol: 'USDC';
+        decimals: typeof USDC_DECIMALS;
+    };
+    assets: NearIntentsToken[];
+    source: 'near-intents';
+    asOf: number;
+}
+interface NearIntentsOptions {
+    /** 1Click origin. Defaults to the official API, or to the app proxy root in proxy mode. */
+    apiUrl?: string;
+    /** Server-side 1Click JWT. Never expose this option in browser code. */
+    token?: string;
+    fetch?: typeof globalThis.fetch;
+    /** Direct uses official `/v0/*` endpoints; proxy uses `/tokens|quote|submit|status`. */
+    transport?: 'direct' | 'proxy';
+    timeoutMs?: number;
+}
+type NearIntentsTradeType = 'EXACT_INPUT' | 'EXACT_OUTPUT';
+interface NearIntentsQuoteInput {
+    /** NEAR Intents asset id from `nearIntentsCapabilities()`. */
+    sourceAsset: string;
+    /** Source units for EXACT_INPUT; Base USDC units for EXACT_OUTPUT. */
+    amount: bigint;
+    /** Base address that will receive canonical USDC. */
+    recipient: string;
+    /** Refund address on the source chain. */
+    refundTo: string;
+    tradeType: NearIntentsTradeType;
+    deadline: string;
+    slippageTolerance?: number;
+    dry?: boolean;
+}
+interface NearIntentsQuoteRequest {
+    dry: boolean;
+    swapType: NearIntentsTradeType;
+    slippageTolerance: number;
+    originAsset: string;
+    depositType: 'ORIGIN_CHAIN';
+    destinationAsset: typeof NEAR_INTENTS_BASE_USDC_ASSET_ID;
+    amount: string;
+    refundTo: string;
+    refundType: 'ORIGIN_CHAIN';
+    recipient: string;
+    recipientType: 'DESTINATION_CHAIN';
+    deadline: string;
+    depositMode: 'SIMPLE';
+}
+interface NearIntentsQuote {
+    provider: 'near-intents';
+    correlationId?: string;
+    sourceAsset: string;
+    destinationAsset: typeof NEAR_INTENTS_BASE_USDC_ASSET_ID;
+    inputAmount: bigint;
+    minInputAmount: bigint;
+    outputAmount: bigint;
+    minOutputAmount: bigint;
+    timeEstimateSeconds?: number;
+    depositAddress?: string;
+    depositMemo?: string;
+    deadline?: string;
+    signature: string;
+    request: NearIntentsQuoteRequest;
+    raw: unknown;
+}
+interface NearIntentsDepositInput {
+    depositAddress: string;
+    txHash: string;
+    depositMemo?: string;
+}
+interface NearIntentsStatusInput {
+    depositAddress: string;
+    depositMemo?: string;
+    /** Persisted signed quote used to reject status for a different route identity. */
+    expectedQuote?: NearIntentsQuote;
+}
+declare const NEAR_INTENTS_STATUSES: readonly ["PENDING_DEPOSIT", "KNOWN_DEPOSIT_TX", "PROCESSING", "SUCCESS", "INCOMPLETE_DEPOSIT", "REFUNDED", "FAILED"];
+type NearIntentsStatusCode = (typeof NEAR_INTENTS_STATUSES)[number];
+interface NearIntentsTransaction {
+    hash: string;
+    explorerUrl?: string;
+}
+interface NearIntentsStatus {
+    provider: 'near-intents';
+    correlationId?: string;
+    depositAddress: string;
+    depositMemo?: string;
+    status: NearIntentsStatusCode;
+    updatedAt?: string;
+    inputAmount?: bigint;
+    outputAmount?: bigint;
+    refundedAmount?: bigint;
+    refundReason?: string;
+    intentHashes: string[];
+    nearTransactionHashes: string[];
+    originTransactions: NearIntentsTransaction[];
+    destinationTransactions: NearIntentsTransaction[];
+    raw: unknown;
+}
+interface NearIntentsClient {
+    capabilities(): Promise<NearIntentsSourceCapabilities>;
+    quoteToBaseUsdc(input: NearIntentsQuoteInput): Promise<NearIntentsQuote>;
+    submitDeposit(input: NearIntentsDepositInput): Promise<NearIntentsStatus>;
+    status(input: NearIntentsStatusInput): Promise<NearIntentsStatus>;
+}
+declare function createNearIntentsClient(options?: NearIntentsOptions): NearIntentsClient;
+declare function readNearIntentsSourceCapabilities(options?: NearIntentsOptions): Promise<NearIntentsSourceCapabilities>;
+declare function quoteNearIntentsToBaseUsdc(input: NearIntentsQuoteInput, options?: NearIntentsOptions): Promise<NearIntentsQuote>;
+declare function submitNearIntentsDeposit(input: NearIntentsDepositInput, options?: NearIntentsOptions): Promise<NearIntentsStatus>;
+declare function readNearIntentsStatus(input: NearIntentsStatusInput, options?: NearIntentsOptions): Promise<NearIntentsStatus>;
+
 /** Hard floor: below one cent a deposit is dust and can never fill. */
 declare const MIN_CASHOUT_AMOUNT = 10000n;
 /** Recommended floor: sub-1-USDC deposits force min==max fills and starve matching. */
@@ -337,7 +509,8 @@ interface CashCapabilities {
     };
     /**
      * Source discovery. The sync default is Base USDC only; pass
-     * `{ includeRelaySources: true }` to `capabilities()` for live Relay EVM sources.
+     * `{ includeRelaySources: true }` or `{ includeNearIntentsSources: true }`
+     * to `capabilities()` for live bridge source assets.
      */
     source: {
         default: {
@@ -349,6 +522,7 @@ interface CashCapabilities {
             };
         };
         relay?: CashSourceCapabilities;
+        nearIntents?: NearIntentsSourceCapabilities;
     };
     /** Every payout corridor: platform × oracle-priced currencies. */
     platforms: CashPlatformCapability[];
@@ -490,6 +664,8 @@ interface CashClientOptions {
     apiKey?: string;
     /** Relay API configuration for source assets outside Base USDC. */
     relay?: RelayOptions;
+    /** NEAR Intents 1Click configuration for externally funded source routes. */
+    nearIntents?: NearIntentsOptions;
     /**
      * Your six-character referral code from the Peer mobile or web app. The SDK
      * emits `peer-ref-XXXXXX`; when this deposit fills, Curator routes the
@@ -648,9 +824,15 @@ interface CashClient {
     /** 0b - Discovery with live Relay-supported EVM source chains/tokens. */
     capabilities(options: {
         includeRelaySources: true;
+        includeNearIntentsSources?: true;
+    }): Promise<CashCapabilities>;
+    /** 0c - Discovery with live NEAR Intents 1Click source assets. */
+    capabilities(options: {
+        includeRelaySources?: true;
+        includeNearIntentsSources: true;
     }): Promise<CashCapabilities>;
     /**
-     * 0c - Raw 30-day demand and first-fill speed evidence keyed by an exact
+     * 0d - Raw 30-day demand and first-fill speed evidence keyed by an exact
      * `platform:currency` pair or sorted multi-currency set. A recommended
      * consumer gate is `fills >= 10 && medianFillSeconds <= 48h`; fail open to
      * the full capability catalog when stats are unavailable or the gate would
@@ -672,6 +854,14 @@ interface CashClient {
     }): Promise<RelayExecutionResult>;
     /** Track Relay execution status by quote/request id. */
     relayStatus(requestId: string): Promise<RelayStatus>;
+    /** Discover live NEAR Intents assets that can route into canonical Base USDC. */
+    nearIntentsCapabilities(): Promise<NearIntentsSourceCapabilities>;
+    /** Quote a NEAR Intents external-deposit route into canonical Base USDC. */
+    quoteNearIntentsSource(input: NearIntentsQuoteInput): Promise<NearIntentsQuote>;
+    /** Optionally register an already-broadcast origin transaction with 1Click. */
+    submitNearIntentsDeposit(input: NearIntentsDepositInput): Promise<NearIntentsStatus>;
+    /** Track a NEAR Intents route by its provider-issued deposit address and memo. */
+    nearIntentsStatus(input: NearIntentsStatusInput): Promise<NearIntentsStatus>;
     /** 1 - Estimate: currency + amount only. No payee, no side effects, no expiry. */
     estimate(input: EstimateInput, options?: EstimateOptions): Promise<CashEstimate>;
     /** 2 - Cash out: payee registration + deposit params + submission happen here. */
@@ -720,4 +910,4 @@ interface CashClient {
 }
 declare function createCashClient(options: CashClientOptions): CashClient;
 
-export { type WithdrawOptions as $, type CashPayeeInput as A, type CashPayout as B, type CashPayoutInfo as C, type CashPayoutPricing as D, type CashPlatformCapability as E, type CashPreparedStepKind as F, type CashReceiveLeg as G, type CashoutInput as H, type IntentStatus as I, type CashoutOptions as J, type CuratorPayeeDataInput as K, type EstimateInput as L, type EstimateOptions as M, MIN_CASHOUT_AMOUNT as N, type OrdersOptions as O, type PrepareResult as P, type PreparedCashoutReceipt as Q, type RelayExecutionResult as R, RECOMMENDED_MIN_CASHOUT_AMOUNT as S, type TopUpResult as T, type RelayOptions as U, type RelayQuoteInput as V, type WithdrawResult as W, type RelaySourceInput as X, type RelayTransaction as Y, type SignerOptions as Z, type WatchOptions as _, type IntentEntity as a, buildCapabilities as a0, createCashClient as a1, normalizeCashPayee as a2, toCashReferralAttributionCode as a3, type CashBuyerProfile as b, type CashDepositInput as c, type CreateDepositParamsArg as d, type CashOrder as e, type CashFill as f, type CashCapabilities as g, type CashoutResult as h, type CashEstimate as i, type CashFillStats as j, type CashPreparedStep as k, type RelayQuote as l, type RelayStatus as m, type CashSourceCapabilities as n, CASH_ATTRIBUTION_CODE as o, CASH_REFERRAL_ATTRIBUTION_PREFIX as p, type CashAsset as q, type CashChain as r, type CashClient as s, type CashClientOptions as t, type CashFillEta as u, type CashLeg as v, type CashMultiCurrencyLeg as w, type CashNextAction as x, type CashOrderState as y, type CashPairFillStats as z };
+export { MARKET_SPREAD_BPS as $, type CashClient as A, BASE_CHAIN_ID as B, type CashPayoutInfo as C, type CashClientOptions as D, type CashFillEta as E, type CashLeg as F, type CashMultiCurrencyLeg as G, type CashNextAction as H, type IntentEntity as I, type CashOrderState as J, type CashPairFillStats as K, type CashPayeeInput as L, type CashPayout as M, type NearIntentsSourceCapabilities as N, type CashPayoutPricing as O, type PrepareResult as P, type CashPlatformCapability as Q, type RelayExecutionResult as R, type CashPreparedStepKind as S, type TopUpResult as T, type CashReceiveLeg as U, type CashoutInput as V, type WithdrawResult as W, type CashoutOptions as X, type CuratorPayeeDataInput as Y, type EstimateInput as Z, type EstimateOptions as _, type CashBuyerProfile as a, MIN_CASHOUT_AMOUNT as a0, NEAR_INTENTS_API_URL as a1, NEAR_INTENTS_BASE_USDC_ASSET_ID as a2, NEAR_INTENTS_DEFAULT_SLIPPAGE_BPS as a3, NEAR_INTENTS_STATUSES as a4, type NearIntentsClient as a5, type NearIntentsOptions as a6, type NearIntentsQuoteRequest as a7, type NearIntentsStatusCode as a8, type NearIntentsToken as a9, type NearIntentsTradeType as aa, type NearIntentsTransaction as ab, ORACLE_MIN_CONVERSION_RATE_SENTINEL as ac, type OrdersOptions as ad, type PreparedCashoutReceipt as ae, RECOMMENDED_MIN_CASHOUT_AMOUNT as af, type RelayOptions as ag, type RelayQuoteInput as ah, type RelaySourceInput as ai, type RelayTransaction as aj, type SignerOptions as ak, USDC_DECIMALS as al, type WatchOptions as am, type WithdrawOptions as an, buildCapabilities as ao, createCashClient as ap, createNearIntentsClient as aq, normalizeCashPayee as ar, quoteNearIntentsToBaseUsdc as as, readNearIntentsSourceCapabilities as at, readNearIntentsStatus as au, submitNearIntentsDeposit as av, toCashReferralAttributionCode as aw, type CashDepositInput as b, type CreateDepositParamsArg as c, type CashOrder as d, type CashFill as e, type CashCapabilities as f, type CashoutResult as g, type CashEstimate as h, type CashFillStats as i, type NearIntentsDepositInput as j, type NearIntentsQuote as k, type NearIntentsQuoteInput as l, type NearIntentsStatus as m, type NearIntentsStatusInput as n, type CashPreparedStep as o, type RelayQuote as p, type RelayStatus as q, type CashSourceCapabilities as r, BASE_USDC_ADDRESS as s, CASH_ATTRIBUTION_CODE as t, CASH_ORDER_POLL_INTERVAL_MS as u, CASH_ORDER_STATUSES as v, CASH_REFERRAL_ATTRIBUTION_PREFIX as w, CASH_RETAIN_ON_EMPTY as x, type CashAsset as y, type CashChain as z };