@toon-protocol/client 0.9.2 → 0.10.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as _toon_protocol_core from '@toon-protocol/core';
 import { IlpPeerInfo, NetworkFamilyStatus, IlpSendResult, IlpClient, ConnectorAdminClient, ConnectorChannelClient, OpenChannelParams, OpenChannelResult, ChannelState } from '@toon-protocol/core';
-import { NostrEvent } from 'nostr-tools/pure';
+import { NostrEvent, EventTemplate } from 'nostr-tools/pure';
 import { PrivateKeyAccount } from 'viem/accounts';
 
 /**
@@ -199,6 +199,27 @@ interface ToonClientConfig {
     btpAuthToken?: string;
     /** Peer ID for BTP connection (used in connector env var BTP_PEER_{ID}_SECRET) */
     btpPeerId?: string;
+    /**
+     * ILP-over-HTTP one-shot endpoint of the uplink connector (the `POST /ilp`
+     * URL, e.g. "http://localhost:3000/ilp"). When set, the client prefers the
+     * stateless {@link HttpIlpClient} transport for one-shot writes instead of
+     * opening a persistent BTP WebSocket.
+     *
+     * This mirrors the `httpEndpoint` field a peer advertises in discovery
+     * (`IlpPeerInfo`, toon PR #29). It is surfaced here as explicit config so the
+     * default runtime can opt into ILP-over-HTTP before connectors advertise the
+     * field on-wire. Leave unset to keep the existing BTP-only behavior (the safe
+     * default — no connector advertises an httpEndpoint until the connector + a
+     * core release with these fields ship).
+     */
+    connectorHttpEndpoint?: string;
+    /**
+     * Whether the uplink connector accepts a BTP `Upgrade` over its HTTP endpoint
+     * (mirrors `IlpPeerInfo.supportsUpgrade`, toon PR #29). Only consulted when
+     * `connectorHttpEndpoint` is set and a duplex session is required. Defaults to
+     * false (no upgrade) when omitted.
+     */
+    connectorSupportsUpgrade?: boolean;
     /**
      * ILP destination address for event publishing.
      * Defaults to the connector's local address (derived from connectorUrl host).
@@ -391,6 +412,103 @@ type ClientTransportConfig = {
     gatewayUrl: string;
 };
 
+/**
+ * Client-side helper for kind:5094 Arweave blob storage DVM requests.
+ *
+ * This composes the three steps a caller previously had to wire by hand:
+ *   1. Build the kind:5094 event via `buildBlobStorageRequest()` (@toon-protocol/core).
+ *   2. Publish it to the DVM destination over ILP via `ToonClient.publishEvent()`
+ *      (reusing the existing claim / channel plumbing).
+ *   3. Decode the FULFILL `data` field into the Arweave transaction ID.
+ *
+ * ## FULFILL data contract
+ *
+ * For a successful single-packet (non-chunked) blob upload, the DVM provider
+ * returns the Arweave transaction ID as a **UTF-8 string, base64-encoded** in
+ * the ILP FULFILL `data` field (the connector validates that FULFILL data is
+ * base64). An Arweave tx ID is a 43-character base64url string (32 raw bytes).
+ *
+ * So the decode is:
+ *   `txId = utf8(base64decode(result.data))`
+ *
+ * See `packages/sdk/src/arweave/arweave-dvm-handler.ts` for the server side and
+ * `packages/client/tests/e2e/docker-arweave-dvm-e2e.test.ts` for the reference
+ * end-to-end flow this helper mirrors.
+ *
+ * Chunked uploads (multi-packet, via `uploadId` / `chunkIndex` / `totalChunks`
+ * params) are intentionally out of scope for this single-packet helper — the
+ * provider returns `ack:<n>` for intermediate chunks and the tx ID only on the
+ * final chunk. Callers needing chunking should drive `publishEvent()` directly
+ * (see the chunked case in the reference E2E test). Tracked as a follow-up.
+ */
+
+/**
+ * Parameters for {@link requestBlobStorage}.
+ */
+interface RequestBlobStorageParams {
+    /** The raw blob data to store on Arweave. */
+    blobData: Uint8Array;
+    /**
+     * MIME type of the blob. Defaults to `'application/octet-stream'`
+     * (matching `buildBlobStorageRequest`).
+     */
+    contentType?: string;
+    /**
+     * Bid amount in USDC micro-units, as a string (declared in the event's
+     * `bid` tag). Defaults to the stringified `ilpAmount` when omitted.
+     *
+     * At least one of `bid` / `ilpAmount` should be provided so the declared
+     * bid and the paid ILP amount agree.
+     */
+    bid?: string;
+    /**
+     * ILP destination address of the DVM that performs the upload
+     * (e.g. `'g.toon.peer1'`). Falls back to the client's configured
+     * `destinationAddress` when omitted.
+     */
+    destination?: string;
+    /**
+     * Pre-signed balance proof claim for this packet. When omitted, the
+     * client's channel manager auto-opens a channel and auto-signs a claim
+     * (same lazy-channel behavior as `publishEvent`).
+     */
+    claim?: SignedBalanceProof;
+    /**
+     * Explicit ILP payment amount (bigint micro-units). When omitted,
+     * `publishEvent` computes it from the encoded event size. When `bid`
+     * is omitted, this value is stringified to populate the event's bid tag.
+     */
+    ilpAmount?: bigint;
+}
+/**
+ * Typed result of {@link requestBlobStorage}.
+ */
+interface RequestBlobStorageResult {
+    /** Whether the upload succeeded and a tx ID was decoded. */
+    success: boolean;
+    /** The Arweave transaction ID (43-char base64url) when `success` is true. */
+    txId?: string;
+    /** The id of the kind:5094 event that was published. */
+    eventId?: string;
+    /** Error message when `success` is false. */
+    error?: string;
+}
+/**
+ * Requests permanent Arweave blob storage from a DVM in a single ILP packet.
+ *
+ * Mirrors the single-packet flow in
+ * `packages/client/tests/e2e/docker-arweave-dvm-e2e.test.ts`: builds a signed
+ * kind:5094 event, publishes it through the supplied {@link ToonClient}
+ * (reusing its claim/channel plumbing), and decodes the FULFILL `data` field
+ * into an Arweave transaction ID.
+ *
+ * @param client - A started `ToonClient` (call `client.start()` first).
+ * @param secretKey - The Nostr secret key used to sign the kind:5094 event.
+ * @param params - Blob, content type, bid, destination, and payment options.
+ * @returns `{ success, txId?, eventId?, error? }`.
+ */
+declare function requestBlobStorage(client: ToonClient, secretKey: Uint8Array, params: RequestBlobStorageParams): Promise<RequestBlobStorageResult>;
+
 /**
  * ToonClient - High-level client for interacting with TOON network.
  *
@@ -469,6 +587,30 @@ declare class ToonClient {
      * Works before start() is called.
      */
     getPublicKey(): string;
+    /**
+     * Sign an unsigned Nostr event template with the client's Nostr secret key,
+     * returning a fully-signed event (id + pubkey + sig).
+     *
+     * This is the key primitive behind the daemon's sign-and-publish path: a UI
+     * or agent supplies only `{ kind, content, tags, created_at }` and never holds
+     * the private key — signing happens here, inside the key owner.
+     */
+    signEvent(template: EventTemplate): NostrEvent;
+    /**
+     * Upload bytes to Arweave via the kind:5094 blob-storage DVM (single-packet),
+     * signing the request with this client's Nostr key and paying through its
+     * existing channel. Returns the Arweave tx id on success.
+     *
+     * Backs the daemon's `upload-media` path: the key and claim/channel plumbing
+     * stay inside the client; callers pass only the bytes.
+     */
+    uploadBlob(params: {
+        blobData: Uint8Array;
+        contentType?: string;
+        bid?: string;
+        destination?: string;
+        ilpAmount?: bigint;
+    }): Promise<RequestBlobStorageResult>;
     /**
      * Per-chain settlement readiness for the configured `network` tier, mirroring
      * the townhouse node's status. Returns `undefined` when no named `network` is
@@ -1112,6 +1254,216 @@ declare class BtpRuntimeClient implements IlpClient {
     private _sendIlpPacketWithClaimOnce;
 }
 
+/**
+ * ILP-over-HTTP (RFC-0035) transport for the TOON client.
+ *
+ * The connector now serves ILP-over-HTTP on the SAME port as BTP (connector
+ * PR #181). This adapter lets a client do stateless one-shot writes over HTTP
+ * (`POST /ilp`) and upgrade to a duplex BTP session when it needs to receive
+ * server-initiated packets or act as a peer.
+ *
+ * Wire contract (targets connector PR #181's `/ilp`):
+ *  - One-shot write: `POST /ilp`
+ *      body:    OER-encoded ILP PREPARE (`application/octet-stream`)
+ *      header:  `ILP-Payment-Channel-Claim: base64(JSON of the claim)` — the
+ *               SAME claim JSON the BTP path attaches as the
+ *               `payment-channel-claim` protocolData entry.
+ *      optional: `ILP-Peer-Id` + `Authorization: Bearer <secret>` identity.
+ *      response: `200 OK` with an OER FULFILL or REJECT body. HTTP non-2xx is
+ *                reserved for TRANSPORT errors (400/401/413/5xx); ILP-level
+ *                rejects come back as a 200 + REJECT body.
+ *  - Upgrade to BTP: standard HTTP `Upgrade` with `Sec-WebSocket-Protocol: btp`
+ *      plus the same `ILP-Peer-Id` + `Authorization` headers. The connector
+ *      pre-authenticates the BTP session from those headers (continuity), so
+ *      after `101` we send BTP frames WITHOUT a separate in-band auth frame.
+ *      Omitting the auth headers falls back to the normal BTP auth-frame flow.
+ *
+ * Reuses `serializeIlpPrepare`/`deserializeIlpPacket` from `btp/protocol.ts` —
+ * the SAME OER codec the BTP path uses. Claim signing/construction is owned by
+ * the caller (BootstrapService); this transport never builds or signs claims.
+ */
+
+/** Header carrying the base64(JSON) payment-channel claim. */
+declare const ILP_CLAIM_HEADER = "ILP-Payment-Channel-Claim";
+/** Header carrying a NIP-59 wrapped (gift-wrapped) claim. */
+declare const ILP_CLAIM_WRAPPED_HEADER = "ILP-Payment-Channel-Claim-Wrapped";
+/** Header carrying the peer identity. */
+declare const ILP_PEER_ID_HEADER = "ILP-Peer-Id";
+interface HttpIlpClientConfig {
+    /** The peer's `POST /ilp` URL (the `httpEndpoint` from discovery). */
+    httpEndpoint: string;
+    /**
+     * Optional peer identity. With no `peerId`/`authToken` the connector treats
+     * the request as an anonymous no-auth peer (permissionless default) and
+     * derives an ephemeral id from the claim signer.
+     */
+    peerId?: string;
+    /** Bearer secret for `Authorization`. Omit for the no-auth peer path. */
+    authToken?: string;
+    /** Request timeout in milliseconds (default: 30000). */
+    timeout?: number;
+    /** Max retry attempts for transport-level network failures (default: 3). */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds (default: 1000). */
+    retryDelay?: number;
+    /** Custom fetch implementation (SOCKS5 mode / testing). */
+    httpClient?: typeof fetch;
+    /**
+     * Custom WebSocket constructor for the BTP upgrade path (SOCKS5 mode).
+     * Forwarded to the underlying BtpRuntimeClient.
+     */
+    createWebSocket?: (url: string) => WebSocket;
+}
+/**
+ * Stateless ILP-over-HTTP transport implementing `IlpClient`.
+ *
+ * Use this for pure one-shot consumers (publish-and-forget writes). When the
+ * client needs a duplex session — to receive server-initiated packets or to act
+ * as a peer — call {@link upgradeToBtp} to obtain a connected BtpRuntimeClient
+ * that reuses the existing BTP code path.
+ */
+declare class HttpIlpClient implements IlpClient {
+    private readonly httpEndpoint;
+    private readonly peerId;
+    private readonly authToken;
+    private readonly timeout;
+    private readonly retryConfig;
+    private readonly httpClient;
+    private readonly createWebSocket;
+    constructor(config: HttpIlpClientConfig);
+    /**
+     * Send an ILP PREPARE via `POST /ilp` WITHOUT a claim. The connector accepts
+     * this only on free/zero-amount routes; paid writes must use
+     * {@link sendIlpPacketWithClaim}. Satisfies the IlpClient interface.
+     */
+    sendIlpPacket(params: {
+        destination: string;
+        amount: string;
+        data: string;
+        timeout?: number;
+    }): Promise<IlpSendResult>;
+    /**
+     * Send an ILP PREPARE via `POST /ilp` with the payment-channel claim attached
+     * as the `ILP-Payment-Channel-Claim` header. `claim` is the SAME JSON object
+     * the BTP path attaches as the `payment-channel-claim` protocolData entry —
+     * we base64(JSON.stringify(claim)) it, byte-for-byte identical to BTP.
+     */
+    sendIlpPacketWithClaim(params: {
+        destination: string;
+        amount: string;
+        data: string;
+        timeout?: number;
+    }, claim: unknown): Promise<IlpSendResult>;
+    /**
+     * Upgrade to a duplex BTP session over the SAME endpoint.
+     *
+     * Derives the `ws(s)://` URL from `httpEndpoint`, opens a WebSocket with
+     * `Sec-WebSocket-Protocol: btp` and the same `ILP-Peer-Id` + `Authorization`
+     * headers, and returns a connected {@link BtpRuntimeClient}. When auth headers
+     * are present the connector pre-authenticates the session (no in-band auth
+     * frame); without them the BtpRuntimeClient falls back to the normal BTP
+     * auth-frame flow.
+     *
+     * NOTE: passing per-connection headers + a subprotocol to a WebSocket is
+     * Node-only (the `ws` package). Browsers cannot set arbitrary request headers
+     * on a WebSocket handshake, so a browser consumer must use the gateway
+     * transport or BTP-with-auth-frame instead.
+     */
+    upgradeToBtp(): Promise<BtpRuntimeClient>;
+    private authHeaders;
+    /**
+     * Single attempt: serialize the PREPARE, POST it, and map the response.
+     * @throws {NetworkError} On connection/timeout failures (retried).
+     * @throws {ConnectorError} On non-retryable transport errors (5xx / unexpected).
+     */
+    private postPrepare;
+    /**
+     * Map a `200 OK` body (OER FULFILL/REJECT) to an IlpSendResult; map a non-2xx
+     * to a transport error. Per the wire contract, ILP-level rejects arrive as a
+     * 200 + REJECT body — only HTTP non-2xx means a transport-layer failure.
+     */
+    private mapResponse;
+    private mapTransportError;
+}
+/**
+ * Derive the BTP WebSocket URL from a `POST /ilp` HTTP endpoint. The connector
+ * serves BTP on the SAME path, so we only swap the scheme (http→ws, https→wss).
+ */
+declare function httpEndpointToBtpUrl(httpEndpoint: string): string;
+
+/**
+ * Transport selection policy for the client ILP layer.
+ *
+ * The connector serves ILP-over-HTTP (`POST /ilp`) and BTP on the SAME port
+ * (connector PR #181). A peer advertises this in discovery via the toon-core
+ * `IlpPeerInfo` fields added in toon PR #29:
+ *   - `httpEndpoint?: string`   — the `POST /ilp` URL.
+ *   - `supportsUpgrade?: boolean` — whether the host accepts the BTP upgrade.
+ *
+ * Those fields may not yet exist on the installed `@toon-protocol/core`
+ * `IlpPeerInfo` type, so we read them defensively here (see `DiscoveredIlpPeer`).
+ *
+ * Policy:
+ *   - Pure one-shot consumers (`needsDuplex: false`) prefer HTTP when the peer
+ *     advertises an `httpEndpoint` — stateless, no persistent socket.
+ *   - Clients that must receive server-initiated packets or act as a peer
+ *     (`needsDuplex: true`) use BTP. If the peer only exposes `httpEndpoint`
+ *     and `supportsUpgrade` is true, we go HTTP-then-upgrade; otherwise we
+ *     connect to the BTP endpoint directly.
+ */
+/**
+ * The subset of discovery fields this policy reads. Structurally compatible with
+ * core's `IlpPeerInfo`; `httpEndpoint`/`supportsUpgrade` are optional so a
+ * pre-PR-#29 `IlpPeerInfo` can be passed through a cast.
+ */
+interface DiscoveredIlpPeer {
+    /** BTP WebSocket endpoint (always present on a TOON peer). */
+    btpEndpoint?: string;
+    /** `POST /ilp` URL (toon PR #29). */
+    httpEndpoint?: string;
+    /** Whether the host accepts the BTP upgrade over the HTTP endpoint (toon PR #29). */
+    supportsUpgrade?: boolean;
+}
+type IlpTransportChoice = 
+/** Stateless one-shot writes via `POST /ilp`. */
+{
+    kind: 'http';
+    httpEndpoint: string;
+    canUpgrade: boolean;
+}
+/** Duplex BTP session via the WebSocket endpoint. */
+ | {
+    kind: 'btp';
+    btpEndpoint: string;
+}
+/**
+ * Open HTTP first (one-shot writes) but upgrade to BTP when duplex is needed.
+ * Only chosen when the peer exposes `httpEndpoint` + `supportsUpgrade` and no
+ * separate `btpEndpoint`.
+ */
+ | {
+    kind: 'http-upgradable';
+    httpEndpoint: string;
+};
+interface SelectIlpTransportOptions {
+    /**
+     * Whether the client needs a duplex session (receive server-initiated
+     * packets / act as a peer). Default: false (pure one-shot consumer).
+     */
+    needsDuplex?: boolean;
+}
+/**
+ * Read discovery fields defensively from a (possibly pre-PR-#29) peer info
+ * object. Accepts core's `IlpPeerInfo` or any structurally-compatible shape.
+ */
+declare function readDiscoveredIlpPeer(peer: unknown): DiscoveredIlpPeer;
+/**
+ * Choose the ILP transport for a discovered peer given the consumer's needs.
+ *
+ * @throws {Error} If the peer advertises no usable endpoint at all.
+ */
+declare function selectIlpTransport(peer: DiscoveredIlpPeer, options?: SelectIlpTransportOptions): IlpTransportChoice;
+
 /**
  * Chain-specific metadata (discriminated union).
  */
@@ -1918,7 +2270,7 @@ declare function validateConfig(config: ToonClientConfig): void;
  * The resolved config type after defaults are applied.
  * secretKey is guaranteed to be present (auto-generated if omitted).
  */
-type ResolvedConfig = Required<Omit<ToonClientConfig, 'connector' | 'mnemonic' | 'mnemonicAccountIndex' | 'evmPrivateKey' | 'network' | 'supportedChains' | 'settlementAddresses' | 'preferredTokens' | 'tokenNetworks' | 'btpUrl' | 'btpAuthToken' | 'btpPeerId' | 'chainRpcUrls' | 'initialDeposit' | 'settlementTimeout' | 'solanaChannel' | 'minaChannel' | 'channelStorePath' | 'knownPeers' | 'destinationAddress' | 'transport' | 'managedAnonProxy' | 'managedAnonSocksPort'>> & {
+type ResolvedConfig = Required<Omit<ToonClientConfig, 'connector' | 'mnemonic' | 'mnemonicAccountIndex' | 'evmPrivateKey' | 'network' | 'supportedChains' | 'settlementAddresses' | 'preferredTokens' | 'tokenNetworks' | 'btpUrl' | 'btpAuthToken' | 'btpPeerId' | 'connectorHttpEndpoint' | 'connectorSupportsUpgrade' | 'chainRpcUrls' | 'initialDeposit' | 'settlementTimeout' | 'solanaChannel' | 'minaChannel' | 'channelStorePath' | 'knownPeers' | 'destinationAddress' | 'transport' | 'managedAnonProxy' | 'managedAnonSocksPort'>> & {
     connector?: unknown;
     /** Always present after applyDefaults() — derived from secretKey if not explicitly provided */
     evmPrivateKey: string | Uint8Array;
@@ -1949,6 +2301,8 @@ type ResolvedConfig = Required<Omit<ToonClientConfig, 'connector' | 'mnemonic' |
     btpUrl?: string;
     btpAuthToken?: string;
     btpPeerId?: string;
+    connectorHttpEndpoint?: string;
+    connectorSupportsUpgrade?: boolean;
     chainRpcUrls?: Record<string, string>;
     initialDeposit?: string;
     settlementTimeout?: number;
@@ -2374,103 +2728,6 @@ declare function filterPetListings(events: NostrEventLike[], options?: PetListin
  */
 declare function buildPetPurchaseRequest(params: PetPurchaseRequestParams): UnsignedNostrEvent;
 
-/**
- * Client-side helper for kind:5094 Arweave blob storage DVM requests.
- *
- * This composes the three steps a caller previously had to wire by hand:
- *   1. Build the kind:5094 event via `buildBlobStorageRequest()` (@toon-protocol/core).
- *   2. Publish it to the DVM destination over ILP via `ToonClient.publishEvent()`
- *      (reusing the existing claim / channel plumbing).
- *   3. Decode the FULFILL `data` field into the Arweave transaction ID.
- *
- * ## FULFILL data contract
- *
- * For a successful single-packet (non-chunked) blob upload, the DVM provider
- * returns the Arweave transaction ID as a **UTF-8 string, base64-encoded** in
- * the ILP FULFILL `data` field (the connector validates that FULFILL data is
- * base64). An Arweave tx ID is a 43-character base64url string (32 raw bytes).
- *
- * So the decode is:
- *   `txId = utf8(base64decode(result.data))`
- *
- * See `packages/sdk/src/arweave/arweave-dvm-handler.ts` for the server side and
- * `packages/client/tests/e2e/docker-arweave-dvm-e2e.test.ts` for the reference
- * end-to-end flow this helper mirrors.
- *
- * Chunked uploads (multi-packet, via `uploadId` / `chunkIndex` / `totalChunks`
- * params) are intentionally out of scope for this single-packet helper — the
- * provider returns `ack:<n>` for intermediate chunks and the tx ID only on the
- * final chunk. Callers needing chunking should drive `publishEvent()` directly
- * (see the chunked case in the reference E2E test). Tracked as a follow-up.
- */
-
-/**
- * Parameters for {@link requestBlobStorage}.
- */
-interface RequestBlobStorageParams {
-    /** The raw blob data to store on Arweave. */
-    blobData: Uint8Array;
-    /**
-     * MIME type of the blob. Defaults to `'application/octet-stream'`
-     * (matching `buildBlobStorageRequest`).
-     */
-    contentType?: string;
-    /**
-     * Bid amount in USDC micro-units, as a string (declared in the event's
-     * `bid` tag). Defaults to the stringified `ilpAmount` when omitted.
-     *
-     * At least one of `bid` / `ilpAmount` should be provided so the declared
-     * bid and the paid ILP amount agree.
-     */
-    bid?: string;
-    /**
-     * ILP destination address of the DVM that performs the upload
-     * (e.g. `'g.toon.peer1'`). Falls back to the client's configured
-     * `destinationAddress` when omitted.
-     */
-    destination?: string;
-    /**
-     * Pre-signed balance proof claim for this packet. When omitted, the
-     * client's channel manager auto-opens a channel and auto-signs a claim
-     * (same lazy-channel behavior as `publishEvent`).
-     */
-    claim?: SignedBalanceProof;
-    /**
-     * Explicit ILP payment amount (bigint micro-units). When omitted,
-     * `publishEvent` computes it from the encoded event size. When `bid`
-     * is omitted, this value is stringified to populate the event's bid tag.
-     */
-    ilpAmount?: bigint;
-}
-/**
- * Typed result of {@link requestBlobStorage}.
- */
-interface RequestBlobStorageResult {
-    /** Whether the upload succeeded and a tx ID was decoded. */
-    success: boolean;
-    /** The Arweave transaction ID (43-char base64url) when `success` is true. */
-    txId?: string;
-    /** The id of the kind:5094 event that was published. */
-    eventId?: string;
-    /** Error message when `success` is false. */
-    error?: string;
-}
-/**
- * Requests permanent Arweave blob storage from a DVM in a single ILP packet.
- *
- * Mirrors the single-packet flow in
- * `packages/client/tests/e2e/docker-arweave-dvm-e2e.test.ts`: builds a signed
- * kind:5094 event, publishes it through the supplied {@link ToonClient}
- * (reusing its claim/channel plumbing), and decodes the FULFILL `data` field
- * into an Arweave transaction ID.
- *
- * @param client - A started `ToonClient` (call `client.start()` first).
- * @param secretKey - The Nostr secret key used to sign the kind:5094 event.
- * @param params - Blob, content type, bid, destination, and payment options.
- * @returns `{ success, txId?, eventId?, error? }`.
- */
-declare function requestBlobStorage(client: ToonClient, secretKey: Uint8Array, params: RequestBlobStorageParams): Promise<RequestBlobStorageResult>;
-
 /**
  * Full multi-chain identity derived from a single BIP-39 mnemonic.
  */
@@ -2820,4 +3077,4 @@ declare function loadKeystore(path: string, password: string): string;
  */
 declare function writeKeystoreFile(path: string, keystore: EncryptedKeystore): void;
 
-export { ANON_ASSETS, ANON_VERSION, type AnonAsset, type BackupPayload, type BalanceProofParams, BtpRuntimeClient, type BtpRuntimeClientConfig, type ChainMetadata, type ChainSigner, ChannelManager, type ClaimMessage, type ClientTransportConfig, ConnectorError, type EVMClaimMessage, type EncryptedKeystore, EvmSigner, HS_HOSTNAME_MAX_LENGTH, HS_HOSTNAME_REGEX, HttpConnectorAdmin, type HttpConnectorAdminConfig, HttpRuntimeClient, type HttpRuntimeClientConfig, type InteractionResultContent, KeyManager, type KeyManagerConfig, type ManagedAnonProxy, type MinaClaimMessage, type MinaDepositReader, MinaSigner, type MinaSignerOptions, NetworkError, OnChainChannelClient, type OnChainChannelClientConfig, type PasskeyInfo, type PetDvmProvider, type PetInteractionEventData, type PetInteractionRequestParams, type PetInteractionResultData, type PetListing, type PetListingFilterOptions, type PetListingParams, type PetPurchaseRequestParams, type ProofStatus, type PublishEventResult, type RequestBlobStorageParams, type RequestBlobStorageResult, type RetryOptions, type SignedBalanceProof, type SolanaChannelClientOptions, type SolanaClaimMessage, SolanaSigner, type StartManagedAnonProxyOptions, type StatValues, ToonClient, type ToonClientConfig, ToonClientError, type ToonIdentity, type ToonSigners, type ToonStartResult, type UnsignedNostrEvent, ValidationError, type VaultData, applyDefaults, applyNetworkPresets, assertRoutableHsHostname, buildBackupEvent, buildBackupFilter, buildPetInteractionRequest, buildPetListingEvent, buildPetPurchaseRequest, buildSettlementInfo, decryptMnemonic, deriveFromNsec, deriveFullIdentity, deriveNostrKeyFromMnemonic, encryptMnemonic, filterPetDvmProviders, filterPetListings, generateKeystore, generateMnemonic, generateRandomIdentity, getNetworkStatus, importKeystore, isPrfSupported, isRoutableHsHostname, loadKeystore, parseBackupPayload, parsePetInteractionEvent, parsePetInteractionResult, parsePetListing, readMinaDepositTotal, requestBlobStorage, selectAnonAsset, startManagedAnonProxy, validateConfig, validateMnemonic, withRetry, writeKeystoreFile };
+export { ANON_ASSETS, ANON_VERSION, type AnonAsset, type BackupPayload, type BalanceProofParams, BtpRuntimeClient, type BtpRuntimeClientConfig, type ChainMetadata, type ChainSigner, ChannelManager, type ClaimMessage, type ClientTransportConfig, ConnectorError, type DiscoveredIlpPeer, type EVMClaimMessage, type EncryptedKeystore, EvmSigner, HS_HOSTNAME_MAX_LENGTH, HS_HOSTNAME_REGEX, HttpConnectorAdmin, type HttpConnectorAdminConfig, HttpIlpClient, type HttpIlpClientConfig, HttpRuntimeClient, type HttpRuntimeClientConfig, ILP_CLAIM_HEADER, ILP_CLAIM_WRAPPED_HEADER, ILP_PEER_ID_HEADER, type IlpTransportChoice, type InteractionResultContent, KeyManager, type KeyManagerConfig, type ManagedAnonProxy, type MinaClaimMessage, type MinaDepositReader, MinaSigner, type MinaSignerOptions, NetworkError, OnChainChannelClient, type OnChainChannelClientConfig, type PasskeyInfo, type PetDvmProvider, type PetInteractionEventData, type PetInteractionRequestParams, type PetInteractionResultData, type PetListing, type PetListingFilterOptions, type PetListingParams, type PetPurchaseRequestParams, type ProofStatus, type PublishEventResult, type RequestBlobStorageParams, type RequestBlobStorageResult, type RetryOptions, type SelectIlpTransportOptions, type SignedBalanceProof, type SolanaChannelClientOptions, type SolanaClaimMessage, SolanaSigner, type StartManagedAnonProxyOptions, type StatValues, ToonClient, type ToonClientConfig, ToonClientError, type ToonIdentity, type ToonSigners, type ToonStartResult, type UnsignedNostrEvent, ValidationError, type VaultData, applyDefaults, applyNetworkPresets, assertRoutableHsHostname, buildBackupEvent, buildBackupFilter, buildPetInteractionRequest, buildPetListingEvent, buildPetPurchaseRequest, buildSettlementInfo, decryptMnemonic, deriveFromNsec, deriveFullIdentity, deriveNostrKeyFromMnemonic, encryptMnemonic, filterPetDvmProviders, filterPetListings, generateKeystore, generateMnemonic, generateRandomIdentity, getNetworkStatus, httpEndpointToBtpUrl, importKeystore, isPrfSupported, isRoutableHsHostname, loadKeystore, parseBackupPayload, parsePetInteractionEvent, parsePetInteractionResult, parsePetListing, readDiscoveredIlpPeer, readMinaDepositTotal, requestBlobStorage, selectAnonAsset, selectIlpTransport, startManagedAnonProxy, validateConfig, validateMnemonic, withRetry, writeKeystoreFile };