@circle-fin/provider-cctp-v2 1.8.2 → 1.8.4

package/index.d.ts

@@ -3279,8 +3279,14 @@ interface AdapterCapabilities {
     /**
      * The set of blockchain networks this adapter supports.
      * Used for validation, capability discovery, and to restrict operations to supported chains.
+     *
+     * @remarks
+     * Typed `readonly` to match the `@core/adapter-base` `AdapterCapabilities`
+     * shape, so the /next adapters (which preserve `readonly` capabilities per
+     * PR #853 A1) remain structurally assignable to this legacy `Adapter`
+     * contract. The collection is only ever read, never mutated.
      */
-    supportedChains: ChainDefinition[];
+    supportedChains: readonly ChainDefinition[];
 }
 /**
  * Abstract class defining the standard interface for an adapter that interacts with a specific blockchain.
@@ -3588,7 +3594,9 @@ declare abstract class Adapter<TAdapterCapabilities extends AdapterCapabilities
  * These settings control the behavior of the API polling process:
  * - timeout: Maximum time (ms) to wait for each request before aborting
  * - maxRetries: Maximum number of retry attempts for failed requests
- * - retryDelay: Time (ms) to wait between retry attempts
+ * - retryDelay: Base delay (ms); constant wait for `'fixed'` or exponential seed for `'exponential'`
+ * - backoff: Retry-delay strategy, `'fixed'` (default) or `'exponential'`
+ * - maxRetryDelayMs: Optional ceiling (ms) for a single backoff wait
  * - headers: Optional HTTP headers to include with each request
  */
 interface ApiPollingConfig {
@@ -3596,8 +3604,28 @@ interface ApiPollingConfig {
     timeout: number;
     /** Maximum number of retry attempts for failed requests */
     maxRetries: number;
-    /** Time in milliseconds to wait between retry attempts */
+    /**
+     * Delay in milliseconds between retry attempts. With the default
+     * `backoff: 'fixed'` strategy this is the constant wait; with
+     * `backoff: 'exponential'` it is the base the exponential backoff grows
+     * from (see {@link pollApiWithValidation}).
+     */
     retryDelay: number;
+    /**
+     * Retry-delay strategy. `'fixed'` (the default when omitted) waits a
+     * constant `retryDelay` between attempts; `'exponential'` grows the wait
+     * exponentially off `retryDelay` and randomizes it with full jitter, which
+     * spreads out retries so rate-limited (429) bursts do not retry in
+     * lockstep. Opt in per caller; existing callers keep the fixed delay.
+     */
+    backoff?: 'fixed' | 'exponential' | undefined;
+    /**
+     * Optional ceiling, in milliseconds, for a single backoff wait. Only
+     * applies when `backoff` is `'exponential'`: the exponential delay is
+     * capped at this value before jitter is applied. Defaults to
+     * {@link DEFAULT_MAX_RETRY_DELAY_MS} when omitted.
+     */
+    maxRetryDelayMs?: number | undefined;
     /** Optional HTTP headers to include with requests */
     headers?: Record<string, string> | undefined;
 }
@@ -4840,6 +4868,18 @@ interface InvocationMeta {
      * Example: [app, kit, provider]
      */
     readonly callers?: readonly Caller[] | undefined;
+    /**
+     * Cooperative cancellation signal for the invocation.
+     *
+     * @remarks
+     * When provided, the signal is threaded onto the resolved
+     * {@link InvocationContext} so operations can forward it to
+     * cancellable work (e.g. `fetch`, timers, adapter calls). Optional and
+     * backwards-compatible: callers that do not support cancellation simply
+     * omit it. Aborting the signal is the caller's responsibility; the
+     * runtime only propagates it.
+     */
+    readonly signal?: AbortSignal | undefined;
 }
 
 /**
@@ -6491,8 +6531,10 @@ declare class CCTPV2BridgingProvider extends BridgingProvider<CCTPV2Actions> imp
      *
      * This method validates that both chains have CCTP v2 contracts deployed and configured.
      * It uses the `isCCTPV2Supported` guard function to check each chain individually.
-     * When `useForwarder` is `true`, additionally checks that the source chain supports
-     * forwarding as source and the destination chain supports forwarding as destination.
+     * When `useForwarder` is `true`, additionally checks that the destination chain
+     * supports forwarding as a destination. The source chain's forwarding support is not
+     * checked: today's Forwarding Service operates on the destination, so any CCTP v2 chain
+     * can originate a forwarded transfer.
      *
      * @param source - The source chain definition to check for CCTP v2 support
      * @param destination - The destination chain definition to check for CCTP v2 support