@talismn/chain-connectors 0.0.0

package/dist/declarations/src/dot/ChainConnectorDot.d.ts

@@ -0,0 +1,79 @@
+import type { ProviderInterface, ProviderInterfaceCallback } from "@polkadot/rpc-provider/types";
+import { DotNetworkId, IChaindataNetworkProvider } from "@talismn/chaindata-provider";
+import { TalismanConnectionMetaDatabase } from "@talismn/connection-meta";
+import { IChainConnectorDot } from "./IChainConnectorDot";
+export declare class ChainConnectionError extends Error {
+    type: "CHAIN_CONNECTION_ERROR";
+    chainId: string;
+    constructor(chainId: string, options?: ErrorOptions);
+}
+export declare class StaleRpcError extends Error {
+    type: "STALE_RPC_ERROR";
+    chainId: string;
+    constructor(chainId: string, options?: ErrorOptions);
+}
+export declare class WebsocketAllocationExhaustedError extends Error {
+    type: "WEBSOCKET_ALLOCATION_EXHAUSTED_ERROR";
+    chainId: string;
+    constructor(chainId: string, options?: ErrorOptions);
+}
+/**
+ * ChainConnector provides an interface similar to WsProvider, but with three points of difference:
+ *
+ * 1. ChainConnector methods all accept a `chainId` instead of an array of RPCs. RPCs are then fetched internally from chaindata.
+ * 2. ChainConnector creates only one `WsProvider` per chain and ensures that all downstream requests to a chain share the one socket connection.
+ * 3. Subscriptions return a callable `unsubscribe` method instead of an id.
+ *
+ * Additionally, when run on the clientside of a dapp where `window.talismanSub` is available, instead of spinning up new websocket
+ * connections this class will forward all requests through to the wallet backend - where another instance of this class will
+ * handle the websocket connections.
+ */
+export declare class ChainConnectorDot implements IChainConnectorDot {
+    #private;
+    constructor(chaindataChainProvider: IChaindataNetworkProvider, connectionMetaDb?: TalismanConnectionMetaDatabase);
+    /**
+     * Creates a facade over this ChainConnector which conforms to the PJS ProviderInterface
+     * @example // Using a chainConnector as a Provider for an ApiPromise
+     *   const provider = chainConnector.asProvider('polkadot')
+     *   const api = new ApiPromise({ provider })
+     */
+    asProvider(chainId: DotNetworkId): ProviderInterface;
+    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:
+         *
+         *     4003: Client error: Execution failed: Execution aborted due to trap: wasm trap: wasm `unreachable` instruction executed
+         *
+         * By setting expectErrors to true, this method won't pollute the logs with errors we intend to have happen.
+         * An example use case of this is when you plan to catch the wasm unreachable error on chains that don't support the query, and then fall back
+         * to another query or perhaps an empty result.
+         */
+        expectErrors?: boolean;
+    }): Promise<T>;
+    subscribe(chainId: DotNetworkId, subscribeMethod: string, responseMethod: string, params: unknown[], callback: ProviderInterfaceCallback, timeout?: number | false): Promise<(unsubscribeMethod: string) => void>;
+    /**
+     * Kills current websocket if any
+     * Useful after changing rpc order to make sure it's applied for futher requests
+     */
+    reset(chainId: DotNetworkId): Promise<void>;
+    /**
+     * Wait for websocket to be ready, but don't wait forever
+     */
+    private waitForWs;
+    /**
+     * Connect to an RPC via chainId
+     *
+     * The caller must call disconnectChainSocket with the returned SocketUserId once they are finished with it
+     */
+    private connectChainSocket;
+    private disconnectChainSocket;
+    private addSocketUser;
+    private removeSocketUser;
+    /** continues to generate a random number until it finds one which is not present in the exclude list */
+    private getExclusiveRandomId;
+    /** generates a random number */
+    private getRandomId;
+    private getTalismanSub;
+    private updateRpcPriority;
+    private getEndpoints;
+}

package/dist/declarations/src/dot/ChainConnectorDotStub.d.ts

@@ -0,0 +1,11 @@
+import { ProviderInterface, ProviderInterfaceCallback } from "@polkadot/rpc-provider/types";
+import { DotNetwork, DotNetworkId } from "@talismn/chaindata-provider";
+import { IChainConnectorDot } from "./IChainConnectorDot";
+export declare class ChainConnectorDotStub implements IChainConnectorDot {
+    #private;
+    constructor(network: DotNetwork);
+    asProvider(): ProviderInterface;
+    send<T = unknown>(chainId: DotNetworkId, method: string, params: unknown[], isCacheable?: boolean): Promise<T>;
+    subscribe(chainId: DotNetworkId, subscribeMethod: string, responseMethod: string, params: unknown[], callback: ProviderInterfaceCallback, timeout?: number | false): Promise<(unsubscribeMethod: string) => void>;
+    reset(): Promise<void>;
+}

package/dist/declarations/src/dot/IChainConnectorDot.d.ts

@@ -0,0 +1,10 @@
+import { ProviderInterface, ProviderInterfaceCallback } from "@polkadot/rpc-provider/types";
+import { DotNetworkId } from "@talismn/chaindata-provider";
+export interface IChainConnectorDot {
+    asProvider(chainId: DotNetworkId): ProviderInterface;
+    send<T = unknown>(chainId: DotNetworkId, method: string, params: unknown[], isCacheable?: boolean, extraOptions?: {
+        expectErrors?: boolean;
+    }): Promise<T>;
+    subscribe(chainId: DotNetworkId, subscribeMethod: string, responseMethod: string, params: unknown[], callback: ProviderInterfaceCallback, timeout?: number | false): Promise<(unsubscribeMethod: string) => void>;
+    reset(chainId: DotNetworkId): Promise<void>;
+}

package/dist/declarations/src/dot/Websocket.d.ts

@@ -0,0 +1,111 @@
+import type { ProviderInterfaceEmitted as PjsProviderInterfaceEmitted, ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb } from "@polkadot/rpc-provider/types";
+type ProviderInterfaceEmitted = PjsProviderInterfaceEmitted | "stale-rpcs";
+interface SubscriptionHandler {
+    callback: ProviderInterfaceCallback;
+    type: string;
+}
+/**
+ * # @talismn/chain-connector/Websocket
+ *
+ * @name Websocket
+ *
+ * @description The WebSocket Provider allows sending requests using WebSocket to a WebSocket RPC server TCP port. Unlike the [[HttpProvider]], it does support subscriptions and allows listening to events such as new blocks or balance changes.
+ *
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { Websocket } from '@talismn/chain-connector';
+ *
+ * const provider = new Websocket('ws://127.0.0.1:9944');
+ * ```
+ *
+ * @see [[HttpProvider]]
+ */
+export declare class Websocket implements ProviderInterface {
+    #private;
+    /**
+     * @param {string | string[]}  endpoint    The endpoint url. Usually `ws://ip:9944` or `wss://ip:9944`, may provide an array of endpoint strings.
+     * @param {Record<string, string>} headers The headers provided to the underlying WebSocket
+     * @param {number} [timeout] Custom timeout value used per request . Defaults to `DEFAULT_TIMEOUT_MS`
+     */
+    constructor(endpoint: string | string[], headers?: Record<string, string>, timeout?: number, nextBackoffInterval?: number);
+    /**
+     * @summary `true` when this provider supports subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @summary `true` when this provider supports clone()
+     */
+    get isClonable(): boolean;
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * @description Promise that resolves the first time we are connected and loaded
+     */
+    get isReady(): Promise<Websocket>;
+    get endpoint(): string;
+    /**
+     * @description Returns a clone of the object
+     */
+    clone(): Websocket;
+    protected selectEndpointIndex(endpoints: string[]): number;
+    /**
+     * @summary Manually connect
+     * @description The [[Websocket]] connects automatically by default, however if you decided otherwise, you may
+     * connect manually using this method.
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Connect, never throwing an error, but rather forcing a retry
+     */
+    connectWithRetry(): Promise<void>;
+    protected scheduleNextRetry(): void;
+    /**
+     * @description Manually disconnect from the connection, clearing auto-connect logic
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    /**
+     * @summary Send JSON data using WebSockets to configured HTTP Endpoint or queue.
+     * @param method The RPC methods to execute
+     * @param params Encoded parameters as applicable for the method
+     * @param subscription Subscription details (internally used)
+     */
+    send<T = any>(method: string, params: unknown[], 
+    /** @deprecated \@talismn/chain-connector doesn't implement a cache */
+    isCacheable?: boolean, subscription?: SubscriptionHandler): Promise<T>;
+    /**
+     * @name subscribe
+     * @summary Allows subscribing to a specific event.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const provider = new Websocket('ws://127.0.0.1:9944');
+     * const rpc = new Rpc(provider);
+     *
+     * rpc.state.subscribeStorage([[storage.system.account, <Address>]], (_, values) => {
+     *   console.log(values)
+     * }).then((subscriptionId) => {
+     *   console.log('balance changes subscription id: ', subscriptionId)
+     * })
+     * ```
+     */
+    subscribe(type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};

package/dist/declarations/src/dot/helpers.d.ts

@@ -0,0 +1,15 @@
+export declare class ExponentialBackoff {
+    #private;
+    constructor(maxIntervalMs?: number, minIntervalMs?: number);
+    enable(): void;
+    disable(): void;
+    increase(): void;
+    decrease(): void;
+    reset(): void;
+    resetTo(nextInterval: number): void;
+    resetToMax(): void;
+    get isActive(): boolean;
+    get next(): number;
+    get isMin(): boolean;
+    get isMax(): boolean;
+}

package/dist/declarations/src/dot/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IChainConnectorDot";
+export * from "./ChainConnectorDot";
+export * from "./ChainConnectorDotStub";

package/dist/declarations/src/eth/ChainConnectorEth.d.ts

@@ -0,0 +1,10 @@
+import { EthNetworkId, IChaindataNetworkProvider, IChaindataTokenProvider } from "@talismn/chaindata-provider";
+import { Account, PublicClient, WalletClient } from "viem";
+import { IChainConnectorEth } from "./IChainConnectorEth";
+export declare class ChainConnectorEth implements IChainConnectorEth {
+    #private;
+    constructor(chaindataProvider: IChaindataNetworkProvider & IChaindataTokenProvider);
+    getPublicClientForEvmNetwork(evmNetworkId: EthNetworkId): Promise<PublicClient | null>;
+    getWalletClientForEvmNetwork(evmNetworkId: EthNetworkId, account?: `0x${string}` | Account): Promise<WalletClient | null>;
+    clearRpcProvidersCache(evmNetworkId?: EthNetworkId): void;
+}

package/dist/declarations/src/eth/ChainConnectorEthStub.d.ts

@@ -0,0 +1,10 @@
+import { EthNetwork, EthNetworkId } from "@talismn/chaindata-provider";
+import { Account, PublicClient, WalletClient } from "viem";
+import { IChainConnectorEth } from "./IChainConnectorEth";
+export declare class ChainConnectorEthStub implements IChainConnectorEth {
+    #private;
+    constructor(network: EthNetwork);
+    getPublicClientForEvmNetwork(): Promise<PublicClient | null>;
+    getWalletClientForEvmNetwork(networkId: EthNetworkId, account?: `0x${string}` | Account): Promise<WalletClient | null>;
+    clearRpcProvidersCache(): void;
+}

package/dist/declarations/src/eth/IChainConnectorEth.d.ts

@@ -0,0 +1,7 @@
+import { EthNetworkId } from "@talismn/chaindata-provider";
+import { Account, PublicClient, WalletClient } from "viem";
+export interface IChainConnectorEth {
+    getPublicClientForEvmNetwork: (evmNetworkId: EthNetworkId) => Promise<PublicClient | null>;
+    getWalletClientForEvmNetwork: (evmNetworkId: EthNetworkId, account?: `0x${string}` | Account) => Promise<WalletClient | null>;
+    clearRpcProvidersCache: (evmNetworkId?: EthNetworkId) => void;
+}

package/dist/declarations/src/eth/getChainFromEvmNetwork.d.ts

@@ -0,0 +1,4 @@
+import { EthNetwork, EthNetworkId } from "@talismn/chaindata-provider";
+import { Chain } from "viem";
+export declare const clearChainsCache: (networkId?: EthNetworkId) => void;
+export declare const getChainFromEvmNetwork: (network: EthNetwork) => Chain;

package/dist/declarations/src/eth/getEvmNetworkPublicClient.d.ts

@@ -0,0 +1,4 @@
+import { EthNetwork } from "@talismn/chaindata-provider";
+import { PublicClient } from "viem";
+export declare const clearPublicClientCache: (evmNetworkId?: string) => void;
+export declare const getEvmNetworkPublicClient: (network: EthNetwork) => PublicClient;

package/dist/declarations/src/eth/getEvmNetworkWalletClient.d.ts

@@ -0,0 +1,7 @@
+import { EthNetwork } from "@talismn/chaindata-provider";
+import { Account, WalletClient } from "viem";
+type WalletClientOptions = {
+    account?: `0x${string}` | Account;
+};
+export declare const getEvmNetworkWalletClient: (network: EthNetwork, options?: WalletClientOptions) => WalletClient;
+export {};

package/dist/declarations/src/eth/getTransportForEvmNetwork.d.ts

@@ -0,0 +1,8 @@
+import { EthNetwork } from "@talismn/chaindata-provider";
+export type TransportOptions = {
+    batch?: boolean | {
+        batchSize?: number | undefined;
+        wait?: number | undefined;
+    };
+};
+export declare const getTransportForEvmNetwork: (evmNetwork: EthNetwork, options?: TransportOptions) => import("viem").FallbackTransport<import("viem").HttpTransport<undefined, false>[]>;

package/dist/declarations/src/eth/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IChainConnectorEth";
+export * from "./ChainConnectorEth";
+export * from "./ChainConnectorEthStub";

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./dot";
+export * from "./eth";
+export * from "./sol";

package/dist/declarations/src/log.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("anylogger").Logger<import("anylogger").BaseLevels>;
+export default _default;

package/dist/declarations/src/sol/ChainConnectorSol.d.ts

@@ -0,0 +1,8 @@
+import { Connection } from "@solana/web3.js";
+import { IChaindataNetworkProvider, IChaindataTokenProvider, SolNetworkId } from "@talismn/chaindata-provider";
+import { IChainConnectorSol } from "./IChainConnectorSol";
+export declare class ChainConnectorSol implements IChainConnectorSol {
+    #private;
+    constructor(chaindataProvider: IChaindataNetworkProvider & IChaindataTokenProvider);
+    getConnection(networkId: SolNetworkId): Promise<Connection>;
+}

package/dist/declarations/src/sol/ChainConnectorSolStub.d.ts

@@ -0,0 +1,8 @@
+import { Connection } from "@solana/web3.js";
+import { SolNetwork } from "@talismn/chaindata-provider";
+import { IChainConnectorSol } from "./IChainConnectorSol";
+export declare class ChainConnectorSolStub implements IChainConnectorSol {
+    #private;
+    constructor(network: SolNetwork);
+    getConnection(): Promise<Connection>;
+}

package/dist/declarations/src/sol/IChainConnectorSol.d.ts

@@ -0,0 +1,5 @@
+import { Connection } from "@solana/web3.js";
+import { SolNetworkId } from "@talismn/chaindata-provider";
+export interface IChainConnectorSol {
+    getConnection: (networkId: SolNetworkId) => Promise<Connection>;
+}

package/dist/declarations/src/sol/getSolConnection.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from "@solana/web3.js";
+import { SolNetworkId } from "@talismn/chaindata-provider";
+export declare const getSolConnection: (_networkId: SolNetworkId, _rpcs: string[]) => Connection;

package/dist/declarations/src/sol/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./IChainConnectorSol";
+export * from "./ChainConnectorSol";
+export * from "./ChainConnectorSolStub";

package/dist/talismn-chain-connectors.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";