@meshconnect/web-link-sdk 3.13.0 → 3.14.1

package/utils/backup.js

@@ -0,0 +1,96 @@
+import { appendQueryParam } from './url';
+/**
+ * Default origin for the standalone backup deposit widget (OR-449): the production
+ * Cloudflare Worker. It is under the `meshconnect.com` zone but served by
+ * Cloudflare, not Azure, so it shares no failure domain with the primary Mesh API
+ * (design doc §5C) — if the core API is down the widget still loads. Matches the
+ * React Native SDK's default. Override per-call via `openLinkBackup`'s
+ * `widgetOrigin` option for staging, demo, or self-host. Money path: this origin
+ * serves the deposit-address UI during an outage.
+ */
+export var DEFAULT_BACKUP_WIDGET_ORIGIN = 'https://backup.meshconnect.com';
+/**
+ * The `type` the backup widget's message bridge requires on the config it
+ * receives. The widget matches `event.data.type === 'meshBackupConfig'` and
+ * drops any message without it, so the config must be delivered as
+ * `{ type: BACKUP_CONFIG_MESSAGE_TYPE, payload: MeshBackupConfig }`.
+ */
+export var BACKUP_CONFIG_MESSAGE_TYPE = 'meshBackupConfig';
+/**
+ * JIT-over-bridge RPC message types (OR-452). An address-less destination is
+ * resolved by the widget invoking the host's `onAddressInit`/`onStatusPoll`
+ * callbacks over this same postMessage bridge, correlated by `callId` — the
+ * widget never calls a client HTTP endpoint and holds no token.
+ *
+ * - Widget → host: `{ type: JIT_REQUEST_MESSAGE_TYPE, payload: MeshBackupJitRequestPayload }`
+ * - Host → widget: `{ type: JIT_RESPONSE_MESSAGE_TYPE, payload: MeshBackupJitResponsePayload }`
+ *
+ * ⚠️ KEEP IN SYNC with `mesh-backup-widget`'s `src/bridge/contract.ts` — the
+ * string values and payload shapes are the frozen cross-repo contract.
+ */
+export var JIT_REQUEST_MESSAGE_TYPE = 'meshBackupJitRequest';
+export var JIT_RESPONSE_MESSAGE_TYPE = 'meshBackupJitResponse';
+/**
+ * How long to wait for the Tier-1 widget's ready handshake (its `loaded`
+ * message) after the iframe starts loading the backup origin, before treating
+ * the origin as unreachable and cascading to the bundled Tier-2 assets.
+ *
+ * On the web this is the **authoritative** Tier-1 failure signal: a cross-origin
+ * iframe does not reliably fire a load `error` event for a network/DNS failure
+ * (and `onload` fires even for an error page), so a served-but-broken, hung, or
+ * captive-portal-intercepted origin is only caught by the absence of the ready
+ * handshake. 5000 ms absorbs a slow mobile network with margin (the widget shell
+ * is ~24 KB on a CDN) while keeping the degraded-path UX acceptable. Per-SDK
+ * tunable constant (design §5H).
+ */
+export var TIER1_READY_TIMEOUT_MS = 5000;
+/**
+ * Fail-closed safety net for Tier 2: the bundled assets load from a local `blob:`
+ * URL, so they should complete the ready handshake near-instantly.
+ * If they somehow do not within this window, the flow exits with an error rather
+ * than sitting on a blank screen (design §5A/§5H — never a blank QR). Deliberately
+ * generous because a Tier-2 timeout should be effectively unreachable.
+ */
+export var TIER2_READY_TIMEOUT_MS = 8000;
+/** URL parameter carrying the per-open session nonce (query for Tier 1, fragment
+ *  for the Tier-2 `blob:` URL). KEEP IN SYNC with `mesh-backup-widget`'s
+ *  `src/bridge/sessionNonce.ts`. */
+export var SESSION_NONCE_PARAM = 'sid';
+/**
+ * A fresh, unguessable nonce for one backup open (128 bits, hex). Navigating an
+ * embedded iframe keeps its `WindowProxy` and Tier-1 sessions share an origin, so
+ * `event.source` + origin alone can't tell the current open's messages from ones
+ * the previous document queued before a reopen; the widget echoes this value as
+ * `sid` on every message and the SDK drops any that don't match.
+ */
+export function createSessionNonce() {
+    var bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, function (b) { return b.toString(16).padStart(2, '0'); }).join('');
+}
+/**
+ * Builds the URL the backup-widget iframe loads. Unlike the primary path there
+ * is no link token to decode — the widget is a static SPA at `origin` and is
+ * hydrated with the `MeshBackupConfig` over the message bridge after load. Only
+ * non-sensitive display hints are carried on the URL; the deposit config never
+ * appears in it.
+ *
+ * A trailing slash on `origin` is normalised away so params attach cleanly.
+ */
+export function buildBackupWidgetUrl(origin, params) {
+    // Trim trailing slashes with an index walk, not `/\/+$/` — the anchored `+`
+    // backtracks super-linearly (Sonar S8786) on a run of slashes before a non-slash.
+    var sliceEnd = origin.length;
+    while (sliceEnd > 0 && origin[sliceEnd - 1] === '/')
+        sliceEnd -= 1;
+    var url = origin.slice(0, sliceEnd);
+    url = appendQueryParam(url, 'platform', params.platform);
+    url = appendQueryParam(url, 'sdkVersion', params.sdkVersion);
+    if (params.theme) {
+        url = appendQueryParam(url, 'theme', params.theme);
+    }
+    if (params.sessionNonce) {
+        url = appendQueryParam(url, SESSION_NONCE_PARAM, params.sessionNonce);
+    }
+    return url;
+}

package/utils/backupTier.d.ts

@@ -0,0 +1,55 @@
+/** Which redundancy tier the backup flow is currently serving (design §5H). */
+export type BackupTier = 'tier1' | 'tier2';
+/**
+ * Why Tier 1 was abandoned. `loadError` = a hard iframe load failure on the
+ * backup-origin document; `readyTimeout` = the widget did not complete its ready
+ * handshake within {@link TIER1_READY_TIMEOUT_MS} (the authoritative signal on
+ * web, where a cross-origin iframe rarely fires a load `error`).
+ */
+export type BackupTierFallbackReason = 'loadError' | 'readyTimeout';
+export interface BackupTierControllerCallbacks {
+    /**
+     * Called exactly once, on the Tier-1 → Tier-2 transition, so the caller can
+     * swap the iframe to the bundled assets and emit the `backupTierChanged` event.
+     */
+    onFallback: (reason: BackupTierFallbackReason) => void;
+    /**
+     * Called if Tier 2 itself never becomes ready — the bundled assets are local so
+     * this should be unreachable, but it is the fail-closed safety net that surfaces
+     * an error instead of a blank screen (design §5A/§5H).
+     */
+    onTier2Unavailable: () => void;
+}
+export interface BackupTierController {
+    /** The tier to render right now. */
+    getTier: () => BackupTier;
+    /**
+     * Arm the Tier-1 ready-handshake timeout. Call once, right after the Tier-1
+     * iframe starts loading. No-op once ready or already cascaded.
+     */
+    start: () => void;
+    /** Call when the current surface completes its ready handshake (its `loaded`). */
+    markReady: () => void;
+    /**
+     * Call on a hard load error on the current surface. In Tier 1 (before ready)
+     * this cascades to Tier 2; in Tier 2 it fails closed. After Tier 1 is ready it
+     * is ignored (a mid-session blip must not discard the funnel).
+     */
+    reportLoadError: () => void;
+    /** Clear any pending timer (call on teardown). */
+    destroy: () => void;
+}
+/**
+ * Tier-1 → Tier-2 cascade state machine for the backup deposit flow (design §5H),
+ * as a framework-agnostic controller (the web SDK is imperative — no React). A
+ * direct port of the RN `useBackupTier` hook's semantics.
+ *
+ * The flow initializes in Tier 1 (widget loaded from the independent backup
+ * origin). If the origin is unreachable — a hard load error, or the widget never
+ * completes its ready handshake within {@link TIER1_READY_TIMEOUT_MS} — the SDK
+ * falls back to the bundled Tier-2 assets and re-delivers the same config. The
+ * cascade is **monotonic and single-shot**: Tier 1 is attempted once per session
+ * and, once in Tier 2, the flow stays there (no flap back). If Tier 2 itself
+ * never becomes ready, the caller fails closed rather than showing a blank QR.
+ */
+export declare function createBackupTierController(callbacks: BackupTierControllerCallbacks): BackupTierController;

package/utils/backupTier.js

@@ -0,0 +1,84 @@
+import { TIER1_READY_TIMEOUT_MS, TIER2_READY_TIMEOUT_MS } from './backup';
+/**
+ * Tier-1 → Tier-2 cascade state machine for the backup deposit flow (design §5H),
+ * as a framework-agnostic controller (the web SDK is imperative — no React). A
+ * direct port of the RN `useBackupTier` hook's semantics.
+ *
+ * The flow initializes in Tier 1 (widget loaded from the independent backup
+ * origin). If the origin is unreachable — a hard load error, or the widget never
+ * completes its ready handshake within {@link TIER1_READY_TIMEOUT_MS} — the SDK
+ * falls back to the bundled Tier-2 assets and re-delivers the same config. The
+ * cascade is **monotonic and single-shot**: Tier 1 is attempted once per session
+ * and, once in Tier 2, the flow stays there (no flap back). If Tier 2 itself
+ * never becomes ready, the caller fails closed rather than showing a blank QR.
+ */
+export function createBackupTierController(callbacks) {
+    var tier = 'tier1';
+    var ready = false;
+    // Single-shot latch: once we leave Tier 1 it can never be re-entered, and a
+    // second trigger of any kind is a no-op.
+    var cascaded = false;
+    // Fail-closed latch: Tier 2 can be reported unavailable by both a load error
+    // and the safety timeout, but the host must only be exited once.
+    var failedClosed = false;
+    var timer = null;
+    var clearTimer = function () {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    };
+    var failClosed = function () {
+        if (failedClosed)
+            return;
+        failedClosed = true;
+        clearTimer();
+        callbacks.onTier2Unavailable();
+    };
+    var cascadeToTier2 = function (reason) {
+        // Monotonic + single-shot: only ever from a not-yet-ready Tier 1.
+        if (cascaded || tier !== 'tier1' || ready)
+            return;
+        cascaded = true;
+        clearTimer();
+        tier = 'tier2';
+        ready = false;
+        callbacks.onFallback(reason);
+        // Fail-closed safety net: the bundled assets are local, so Tier 2 should
+        // become ready almost instantly; if it does not, surface an error.
+        timer = setTimeout(function () {
+            timer = null;
+            if (!ready)
+                failClosed();
+        }, TIER2_READY_TIMEOUT_MS);
+    };
+    return {
+        getTier: function () { return tier; },
+        start: function () {
+            if (ready || cascaded)
+                return;
+            clearTimer();
+            timer = setTimeout(function () {
+                timer = null;
+                cascadeToTier2('readyTimeout');
+            }, TIER1_READY_TIMEOUT_MS);
+        },
+        markReady: function () {
+            ready = true;
+            // Whichever tier just handshook is healthy — cancel its pending timer.
+            clearTimer();
+        },
+        reportLoadError: function () {
+            if (tier === 'tier1') {
+                // Immediate cascade — do not wait out the ready timeout (design §5H).
+                cascadeToTier2('loadError');
+            }
+            else if (!ready) {
+                // Tier 2 (local assets) failing to load is effectively impossible; if it
+                // happens, fail closed rather than reload into the same failure.
+                failClosed();
+            }
+        },
+        destroy: clearTimer
+    };
+}

package/utils/event-types.d.ts

@@ -1,6 +1,6 @@
 import { LinkPayload, TransferFinishedPayload } from './types';
-export type LinkEventType = IntegrationConnected | IntegrationConnectionError | TransferCompleted | IntegrationSelected | CredentialsEntered | TransferStarted | TransferPreviewed | TransferPreviewError | TransferExecutionError | TransferConfigureError | PageLoaded | IntegrationMfaRequired | IntegrationMfaEntered | IntegrationOAuthStarted | IntegrationAccountSelectionRequired | TransferAssetSelected | TransferNetworkSelected | TransferAmountEntered | TransferMfaRequired | TransferMfaEntered | TransferKycRequired | TransferInitiated | TransferExecuted | TransferNoEligibleAssets | WalletMessageSigned | DoneEvent | CloseEvent | VerifyWalletRejected | VerifyDonePage | SDKinjectedWalletProviders | LegalTermsViewed | SeeWhatHappenedClicked | FundingOptionsUpdated | FundingOptionsViewed | GasIncreaseWarning | ExecuteFundingStep | LinkTransferQrGenerated | HomePageMethodSelected | ConnectionUnavailable | ConnectionDeclined | TransferDeclined | DefiWalletError | HomePageLoaded;
-declare const LINK_EVENT_TYPE_KEYS: readonly ["integrationConnected", "integrationConnectionError", "integrationMfaRequired", "integrationMfaEntered", "integrationOAuthStarted", "integrationAccountSelectionRequired", "transferCompleted", "integrationSelected", "credentialsEntered", "transferStarted", "transferPreviewed", "transferPreviewError", "transferExecutionError", "transferConfigureError", "pageLoaded", "transferAssetSelected", "transferNetworkSelected", "transferAmountEntered", "transferMfaRequired", "transferMfaEntered", "transferKycRequired", "transferExecuted", "transferInitiated", "transferNoEligibleAssets", "walletMessageSigned", "verifyDonePage", "verifyWalletRejected", "connectionDeclined", "connectionUnavailable", "transferDeclined", "done", "close", "SDKinjectedWalletProviders", "legalTermsViewed", "seeWhatHappenedClicked", "executeFundingStep", "fundingOptionsUpdated", "fundingOptionsViewed", "gasIncreaseWarning", "linkTransferQRGenerated", "methodSelected", "defiWalletError", "homePageLoaded"];
+export type LinkEventType = IntegrationConnected | IntegrationConnectionError | TransferCompleted | IntegrationSelected | CredentialsEntered | TransferStarted | TransferPreviewed | TransferPreviewError | TransferExecutionError | TransferConfigureError | PageLoaded | IntegrationMfaRequired | IntegrationMfaEntered | IntegrationOAuthStarted | IntegrationAccountSelectionRequired | TransferAssetSelected | TransferNetworkSelected | TransferAmountEntered | TransferMfaRequired | TransferMfaEntered | TransferKycRequired | TransferInitiated | TransferExecuted | TransferNoEligibleAssets | WalletMessageSigned | DoneEvent | CloseEvent | VerifyWalletRejected | VerifyDonePage | SDKinjectedWalletProviders | LegalTermsViewed | SeeWhatHappenedClicked | FundingOptionsUpdated | FundingOptionsViewed | GasIncreaseWarning | ExecuteFundingStep | LinkTransferQrGenerated | HomePageMethodSelected | ConnectionUnavailable | ConnectionDeclined | TransferDeclined | DefiWalletError | HomePageLoaded | BackupTierChanged | WithdrawalRequested;
+declare const LINK_EVENT_TYPE_KEYS: readonly ["integrationConnected", "integrationConnectionError", "integrationMfaRequired", "integrationMfaEntered", "integrationOAuthStarted", "integrationAccountSelectionRequired", "transferCompleted", "integrationSelected", "credentialsEntered", "transferStarted", "transferPreviewed", "transferPreviewError", "transferExecutionError", "transferConfigureError", "pageLoaded", "transferAssetSelected", "transferNetworkSelected", "transferAmountEntered", "transferMfaRequired", "transferMfaEntered", "transferKycRequired", "transferExecuted", "transferInitiated", "transferNoEligibleAssets", "walletMessageSigned", "verifyDonePage", "verifyWalletRejected", "connectionDeclined", "connectionUnavailable", "transferDeclined", "done", "close", "SDKinjectedWalletProviders", "legalTermsViewed", "seeWhatHappenedClicked", "executeFundingStep", "fundingOptionsUpdated", "fundingOptionsViewed", "gasIncreaseWarning", "linkTransferQRGenerated", "methodSelected", "defiWalletError", "homePageLoaded", "backupTierChanged", "withdrawalRequested"];
 export type LinkEventTypeKeys = (typeof LINK_EVENT_TYPE_KEYS)[number];
 export declare function isLinkEventTypeKey(key: string): key is LinkEventTypeKeys;
 interface LinkEventBase {
@@ -318,4 +318,25 @@ export interface HomePageMethodSelected {
 export interface HomePageLoaded extends LinkEventBase {
     type: 'homePageLoaded';
 }
+/**
+ * Emitted once when the backup deposit flow cascades from Tier 1 (the widget
+ * loaded from the independent backup origin) to Tier 2 (the SDK-bundled offline
+ * widget), because the backup origin was unreachable (design §5H). Lets clients
+ * measure the real fallback rate.
+ */
+export interface BackupTierChanged extends LinkEventBase {
+    type: 'backupTierChanged';
+    payload: {
+        from: 'tier1';
+        to: 'tier2';
+        reason: 'loadError' | 'readyTimeout';
+    };
+}
+export interface WithdrawalRequested extends LinkEventBase {
+    type: 'withdrawalRequested';
+    payload: {
+        transferId: string;
+        status: string;
+    };
+}
 export {};

package/utils/event-types.js

@@ -41,7 +41,9 @@ var LINK_EVENT_TYPE_KEYS = [
     'linkTransferQRGenerated',
     'methodSelected',
     'defiWalletError',
-    'homePageLoaded'
+    'homePageLoaded',
+    'backupTierChanged',
+    'withdrawalRequested'
 ];
 export function isLinkEventTypeKey(key) {
     return LINK_EVENT_TYPE_KEYS.includes(key);

package/utils/types.d.ts

@@ -8,6 +8,17 @@ export interface Link {
      * @param customIframeId - Optional custom ID for the existing iframe element. If not provided, a new iframe element will be created
      */
     openLink: (linkToken: string, customIframeId?: string) => void;
+    /**
+     * Opens the standalone backup deposit widget for use when the primary Mesh API
+     * is unavailable. Unlike {@link openLink} there is no link token — the widget is
+     * a static SPA served from an independent origin, hydrated with `session` over
+     * the message bridge after it loads. The host event contract
+     * (`onIntegrationConnected` / `onTransferFinished` / `onEvent` / `onExit`) is
+     * unchanged, so the same handlers passed to `createLink` apply to both paths.
+     * @param session - Backup deposit configuration, assembled server-side (canonical shape: OR-446).
+     * @param options - Optional `widgetOrigin` (defaults to `DEFAULT_BACKUP_WIDGET_ORIGIN`) and `customIframeId` for embedded mode.
+     */
+    openLinkBackup: (session: MeshBackupConfig, options?: MeshBackupOptions) => void;
     /**
      * A function to close Link UI popup
      */
@@ -17,6 +28,112 @@ export interface Link {
      */
     closeLinkRequested: () => void;
 }
+/**
+ * A single deposit destination offered by the backup widget. When `address` is
+ * omitted it is resolved at runtime via the host's `onAddressInit` /
+ * `onStatusPoll` callbacks (see {@link LinkOptions}) — so those callbacks are
+ * required whenever any destination omits `address`.
+ */
+export interface MeshBackupDestination {
+    /** Mesh network id for this destination. */
+    networkId: string;
+    /** Token symbol (e.g. `USDC`). */
+    symbol: string;
+    /** Static deposit address. Omit to resolve just-in-time via the JIT callbacks. */
+    address?: string;
+    /** Destination tag / memo, for networks that require one (e.g. XRP). */
+    addressTag?: string;
+}
+/**
+ * Configuration handed to the backup deposit widget. Assemble this server-side
+ * (destinations should not be built in untrusted client code) and pass it to
+ * {@link Link.openLinkBackup}; it is delivered to the widget over the message
+ * bridge after the widget loads. Canonical shape: OR-446 (updated OR-452 — there
+ * is no `jit` block or token; JIT is resolved through host callbacks).
+ */
+export interface MeshBackupConfig {
+    /** The client's Mesh client id. */
+    clientId: string;
+    /**
+     * The client's end-user identifier. Used for analytics — it is **not** an
+     * authentication credential.
+     */
+    userId: string;
+    /** Deposit destinations to offer. At least one is required. */
+    destinations: MeshBackupDestination[];
+    /**
+     * Preselect a token symbol, skipping the token-select screen. Must match one
+     * of the destination symbols; an unknown symbol falls back to token select.
+     */
+    preselectedSymbol?: string;
+}
+/**
+ * The state an {@link LinkOptions.onStatusPoll} poll reports back. `pending`
+ * ⇒ the widget polls again; `ready` ⇒ the widget renders the deposit address
+ * (after its own echo + format fail-closed checks); `failed` ⇒ the widget
+ * surfaces an error.
+ */
+export type MeshBackupJitStatus = 'pending' | 'ready' | 'failed';
+/**
+ * What {@link LinkOptions.onStatusPoll} resolves to, as a discriminated union so
+ * a `ready` result cannot type-check without an `address`. On `ready`, `address`
+ * must be a valid deposit address for the requested network and `addressTag` is
+ * required for memo-chain networks (XRP, XLM, …), omitted otherwise. For a given
+ * `(symbol, networkId)` the resolved address/tag MUST be idempotent — always
+ * return the same one.
+ */
+export type MeshBackupStatusResult = {
+    status: 'pending';
+} | {
+    status: 'failed';
+} | {
+    status: 'ready';
+    address: string;
+    addressTag?: string;
+};
+/** The two JIT calls the widget can make over the bridge (client spec §5/§6). */
+export type MeshBackupJitMethod = 'addressInit' | 'statusPoll';
+/**
+ * Widget → host JIT RPC request payload (OR-452). Correlated to the host's async
+ * response by `callId`. Mirrors `mesh-backup-widget`'s `BackupJitRequestPayload`.
+ */
+export interface MeshBackupJitRequestPayload {
+    callId: string;
+    method: MeshBackupJitMethod;
+    symbol: string;
+    networkId: string;
+}
+/**
+ * Host → widget JIT RPC response payload (OR-452). `ok: true` with a `result`
+ * (for `statusPoll`) means the host callback resolved; `ok: false` with an
+ * `error` means it threw/rejected (or the callback was not provided). Mirrors
+ * `mesh-backup-widget`'s `BackupJitResponsePayload`.
+ */
+export interface MeshBackupJitResponsePayload {
+    callId: string;
+    ok: boolean;
+    result?: MeshBackupStatusResult;
+    error?: string;
+}
+/**
+ * Optional arguments to {@link Link.openLinkBackup}.
+ */
+export interface MeshBackupOptions {
+    /**
+     * Origin serving the standalone backup widget. Defaults to
+     * `DEFAULT_BACKUP_WIDGET_ORIGIN`. Override for staging, demo, or self-hosting.
+     * The widget served there must echo the per-open session nonce (`sid`) on its
+     * messages (mesh-backup-widget with the session-nonce bridge); an older build's
+     * messages are ignored and the flow falls back to the bundled Tier-2 widget.
+     */
+    widgetOrigin?: string;
+    /**
+     * Custom ID for an existing iframe element, mirroring {@link Link.openLink}'s
+     * embedded-mode param. Required when `createLink` was called with
+     * `renderType: 'embedded'`.
+     */
+    customIframeId?: string;
+}
 export interface AccountToken {
     account: Account;
     accessToken: string;
@@ -108,10 +225,10 @@ export interface LinkOptions {
      */
     clientId?: string;
     /**
-     * A callback function that is called when an integration is successfully connected.
+     * (Optional) A callback function that is called when an integration is successfully connected.
      * It receives a payload of type `LinkPayload`.
      */
-    onIntegrationConnected: (payload: LinkPayload) => void;
+    onIntegrationConnected?: (payload: LinkPayload) => void;
     /**
      * (Optional) A callback function that is called when the Front iframe is closed.
      */
@@ -150,6 +267,24 @@ export interface LinkOptions {
      * - 'embedded': renders inside a client-supplied iframe for a more native UI experience. Requires `customIframeId` in `openLink`.
      */
     renderType?: 'overlay' | 'embedded';
+    /**
+     * (Backup flow only) Called once when the user confirms a token/network for a
+     * destination that omits `address`, to kick off just-in-time address
+     * generation against your own backend (with your own session). The return
+     * value is ignored — the widget moves straight to polling {@link onStatusPoll}
+     * — but a thrown error / rejected promise is treated as a generation failure.
+     * Required whenever any backup destination omits `address`.
+     */
+    onAddressInit?: (symbol: string, networkId: string) => void | Promise<unknown>;
+    /**
+     * (Backup flow only) Polled (~every 2–3s) after {@link onAddressInit} until it
+     * resolves `ready` or `failed`. Resolve to `{ status: 'ready', address, addressTag? }`
+     * once the address is available; `{ status: 'pending' }` to be polled again; or
+     * `{ status: 'failed' }` to abort. For a given `(symbol, networkId)` the
+     * resolved address MUST be idempotent. Required whenever any backup destination
+     * omits `address`.
+     */
+    onStatusPoll?: (symbol: string, networkId: string) => Promise<MeshBackupStatusResult>;
 }
 export interface LinkStyle {
     ir: number;

package/utils/version.d.ts

@@ -1 +1 @@
-export declare const sdkVersion = "3.13.0";
+export declare const sdkVersion = "3.14.1";

package/utils/version.js

@@ -1 +1 @@
-export var sdkVersion = '3.13.0';
+export var sdkVersion = '3.14.1';