@talismn/chain-connectors 1.0.6 → 1.1.1

package/README.md

@@ -7,3 +7,13 @@ RPC connections to the networks that the Talisman wallet supports, one connector
 - `ChainConnectorSol`: Solana networks, `@solana/kit` RPC and transport per network (`getRpc`, `getTransport`, cached). The transport fails over through the network's RPCs in order and sends the next request to the RPC that answered last.
 
 The `*Stub` variants connect to a single network from its RPC list, without chaindata.
+
+`ChainConnectorDotPapi` runs over a dapp's polkadot-api clients instead of opening sockets of its own. A dapp that uses `@talismn/balances` next to polkadot-api then has one socket per chain:
+
+```ts
+const chainConnector = new ChainConnectorDotPapi((networkId) => clients[networkId])
+```
+
+It supports the requests and the `state_subscribeStorage` subscription that balances uses. A storage subscription queries all its keys at each new best block and reports the values that changed, so each balances subscription costs one `state_queryStorageAt` per block.
+
+Pass a client for every Polkadot SDK network that balances is enabled on, connected to full nodes over a websocket: balances uses the legacy JSON-RPC methods (`state_queryStorageAt`, `state_call`, `state_getKeysPaged`, …), which light clients do not serve. Keep each client alive as long as the connector, and change its RPCs with the provider's `switch()` rather than by recreating it: a subscription stays on the client it started with, and a destroyed client gives no signal, so its subscriptions stop updating.

package/dist/index.d.mts

@@ -18,11 +18,24 @@ export declare class ChainConnectionError extends Error {
   chainId: string;
   constructor(chainId: string, options?: ErrorOptions);
 }
+/**
+ * Passed to subscription callbacks when the chain has been unreachable for a while. Not
+ * terminal: the subscription stays registered and is re-issued when a socket connects.
+ */
 export declare class StaleRpcError extends Error {
   type: "STALE_RPC_ERROR";
   chainId: string;
   constructor(chainId: string, options?: ErrorOptions);
 }
+export type ChainConnectorDotOptions = {
+  /**
+   * How long a new socket may take to open before the provider gives up on the endpoint
+   * and tries the next one. Defaults to polkadot-api's 5 seconds. A slow device or
+   * network can take longer than that to connect while it is busy, as a phone app is
+   * at startup, and every endpoint then times out in turn.
+   */
+  connectionTimeout?: number;
+};
 /**
  * ChainConnector provides an interface similar to a websocket JSON-RPC provider, but with three points of difference:
  *
@@ -39,7 +52,7 @@ export declare class StaleRpcError extends Error {
  */
 export declare class ChainConnectorDot implements IChainConnectorDot {
   #private;
-  constructor(chaindataChainProvider: IChaindataNetworkProvider);
+  constructor(chaindataChainProvider: IChaindataNetworkProvider, options?: ChainConnectorDotOptions);
   send<T = any>(chainId: DotNetworkId, method: string, params: unknown[], _isCacheable?: boolean | undefined, extraOptions?: {
     /**
      * Set to `true` if this query is speculative, i.e. if on some chains it's expected that it will raise a wasm unreachable error of the form:
@@ -81,6 +94,40 @@ export declare class ChainConnectorDot implements IChainConnectorDot {
   private getTalismanSub;
 }
 //#endregion
+//#region src/dot/ChainConnectorDotPapi.d.ts
+/** The parts of a polkadot-api `PolkadotClient` that the connector uses */
+export type PapiClient = {
+  /** `PolkadotClient` types it without `abortSignal`, but it is substrate-client's `request`, which honours it */
+  _request: <Reply>(method: string, params: unknown[], abortSignal?: AbortSignal) => Promise<Reply>;
+  bestBlocks$: {
+    subscribe: (observer: {
+      next: (blocks: {
+        hash: string;
+      }[]) => void;
+      error: (error: unknown) => void;
+      complete: () => void;
+    }) => {
+      unsubscribe: () => void;
+    };
+  };
+};
+/**
+ * Runs `@talismn/balances` over a dapp's polkadot-api clients, so the dapp and its balances share one socket per chain.
+ *
+ * `state_subscribeStorage` is the only subscription balances uses. It is served by querying the keys at each new
+ * best block and reporting the values that changed, like the node does. One query runs at a time, for the latest
+ * best block. A failed query is retried at the next block, because balances treats a subscription error as final
+ * and would stop updating that network. Only when the first three queries fail does the subscription report the error.
+ */
+export declare class ChainConnectorDotPapi implements IChainConnectorDot {
+  #private;
+  constructor(clientFor: (networkId: DotNetworkId) => PapiClient | undefined);
+  send<T = unknown>(networkId: DotNetworkId, method: string, params: unknown[]): Promise<T>;
+  subscribe(networkId: DotNetworkId, subscribeMethod: string, _responseMethod: string, params: unknown[], callback: SubscriptionCallback, timeout?: number | false): Promise<(unsubscribeMethod: string) => void>;
+  reset(): Promise<void>;
+  private getClient;
+}
+//#endregion
 //#region src/dot/ChainConnectorDotStub.d.ts
 export declare class ChainConnectorDotStub implements IChainConnectorDot {
   #private;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/dot/IChainConnectorDot.ts","../src/dot/ChainConnectorDot.ts","../src/dot/ChainConnectorDotStub.ts","../src/eth/IChainConnectorEth.ts","../src/eth/ChainConnectorEth.ts","../src/eth/ChainConnectorEthStub.ts","../src/sol/getSolRpc.ts","../src/sol/IChainConnectorSol.ts","../src/sol/ChainConnectorSol.ts","../src/sol/ChainConnectorSolStub.ts"],"mappings":";;;;;YAIY,wBAAwB,OAAO,cAAc;iBAExC;EACf,KAAK,aACH,SAAS,cACT,gBACA,mBACA,uBACA;IACE;MAED,QAAQ;EAEX,UACE,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EAEZ,MAAM,SAAS,eAAe;;;;qBCCnB,6BAA6B;EACxC;EACA;EAEA,YAAY,iBAAiB,UAAU;;qBAQ5B,sBAAsB;EACjC;EACA;EAEA,YAAY,iBAAiB,UAAU;;;;;;;;;;;;;;;;qBA+C5B,6BAA6B;;EAMxC,YAAY,wBAAwB;EAK9B,KAAK,SACT,SAAS,cACT,gBACA,mBACA,oCACA;;;;;;;;;;IAUE;MAED,QAAQ;EAsDL,UACJ,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;;;;;;EA6FN,MAAM,SAAS,eAAY;;UAyBzB;;UA0BA;;;;;;UAgCM;UAuBA;UA8BN;UAoDA;UAWA;UAsBM;;UAYN;;UAQA;UAIA;;;;qBC5fG,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,KAAK,aACT,UAAU,cACV,gBACA,mBACA,yBACC,QAAQ;EAOL,UACJ,UAAU,cACV,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA4BZ,SAAS;EAIT;;;;iBChEe;EACf,+BAA+B,cAAc,iBAAiB,QAAQ;EACtE,+BACE,cAAc,cACd,0BAA0B,YACvB,QAAQ;EACb,yBAAyB,eAAe;;;;qBCE7B,6BAA6B;;EAGxC,YAAY,mBAAmB,4BAA4B;EAIrD,6BAA6B,cAAc,eAAe,QAAQ;EAOlE,6BACJ,cAAc,cACd,0BAA0B,UACzB,QAAQ;EAOJ,uBAAuB,eAAe;;;;qBC5BlC,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,gCAAgC,QAAQ;EAIxC,6BACJ,YAAY,cACZ,0BAA0B,UACzB,QAAQ;EAIX;;;;YCrBU,SAAS,IAAI;YAqHb;;EAEV,gBAAgB;;;;;;;qBAuDL,kBAAe,YACd,cAAY,gBACV,UACL,wBACR;qBAIU,YAAS,WACT,cAAY,gBACT,UACJ,wBACT;;;iBCzLc;EACf,SAAS,WAAW,iBAAiB,QAAQ;;EAE7C,eAAe,WAAW,iBAAiB,QAAQ;;;;qBCIxC,6BAA6B;;EAKxC,YAAY,mBAAmB,4BAA4B;EAWrD,aAAa,WAAW,eAAe,QAAQ;EAU/C,OAAO,WAAW,eAAe,QAAQ;;EAQ/C,uBAAuB,YAAY;;;;qBCtCxB,iCAAiC;;EAI5C,YAAY,SAAS,KAAK;EAKpB,UAAU,QAAQ;EAIlB,gBAAgB,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/dot/IChainConnectorDot.ts","../src/dot/ChainConnectorDot.ts","../src/dot/ChainConnectorDotPapi.ts","../src/dot/ChainConnectorDotStub.ts","../src/eth/IChainConnectorEth.ts","../src/eth/ChainConnectorEth.ts","../src/eth/ChainConnectorEthStub.ts","../src/sol/getSolRpc.ts","../src/sol/IChainConnectorSol.ts","../src/sol/ChainConnectorSol.ts","../src/sol/ChainConnectorSolStub.ts"],"mappings":";;;;;YAIY,wBAAwB,OAAO,cAAc;iBAExC;EACf,KAAK,aACH,SAAS,cACT,gBACA,mBACA,uBACA;IACE;MAED,QAAQ;EAEX,UACE,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EAEZ,MAAM,SAAS,eAAe;;;;qBCOnB,6BAA6B;EACxC;EACA;EAEA,YAAY,iBAAiB,UAAU;;;;;;qBAY5B,sBAAsB;EACjC;EACA;EAEA,YAAY,iBAAiB,UAAU;;YAmC7B;;;;;;;EAOV;;;;;;;;;;;;;;;;qBAiBW,6BAA6B;;EAOxC,YACE,wBAAwB,2BACxB,UAAU;EAON,KAAK,SACT,SAAS,cACT,gBACA,mBACA,oCACA;;;;;;;;;;IAUE;MAED,QAAQ;EAsDL,UACJ,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;;;;;;EA2FN,MAAM,SAAS,eAAY;;UA2BzB;;UA0BA;;;;;;UAgCM;UA2BA;UAgCN;UAoDA;UAeA;UAwBM;;UAYN;;UAQA;UAIA;;;;;YC/hBE;;EAEV,WAAW,OAAO,gBAAgB,mBAAmB,cAAc,gBAAgB,QAAQ;EAC3F;IACE,YAAY;MACV,OAAO;QAAU;;MACjB,QAAQ;MACR;;MACM;;;;;;;;;;;;qBAYC,iCAAiC;;EAG5C,YAAY,YAAY,WAAW,iBAAiB;EAI9C,KAAK,aAAa,WAAW,cAAc,gBAAgB,oBAAoB,QAAQ;EAIvF,UACJ,WAAW,cACX,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA8FN,SAAK;UAEH;;;;qBC1IG,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,KAAK,aACT,UAAU,cACV,gBACA,mBACA,yBACC,QAAQ;EAOL,UACJ,UAAU,cACV,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA4BZ,SAAS;EAIT;;;;iBChEe;EACf,+BAA+B,cAAc,iBAAiB,QAAQ;EACtE,+BACE,cAAc,cACd,0BAA0B,YACvB,QAAQ;EACb,yBAAyB,eAAe;;;;qBCE7B,6BAA6B;;EAGxC,YAAY,mBAAmB,4BAA4B;EAIrD,6BAA6B,cAAc,eAAe,QAAQ;EAOlE,6BACJ,cAAc,cACd,0BAA0B,UACzB,QAAQ;EAOJ,uBAAuB,eAAe;;;;qBC5BlC,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,gCAAgC,QAAQ;EAIxC,6BACJ,YAAY,cACZ,0BAA0B,UACzB,QAAQ;EAIX;;;;YCrBU,SAAS,IAAI;YAqHb;;EAEV,gBAAgB;;;;;;;qBAuDL,kBAAe,YACd,cAAY,gBACV,UACL,wBACR;qBAIU,YAAS,WACT,cAAY,gBACT,UACJ,wBACT;;;iBCzLc;EACf,SAAS,WAAW,iBAAiB,QAAQ;;EAE7C,eAAe,WAAW,iBAAiB,QAAQ;;;;qBCIxC,6BAA6B;;EAKxC,YAAY,mBAAmB,4BAA4B;EAWrD,aAAa,WAAW,eAAe,QAAQ;EAU/C,OAAO,WAAW,eAAe,QAAQ;;EAQ/C,uBAAuB,YAAY;;;;qBCtCxB,iCAAiC;;EAI5C,YAAY,SAAS,KAAK;EAKpB,UAAU,QAAQ;EAIlB,gBAAgB,QAAQ"}

package/dist/index.d.ts

@@ -18,11 +18,24 @@ export declare class ChainConnectionError extends Error {
   chainId: string;
   constructor(chainId: string, options?: ErrorOptions);
 }
+/**
+ * Passed to subscription callbacks when the chain has been unreachable for a while. Not
+ * terminal: the subscription stays registered and is re-issued when a socket connects.
+ */
 export declare class StaleRpcError extends Error {
   type: "STALE_RPC_ERROR";
   chainId: string;
   constructor(chainId: string, options?: ErrorOptions);
 }
+export type ChainConnectorDotOptions = {
+  /**
+   * How long a new socket may take to open before the provider gives up on the endpoint
+   * and tries the next one. Defaults to polkadot-api's 5 seconds. A slow device or
+   * network can take longer than that to connect while it is busy, as a phone app is
+   * at startup, and every endpoint then times out in turn.
+   */
+  connectionTimeout?: number;
+};
 /**
  * ChainConnector provides an interface similar to a websocket JSON-RPC provider, but with three points of difference:
  *
@@ -39,7 +52,7 @@ export declare class StaleRpcError extends Error {
  */
 export declare class ChainConnectorDot implements IChainConnectorDot {
   #private;
-  constructor(chaindataChainProvider: IChaindataNetworkProvider);
+  constructor(chaindataChainProvider: IChaindataNetworkProvider, options?: ChainConnectorDotOptions);
   send<T = any>(chainId: DotNetworkId, method: string, params: unknown[], _isCacheable?: boolean | undefined, extraOptions?: {
     /**
      * Set to `true` if this query is speculative, i.e. if on some chains it's expected that it will raise a wasm unreachable error of the form:
@@ -81,6 +94,40 @@ export declare class ChainConnectorDot implements IChainConnectorDot {
   private getTalismanSub;
 }
 //#endregion
+//#region src/dot/ChainConnectorDotPapi.d.ts
+/** The parts of a polkadot-api `PolkadotClient` that the connector uses */
+export type PapiClient = {
+  /** `PolkadotClient` types it without `abortSignal`, but it is substrate-client's `request`, which honours it */
+  _request: <Reply>(method: string, params: unknown[], abortSignal?: AbortSignal) => Promise<Reply>;
+  bestBlocks$: {
+    subscribe: (observer: {
+      next: (blocks: {
+        hash: string;
+      }[]) => void;
+      error: (error: unknown) => void;
+      complete: () => void;
+    }) => {
+      unsubscribe: () => void;
+    };
+  };
+};
+/**
+ * Runs `@talismn/balances` over a dapp's polkadot-api clients, so the dapp and its balances share one socket per chain.
+ *
+ * `state_subscribeStorage` is the only subscription balances uses. It is served by querying the keys at each new
+ * best block and reporting the values that changed, like the node does. One query runs at a time, for the latest
+ * best block. A failed query is retried at the next block, because balances treats a subscription error as final
+ * and would stop updating that network. Only when the first three queries fail does the subscription report the error.
+ */
+export declare class ChainConnectorDotPapi implements IChainConnectorDot {
+  #private;
+  constructor(clientFor: (networkId: DotNetworkId) => PapiClient | undefined);
+  send<T = unknown>(networkId: DotNetworkId, method: string, params: unknown[]): Promise<T>;
+  subscribe(networkId: DotNetworkId, subscribeMethod: string, _responseMethod: string, params: unknown[], callback: SubscriptionCallback, timeout?: number | false): Promise<(unsubscribeMethod: string) => void>;
+  reset(): Promise<void>;
+  private getClient;
+}
+//#endregion
 //#region src/dot/ChainConnectorDotStub.d.ts
 export declare class ChainConnectorDotStub implements IChainConnectorDot {
   #private;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/dot/IChainConnectorDot.ts","../src/dot/ChainConnectorDot.ts","../src/dot/ChainConnectorDotStub.ts","../src/eth/IChainConnectorEth.ts","../src/eth/ChainConnectorEth.ts","../src/eth/ChainConnectorEthStub.ts","../src/sol/getSolRpc.ts","../src/sol/IChainConnectorSol.ts","../src/sol/ChainConnectorSol.ts","../src/sol/ChainConnectorSolStub.ts"],"mappings":";;;;;YAIY,wBAAwB,OAAO,cAAc;iBAExC;EACf,KAAK,aACH,SAAS,cACT,gBACA,mBACA,uBACA;IACE;MAED,QAAQ;EAEX,UACE,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EAEZ,MAAM,SAAS,eAAe;;;;qBCCnB,6BAA6B;EACxC;EACA;EAEA,YAAY,iBAAiB,UAAU;;qBAQ5B,sBAAsB;EACjC;EACA;EAEA,YAAY,iBAAiB,UAAU;;;;;;;;;;;;;;;;qBA+C5B,6BAA6B;;EAMxC,YAAY,wBAAwB;EAK9B,KAAK,SACT,SAAS,cACT,gBACA,mBACA,oCACA;;;;;;;;;;IAUE;MAED,QAAQ;EAsDL,UACJ,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;;;;;;EA6FN,MAAM,SAAS,eAAY;;UAyBzB;;UA0BA;;;;;;UAgCM;UAuBA;UA8BN;UAoDA;UAWA;UAsBM;;UAYN;;UAQA;UAIA;;;;qBC5fG,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,KAAK,aACT,UAAU,cACV,gBACA,mBACA,yBACC,QAAQ;EAOL,UACJ,UAAU,cACV,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA4BZ,SAAS;EAIT;;;;iBChEe;EACf,+BAA+B,cAAc,iBAAiB,QAAQ;EACtE,+BACE,cAAc,cACd,0BAA0B,YACvB,QAAQ;EACb,yBAAyB,eAAe;;;;qBCE7B,6BAA6B;;EAGxC,YAAY,mBAAmB,4BAA4B;EAIrD,6BAA6B,cAAc,eAAe,QAAQ;EAOlE,6BACJ,cAAc,cACd,0BAA0B,UACzB,QAAQ;EAOJ,uBAAuB,eAAe;;;;qBC5BlC,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,gCAAgC,QAAQ;EAIxC,6BACJ,YAAY,cACZ,0BAA0B,UACzB,QAAQ;EAIX;;;;YCrBU,SAAS,IAAI;YAqHb;;EAEV,gBAAgB;;;;;;;qBAuDL,kBAAe,YACd,cAAY,gBACV,UACL,wBACR;qBAIU,YAAS,WACT,cAAY,gBACT,UACJ,wBACT;;;iBCzLc;EACf,SAAS,WAAW,iBAAiB,QAAQ;;EAE7C,eAAe,WAAW,iBAAiB,QAAQ;;;;qBCIxC,6BAA6B;;EAKxC,YAAY,mBAAmB,4BAA4B;EAWrD,aAAa,WAAW,eAAe,QAAQ;EAU/C,OAAO,WAAW,eAAe,QAAQ;;EAQ/C,uBAAuB,YAAY;;;;qBCtCxB,iCAAiC;;EAI5C,YAAY,SAAS,KAAK;EAKpB,UAAU,QAAQ;EAIlB,gBAAgB,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/dot/IChainConnectorDot.ts","../src/dot/ChainConnectorDot.ts","../src/dot/ChainConnectorDotPapi.ts","../src/dot/ChainConnectorDotStub.ts","../src/eth/IChainConnectorEth.ts","../src/eth/ChainConnectorEth.ts","../src/eth/ChainConnectorEthStub.ts","../src/sol/getSolRpc.ts","../src/sol/IChainConnectorSol.ts","../src/sol/ChainConnectorSol.ts","../src/sol/ChainConnectorSolStub.ts"],"mappings":";;;;;YAIY,wBAAwB,OAAO,cAAc;iBAExC;EACf,KAAK,aACH,SAAS,cACT,gBACA,mBACA,uBACA;IACE;MAED,QAAQ;EAEX,UACE,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EAEZ,MAAM,SAAS,eAAe;;;;qBCOnB,6BAA6B;EACxC;EACA;EAEA,YAAY,iBAAiB,UAAU;;;;;;qBAY5B,sBAAsB;EACjC;EACA;EAEA,YAAY,iBAAiB,UAAU;;YAmC7B;;;;;;;EAOV;;;;;;;;;;;;;;;;qBAiBW,6BAA6B;;EAOxC,YACE,wBAAwB,2BACxB,UAAU;EAON,KAAK,SACT,SAAS,cACT,gBACA,mBACA,oCACA;;;;;;;;;;IAUE;MAED,QAAQ;EAsDL,UACJ,SAAS,cACT,yBACA,wBACA,mBACA,UAAU,sBACV,2BACC,SAAS;;;;;;EA2FN,MAAM,SAAS,eAAY;;UA2BzB;;UA0BA;;;;;;UAgCM;UA2BA;UAgCN;UAoDA;UAeA;UAwBM;;UAYN;;UAQA;UAIA;;;;;YC/hBE;;EAEV,WAAW,OAAO,gBAAgB,mBAAmB,cAAc,gBAAgB,QAAQ;EAC3F;IACE,YAAY;MACV,OAAO;QAAU;;MACjB,QAAQ;MACR;;MACM;;;;;;;;;;;;qBAYC,iCAAiC;;EAG5C,YAAY,YAAY,WAAW,iBAAiB;EAI9C,KAAK,aAAa,WAAW,cAAc,gBAAgB,oBAAoB,QAAQ;EAIvF,UACJ,WAAW,cACX,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA8FN,SAAK;UAEH;;;;qBC1IG,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,KAAK,aACT,UAAU,cACV,gBACA,mBACA,yBACC,QAAQ;EAOL,UACJ,UAAU,cACV,yBACA,yBACA,mBACA,UAAU,sBACV,2BACC,SAAS;EA4BZ,SAAS;EAIT;;;;iBChEe;EACf,+BAA+B,cAAc,iBAAiB,QAAQ;EACtE,+BACE,cAAc,cACd,0BAA0B,YACvB,QAAQ;EACb,yBAAyB,eAAe;;;;qBCE7B,6BAA6B;;EAGxC,YAAY,mBAAmB,4BAA4B;EAIrD,6BAA6B,cAAc,eAAe,QAAQ;EAOlE,6BACJ,cAAc,cACd,0BAA0B,UACzB,QAAQ;EAOJ,uBAAuB,eAAe;;;;qBC5BlC,iCAAiC;;EAG5C,YAAY,SAAS;EAIf,gCAAgC,QAAQ;EAIxC,6BACJ,YAAY,cACZ,0BAA0B,UACzB,QAAQ;EAIX;;;;YCrBU,SAAS,IAAI;YAqHb;;EAEV,gBAAgB;;;;;;;qBAuDL,kBAAe,YACd,cAAY,gBACV,UACL,wBACR;qBAIU,YAAS,WACT,cAAY,gBACT,UACJ,wBACT;;;iBCzLc;EACf,SAAS,WAAW,iBAAiB,QAAQ;;EAE7C,eAAe,WAAW,iBAAiB,QAAQ;;;;qBCIxC,6BAA6B;;EAKxC,YAAY,mBAAmB,4BAA4B;EAWrD,aAAa,WAAW,eAAe,QAAQ;EAU/C,OAAO,WAAW,eAAe,QAAQ;;EAQ/C,uBAAuB,YAAY;;;;qBCtCxB,iCAAiC;;EAI5C,YAAY,SAAS,KAAK;EAKpB,UAAU,QAAQ;EAIlB,gBAAgB,QAAQ"}

package/dist/index.js

@@ -40,8 +40,14 @@ const BAD_RPC_ERRORS = {
 	"-32097": "Rate limit exceeded",
 	"-32098": "Capacity exceeded"
 };
-const RESPONSE_TIMEOUT = 3e4;
+const RESPONSE_TIMEOUT$1 = 3e4;
 const KEEP_ALIVE_INTERVAL = 2e4;
+/**
+* How long a connection stays open once its last user releases it. A one-off request is
+* often followed by more traffic to the same chain (balances read the runtime version,
+* then subscribe to storage), which then reuses the socket instead of opening a new one.
+*/
+const IDLE_CLOSE_DELAY = 3e4;
 /** in-flight requests reject with DestroyedError when a connection is torn down - expected, not worth logging */
 const isDestroyedError = (error) => error instanceof Error && error.name === "DestroyedError";
 const STALE_NOTIFY_TIMEOUT = 3e4;
@@ -54,6 +60,10 @@ var ChainConnectionError = class extends Error {
 		this.chainId = chainId;
 	}
 };
+/**
+* Passed to subscription callbacks when the chain has been unreachable for a while. Not
+* terminal: the subscription stays registered and is re-issued when a socket connects.
+*/
 var StaleRpcError = class extends Error {
 	type;
 	chainId;
@@ -79,10 +89,12 @@ var StaleRpcError = class extends Error {
 */
 var ChainConnectorDot = class {
 	#chaindataChainProvider;
+	#connectionTimeout;
 	#connections = {};
 	#pendingConnections = {};
-	constructor(chaindataChainProvider) {
+	constructor(chaindataChainProvider, options) {
 		this.#chaindataChainProvider = chaindataChainProvider;
+		this.#connectionTimeout = options?.connectionTimeout;
 	}
 	async send(chainId, method, params, _isCacheable, extraOptions) {
 		const talismanSub = this.getTalismanSub();
@@ -171,8 +183,7 @@ var ChainConnectorDot = class {
 			subscription.cancelRequest?.();
 			subscription.stopFollow?.();
 			const current = this.#connections[chainId];
-			const isLastUser = !!current && current.users.size === 1 && current.users.has(socketUserId);
-			if (subscription.serverSubId !== null && current && !isLastUser) try {
+			if (subscription.serverSubId !== null && current) try {
 				current.client.request(unsubscribeMethod, [subscription.serverSubId]).catch((error) => {
 					if (!isDestroyedError(error)) log_default.warn(`Failed to unsubscribe from ${chainId}`, error);
 				});
@@ -202,11 +213,11 @@ var ChainConnectorDot = class {
 			for (const subscription of fresh.subscriptions) this.startSubscription(fresh, subscription);
 		} catch (error) {
 			log_default.warn(`Failed to recreate connection for ${chainId} after reset`, error);
-			for (const subscription of connection.subscriptions) subscription.callback(new StaleRpcError(chainId, { cause: error }), null);
+			for (const subscription of connection.subscriptions) subscription.callback(new ChainConnectionError(chainId, { cause: error }), null);
 		}
 	}
 	/** Sends a request over a connection, throwing `Error("TIMEOUT")` if no response arrives in time */
-	request(connection, method, params, timeoutMs = RESPONSE_TIMEOUT) {
+	request(connection, method, params, timeoutMs = RESPONSE_TIMEOUT$1) {
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				cancel();
@@ -260,6 +271,10 @@ var ChainConnectorDot = class {
 			});
 			connection = await this.#pendingConnections[chainId];
 		}
+		if (connection.idleTimeout) {
+			clearTimeout(connection.idleTimeout);
+			connection.idleTimeout = null;
+		}
 		const socketUserId = this.getExclusiveRandomId([...connection.users]);
 		connection.users.add(socketUserId);
 		return [socketUserId, connection];
@@ -270,7 +285,10 @@ var ChainConnectorDot = class {
 		const rpcs = chain.rpcs.concat();
 		if (!rpcs.length) throw new Error(`No healthy RPCs available for chain ${chainId}`);
 		let connection = null;
-		const provider = (0, _polkadot_api_ws_provider.getWsProvider)(rpcs, { onStatusChanged: (status) => this.handleStatusChange(connection, status) });
+		const provider = (0, _polkadot_api_ws_provider.getWsProvider)(rpcs, {
+			onStatusChanged: (status) => this.handleStatusChange(connection, status),
+			...this.#connectionTimeout !== void 0 && { timeout: this.#connectionTimeout }
+		});
 		connection = {
 			chainId,
 			provider,
@@ -279,7 +297,8 @@ var ChainConnectorDot = class {
 			subscriptions: /* @__PURE__ */ new Set(),
 			wasConnected: false,
 			keepAliveInterval: null,
-			staleTimeout: null
+			staleTimeout: null,
+			idleTimeout: null
 		};
 		return connection;
 	}
@@ -321,15 +340,21 @@ var ChainConnectorDot = class {
 		const connection = this.#connections[chainId];
 		if (!connection) return;
 		connection.users.delete(socketUserId);
-		if (connection.users.size > 0) return;
-		this.destroyConnection(connection);
-		delete this.#connections[chainId];
+		if (connection.users.size > 0 || connection.idleTimeout) return;
+		connection.idleTimeout = setTimeout(() => {
+			connection.idleTimeout = null;
+			if (connection.users.size > 0 || this.#connections[chainId] !== connection) return;
+			this.destroyConnection(connection);
+			delete this.#connections[chainId];
+		}, IDLE_CLOSE_DELAY);
 	}
 	destroyConnection(connection) {
 		if (connection.keepAliveInterval) clearInterval(connection.keepAliveInterval);
 		if (connection.staleTimeout) clearTimeout(connection.staleTimeout);
+		if (connection.idleTimeout) clearTimeout(connection.idleTimeout);
 		connection.keepAliveInterval = null;
 		connection.staleTimeout = null;
+		connection.idleTimeout = null;
 		for (const subscription of connection.subscriptions) {
 			subscription.stopFollow?.();
 			subscription.cancelRequest?.();
@@ -376,6 +401,119 @@ var ChainConnectorDot = class {
 	}
 };
 //#endregion
+//#region src/dot/ChainConnectorDotPapi.ts
+const RESPONSE_TIMEOUT = 3e4;
+const FAILURES_BEFORE_FIRST_RESULT = 3;
+/**
+* Runs `@talismn/balances` over a dapp's polkadot-api clients, so the dapp and its balances share one socket per chain.
+*
+* `state_subscribeStorage` is the only subscription balances uses. It is served by querying the keys at each new
+* best block and reporting the values that changed, like the node does. One query runs at a time, for the latest
+* best block. A failed query is retried at the next block, because balances treats a subscription error as final
+* and would stop updating that network. Only when the first three queries fail does the subscription report the error.
+*/
+var ChainConnectorDotPapi = class {
+	#clientFor;
+	constructor(clientFor) {
+		this.#clientFor = clientFor;
+	}
+	async send(networkId, method, params) {
+		return requestWithTimeout(this.getClient(networkId), method, params, new AbortController());
+	}
+	async subscribe(networkId, subscribeMethod, _responseMethod, params, callback, timeout = 3e4) {
+		const client = this.getClient(networkId);
+		if (subscribeMethod !== "state_subscribeStorage") throw new Error(`ChainConnectorDotPapi does not support ${subscribeMethod}`);
+		const [keys] = params;
+		const values = /* @__PURE__ */ new Map();
+		let bestBlockHash;
+		let queriedBlockHash;
+		let inFlight;
+		let delivered = false;
+		let failures = 0;
+		let active = true;
+		let subscription;
+		const staleTimer = timeout ? setTimeout(() => callback(new StaleRpcError(networkId), null), timeout) : void 0;
+		const stop = () => {
+			active = false;
+			clearTimeout(staleTimer);
+			inFlight?.abort();
+			subscription?.unsubscribe();
+		};
+		const finish = (error) => {
+			if (!active) return;
+			stop();
+			callback(error, null);
+		};
+		const reportChanges = (result) => {
+			const changes = result.changes.filter(([key, value]) => values.get(key) !== value);
+			for (const [key, value] of changes) values.set(key, value);
+			if (!changes.length) return;
+			delivered = true;
+			clearTimeout(staleTimer);
+			callback(null, {
+				block: result.block,
+				changes
+			});
+		};
+		const reportFailure = (error) => {
+			if (delivered || ++failures < FAILURES_BEFORE_FIRST_RESULT) return log_default.warn(`state_queryStorageAt failed on ${networkId}, retrying at the next block`, error);
+			finish(error);
+		};
+		const queryBestBlock = async () => {
+			if (!active || inFlight || !bestBlockHash || bestBlockHash === queriedBlockHash) return;
+			const blockHash = bestBlockHash;
+			queriedBlockHash = blockHash;
+			const controller = new AbortController();
+			inFlight = controller;
+			try {
+				const [result] = await requestWithTimeout(client, "state_queryStorageAt", [keys, blockHash], controller);
+				if (!active) return;
+				if (!result) throw new Error(`Empty state_queryStorageAt response on ${networkId}`);
+				reportChanges(result);
+			} catch (error) {
+				if (active) reportFailure(error);
+			} finally {
+				if (inFlight === controller) inFlight = void 0;
+				queryBestBlock();
+			}
+		};
+		try {
+			subscription = client.bestBlocks$.subscribe({
+				next: ([best]) => {
+					bestBlockHash = best?.hash;
+					queryBestBlock();
+				},
+				error: (error) => finish(error),
+				complete: () => finish(/* @__PURE__ */ new Error(`polkadot-api client for ${networkId} stopped following blocks`))
+			});
+		} catch (error) {
+			stop();
+			throw error;
+		}
+		if (!active) subscription.unsubscribe();
+		return stop;
+	}
+	async reset() {}
+	getClient(networkId) {
+		const client = this.#clientFor(networkId);
+		if (!client) throw new Error(`No polkadot-api client for network ${networkId}`);
+		return client;
+	}
+};
+/** rejects on its own timer too, so a client that ignores the abort signal cannot hang the caller */
+const requestWithTimeout = (client, method, params, controller) => new Promise((resolve, reject) => {
+	const timer = setTimeout(() => {
+		controller.abort();
+		reject(/* @__PURE__ */ new Error("Timeout"));
+	}, RESPONSE_TIMEOUT);
+	try {
+		client._request(method, params, controller.signal).then(resolve, reject).finally(() => clearTimeout(timer));
+	} catch (error) {
+		clearTimeout(timer);
+		reject(error);
+	}
+});
+//#endregion
 //#region src/dot/ChainConnectorDotStub.ts
 const TIMEOUT = 1e4;
 var ChainConnectorDotStub = class {
@@ -733,6 +871,7 @@ var ChainConnectorSolStub = class {
 //#endregion
 exports.ChainConnectionError = ChainConnectionError;
 exports.ChainConnectorDot = ChainConnectorDot;
+exports.ChainConnectorDotPapi = ChainConnectorDotPapi;
 exports.ChainConnectorDotStub = ChainConnectorDotStub;
 exports.ChainConnectorEth = ChainConnectorEth;
 exports.ChainConnectorEthStub = ChainConnectorEthStub;