dequanto 0.2.50 → 0.2.52

package/src/prebuilt/weth/WETH/WETH.ts

@@ -3,28 +3,28 @@
  *  Implementation: https://etherscan.io/address/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2#code
  */
 import di from 'a-di';
-import { TAddress } from '@dequanto/models/TAddress';
-import { TAccount } from '@dequanto/models/TAccount';
-import { TBufferLike } from '@dequanto/models/TBufferLike';
-import { ClientEventsStream, TClientEventsStreamData } from '@dequanto/clients/ClientEventsStream';
-import { ContractBase } from '@dequanto/contracts/ContractBase';
-import { ContractBaseUtils } from '@dequanto/contracts/utils/ContractBaseUtils';
-import { ContractStorageReaderBase } from '@dequanto/contracts/ContractStorageReaderBase';
-import { TxWriter } from '@dequanto/txs/TxWriter';
-import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
-import { Web3Client } from '@dequanto/clients/Web3Client';
-import { IBlockchainExplorer } from '@dequanto/explorer/IBlockchainExplorer';
-import { SubjectStream } from '@dequanto/class/SubjectStream';
-
-
-import type { ContractWriter } from '@dequanto/contracts/ContractWriter';
-import type { TAbiItem } from '@dequanto/types/TAbi';
-import type { TEth } from '@dequanto/models/TEth';
-import type { TOverrideReturns } from '@dequanto/utils/types';
-
-
-import { Etherscan } from '@dequanto/explorer/Etherscan'
-import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'
+import { TAddress } from 'dequanto/models/TAddress';
+import { TAccount } from 'dequanto/models/TAccount';
+import { TBufferLike } from 'dequanto/models/TBufferLike';
+import { ClientEventsStream, TClientEventsStreamData } from 'dequanto/clients/ClientEventsStream';
+import { ContractBase } from 'dequanto/contracts/ContractBase';
+import { ContractBaseUtils } from 'dequanto/contracts/utils/ContractBaseUtils';
+import { ContractStorageReaderBase } from 'dequanto/contracts/ContractStorageReaderBase';
+import { TxWriter } from 'dequanto/txs/TxWriter';
+import { ITxLogItem } from 'dequanto/txs/receipt/ITxLogItem';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { IBlockchainExplorer } from 'dequanto/explorer/IBlockchainExplorer';
+import { SubjectStream } from 'dequanto/class/SubjectStream';
+
+
+import type { ContractWriter } from 'dequanto/contracts/ContractWriter';
+import type { TAbiItem } from 'dequanto/types/TAbi';
+import type { TEth } from 'dequanto/models/TEth';
+import type { TOverrideReturns } from 'dequanto/utils/types';
+
+
+import { Etherscan } from 'dequanto/explorer/Etherscan'
+import { EthWeb3Client } from 'dequanto/clients/EthWeb3Client'
 
 
 

package/src/prebuilt-factories/TimelockControllerFactory.ts

@@ -3,28 +3,28 @@
  *  Implementation: https://etherscan.io/address/undefined#code
  */
 import di from 'a-di';
-import { TAddress } from '@dequanto/models/TAddress';
-import { TAccount } from '@dequanto/models/TAccount';
-import { TBufferLike } from '@dequanto/models/TBufferLike';
-import { ClientEventsStream, TClientEventsStreamData } from '@dequanto/clients/ClientEventsStream';
-import { ContractBase } from '@dequanto/contracts/ContractBase';
-import { ContractBaseUtils } from '@dequanto/contracts/utils/ContractBaseUtils';
-import { ContractStorageReaderBase } from '@dequanto/contracts/ContractStorageReaderBase';
-import { TxWriter } from '@dequanto/txs/TxWriter';
-import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
-import { Web3Client } from '@dequanto/clients/Web3Client';
-import { IBlockchainExplorer } from '@dequanto/explorer/IBlockchainExplorer';
-import { SubjectStream } from '@dequanto/class/SubjectStream';
-
-
-import type { ContractWriter } from '@dequanto/contracts/ContractWriter';
-import type { TAbiItem } from '@dequanto/types/TAbi';
-import type { TEth } from '@dequanto/models/TEth';
-import type { TOverrideReturns } from '@dequanto/utils/types';
-
-
-import { Etherscan } from '@dequanto/explorer/Etherscan'
-import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'
+import { TAddress } from 'dequanto/models/TAddress';
+import { TAccount } from 'dequanto/models/TAccount';
+import { TBufferLike } from 'dequanto/models/TBufferLike';
+import { ClientEventsStream, TClientEventsStreamData } from 'dequanto/clients/ClientEventsStream';
+import { ContractBase } from 'dequanto/contracts/ContractBase';
+import { ContractBaseUtils } from 'dequanto/contracts/utils/ContractBaseUtils';
+import { ContractStorageReaderBase } from 'dequanto/contracts/ContractStorageReaderBase';
+import { TxWriter } from 'dequanto/txs/TxWriter';
+import { ITxLogItem } from 'dequanto/txs/receipt/ITxLogItem';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { IBlockchainExplorer } from 'dequanto/explorer/IBlockchainExplorer';
+import { SubjectStream } from 'dequanto/class/SubjectStream';
+
+
+import type { ContractWriter } from 'dequanto/contracts/ContractWriter';
+import type { TAbiItem } from 'dequanto/types/TAbi';
+import type { TEth } from 'dequanto/models/TEth';
+import type { TOverrideReturns } from 'dequanto/utils/types';
+
+
+import { Etherscan } from 'dequanto/explorer/Etherscan'
+import { EthWeb3Client } from 'dequanto/clients/EthWeb3Client'
 
 import type { TimelockController as TimelockControllerType } from '../prebuilt/openzeppelin/TimelockController';
 

package/src/rpc/$rpc.ts

@@ -1,7 +1,7 @@
 import type { Rpc } from './Rpc';
-import { $promise } from '@dequanto/utils/$promise';
-import { TEth } from '@dequanto/models/TEth';
-import { $require } from '@dequanto/utils/$require';
+import { $promise } from 'dequanto/utils/$promise';
+import { TEth } from 'dequanto/models/TEth';
+import { $require } from 'dequanto/utils/$require';
 import { TTransport } from './transports/ITransport';
 
 

package/src/rpc/Rpc.ts

@@ -1,10 +1,10 @@
 /** Autogenerated with "atma act ./actions/rpc.act.ts" */
 
-import { DataLike } from '@dequanto/utils/types';
-import { TEth } from '@dequanto/models/TEth';
-import { RpcBase } from '@dequanto/rpc/RpcBase';
-import { RpcSubscription, RpcLogFilterOptions } from '@dequanto/rpc/RpcSubscription';
-//import { RpcHandler, RpcTransport } from '@dequanto/rpc/RpcHandler';
+import { DataLike } from 'dequanto/utils/types';
+import { TEth } from 'dequanto/models/TEth';
+import { RpcBase } from 'dequanto/rpc/RpcBase';
+import { RpcSubscription, RpcLogFilterOptions } from 'dequanto/rpc/RpcSubscription';
+//import { RpcHandler, RpcTransport } from 'dequanto/rpc/RpcHandler';
 export class Rpc extends RpcBase {
 
 /**

package/src/rpc/RpcBase.ts

@@ -1,17 +1,18 @@
 import { RpcTransport } from './transports/RpcTransport';
 import { RpcError } from './RpcError';
-import { TTransport } from './transports/ITransport';
+import { getRpcRequestTimeout, rpcRequestWithTimeout, TTransport } from './transports/ITransport';
 import { RpcSubscription } from './RpcSubscription';
 import { $rpc } from './$rpc';
 import { RpcFunction } from './RpcFunction';
-import { $array } from '@dequanto/utils/$array';
-import { $hex } from '@dequanto/utils/$hex';
+import { $array } from 'dequanto/utils/$array';
+import { $hex } from 'dequanto/utils/$hex';
 
 let ID = 0;
 
 export abstract class RpcBase {
 
     protected _transport: TTransport.Transport;
+    private requestTimeout: number;
 
     public fns = {} as {
         [name: string]: (...params) => Promise<any>
@@ -19,11 +20,12 @@ export abstract class RpcBase {
 
     constructor (protected transportInfo?: TTransport.Options.Any) {
         this._transport = RpcTransport.create(this.transportInfo);
+        this.requestTimeout = getRpcRequestTimeout(this.transportInfo);
     }
 
     async request <TResult = any> (req: TRpc.IRpcAction): Promise<TResult> {
         let body = this._wrapBody(req);
-        let resp = await this._transport.request(body);
+        let resp = await this.requestWithTimeout(this._transport.request(body), req.method);
         if ('error' in resp) {
             let params = { ...(req.params ?? {}) };
             for (let key in params) {
@@ -43,7 +45,7 @@ export abstract class RpcBase {
         allowErrors?: boolean
     }): Promise<any[]> {
         let body = arr.map(req => this._wrapBody(req));
-        let resp = await this._transport.request(body);
+        let resp = await this.requestWithTimeout(this._transport.request(body), `batch (${arr.length})`);
         if (Array.isArray(resp) === false && arr.length === 1 && 'error' in resp === false && 'result' in resp === true) {
             // Some RPCs return a single response instead of an array for one RpcAction in a batch
             resp = [ resp ];
@@ -90,7 +92,7 @@ export abstract class RpcBase {
 
     protected async subscribe <TReturn = any> (req: TRpc.IRpcAction): Promise<RpcSubscription<TReturn>> {
         let body = this._wrapBody(req);
-        let subscription = await this._transport.subscribe<TReturn>(body);
+        let subscription = await this.requestWithTimeout(this._transport.subscribe<TReturn>(body), req.method);
 
 
         let mapped = RpcSubscription.createMapping(subscription, this._transport, x => this._deserialize(`${req.method}.${req.params[0]}`, x))
@@ -124,6 +126,9 @@ export abstract class RpcBase {
     private _unwrapBody (resp: any): any {
         return RpcBase.unwrapBody(resp);
     }
+    private requestWithTimeout<T> (promise: PromiseLike<T>, method: string): Promise<T> {
+        return rpcRequestWithTimeout(promise, this.requestTimeout, `${this._transport.id ?? 'RPC'}: ${method}`);
+    }
     private _deserialize (method: string, result: any) {
         let { methods, schemas } = this.returnSchemas;
         let schema = methods[method];

package/src/rpc/RpcContract.ts

@@ -2,19 +2,19 @@ import di from 'a-di';
 import alot from 'alot';
 import { Rpc, RpcTypes } from './Rpc';
 
-import { TAbiItem } from '@dequanto/types/TAbi';
-import { TAddress } from '@dequanto/models/TAddress';
-import { $require } from '@dequanto/utils/$require';
-import { $abiUtils } from '@dequanto/utils/$abiUtils';
-import { $abiCoder } from '@dequanto/abi/$abiCoder';
-import { $abi } from '@dequanto/abi/$abi';
+import { TAbiItem } from 'dequanto/types/TAbi';
+import { TAddress } from 'dequanto/models/TAddress';
+import { $require } from 'dequanto/utils/$require';
+import { $abiUtils } from 'dequanto/utils/$abiUtils';
+import { $abiCoder } from 'dequanto/abi/$abiCoder';
+import { $abi } from 'dequanto/abi/$abi';
 import { RpcError } from './RpcError';
-import { $hex } from '@dequanto/utils/$hex';
-import { TEth } from '@dequanto/models/TEth';
-import { DataLike } from '@dequanto/utils/types';
-import { $web3Abi } from '@dequanto/clients/utils/$web3Abi';
-import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
-import type { Web3Client } from '@dequanto/clients/Web3Client';
+import { $hex } from 'dequanto/utils/$hex';
+import { TEth } from 'dequanto/models/TEth';
+import { DataLike } from 'dequanto/utils/types';
+import { $web3Abi } from 'dequanto/clients/utils/$web3Abi';
+import { BlockDateResolver } from 'dequanto/blocks/BlockDateResolver';
+import type { Web3Client } from 'dequanto/clients/Web3Client';
 
 
 type TRpcContract = {
@@ -34,6 +34,7 @@ type TRpcContractCallBase = {
     value?: bigint
     from?: TAddress
     blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash> | Date
+    options?
 }
 
 export type TRpcContractCall = (TRpcContractCallBase & Pick<TRpcContractCallBase, 'method' | 'params'>)

package/src/rpc/RpcError.ts

@@ -1,6 +1,6 @@
-import { $array } from '@dequanto/utils/$array';
+import { $array } from 'dequanto/utils/$array';
 import { TTransport } from './transports/ITransport';
-import { TEth } from '@dequanto/models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 
 export class RpcError extends Error {
     code: number

package/src/rpc/RpcModelMiddleware.ts

@@ -1,4 +1,4 @@
-import { $require } from '@dequanto/utils/$require';
+import { $require } from 'dequanto/utils/$require';
 import { RpcError } from './RpcError';
 import { RpcSubscription } from './RpcSubscription';
 

package/src/rpc/RpcSubscription.ts

@@ -1,5 +1,5 @@
-import { SubjectStream } from '@dequanto/class/SubjectStream';
-import { TEth } from '@dequanto/models/TEth';
+import { SubjectStream } from 'dequanto/class/SubjectStream';
+import { TEth } from 'dequanto/models/TEth';
 import { TTransport } from './transports/ITransport';
 import { class_EventEmitter } from 'atma-utils';
 
@@ -7,7 +7,7 @@ export class RpcSubscription<T> extends SubjectStream<T> implements TTransport.S
 
     private _emitter: class_EventEmitter
 
-    constructor (public id: number, public transport: TTransport.Transport,  mapper?: (value) => T) {
+    constructor (public id: TTransport.SubscriptionId, public transport: TTransport.Transport,  mapper?: (value) => T) {
         super();
         this._mapper = mapper;
     }

package/src/rpc/transports/DeferredTransport.ts

@@ -17,7 +17,7 @@ export class DeferredTransport implements TTransport.Transport {
         const inner = await this.getInner();
         return inner.subscribe(req);
     }
-    async unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [number]; }): Promise<TTransport.Subscription<any>> {
+    async unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [TTransport.SubscriptionId]; }): Promise<TTransport.Subscription<any>> {
         const inner = await this.getInner();
         return inner.unsubscribe(req);
     }

package/src/rpc/transports/HttpTransport.ts

@@ -1,6 +1,6 @@
 import { $rpc } from '../$rpc';
 import { RpcSubscription } from '../RpcSubscription';
-import { RequestError, TTransport } from './ITransport';
+import { getRpcRequestTimeout, RequestError, rpcRequestWithTimeout, TTransport } from './ITransport';
 
 export class HttpTransport implements TTransport.Transport {
 
@@ -12,6 +12,9 @@ export class HttpTransport implements TTransport.Transport {
 
 
     async request (req: TTransport.Request | TTransport.Request[]) {
+        let controller: AbortController;
+        let externalSignal = this.options.signal;
+        let onExternalAbort: () => void;
         try {
             let body = JSON.stringify(req);
             let headers = {
@@ -23,11 +26,36 @@ export class HttpTransport implements TTransport.Transport {
                     headers[key] = await headers[key]({ body });
                 }
             }
-            let resp = await fetch(this.options.url, {
+            let {
+                url,
+                // Remove fields from options to have cleaner featchOptions
+                headers: _,
+                timeout: __,
+                signal: ___,
+                ...fetchOptions
+            } = this.options;
+            controller = new AbortController();
+            if (externalSignal != null) {
+                onExternalAbort = () => controller.abort(externalSignal.reason);
+                if (externalSignal.aborted) {
+                    onExternalAbort();
+                } else {
+                    externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+                }
+            }
+            let responsePromise = fetch(url, {
+                ...fetchOptions,
                 method: 'POST',
                 body,
                 headers,
+                signal: controller.signal,
             });
+            let resp = await rpcRequestWithTimeout(
+                responsePromise,
+                getRpcRequestTimeout(this.options),
+                `${url}: HTTP`,
+                () => controller.abort()
+            );
             let data = /json/.test(resp.headers.get('Content-Type'))
                 ? await resp.json()
                 : await resp.text();
@@ -42,13 +70,17 @@ export class HttpTransport implements TTransport.Transport {
             return data;
         } catch (error) {
             return $rpc.createConnectionErrorResponse(error, this.options);
+        } finally {
+            if (externalSignal != null && onExternalAbort != null) {
+                externalSignal.removeEventListener('abort', onExternalAbort);
+            }
         }
     }
 
     async subscribe(req: TTransport.Request): Promise<RpcSubscription<any>> {
         throw new Error(`(subscribe) Polling is not implemented for HttpTransport`);
     }
-    unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [number]; }): Promise<TTransport.Subscription<any>> {
+    unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [TTransport.SubscriptionId]; }): Promise<TTransport.Subscription<any>> {
         throw new Error(`(unsubscribe) Polling is not implemented for HttpTransport`);
     }
 }

package/src/rpc/transports/ITransport.ts

@@ -1,5 +1,5 @@
-import type { IWeb3EndpointOptions } from '@dequanto/clients/interfaces/IWeb3EndpointOptions';
-import type { TEth } from '@dequanto/models/TEth';
+import type { IWeb3EndpointOptions } from 'dequanto/clients/interfaces/IWeb3EndpointOptions';
+import type { TEth } from 'dequanto/models/TEth';
 import type { ClientOptions } from 'ws'
 import { IEip1193Provider } from './compatibility/EIP1193Transport';
 
@@ -12,7 +12,7 @@ export namespace TTransport {
         request (req: Request): Promise<Response>
 
         subscribe <TResult = any> (req: Request): Promise<Subscription<TResult>>
-        unsubscribe (req: Request & { method: 'eth_unsubscribe', params: [number] }): Promise<Subscription<any>>
+        unsubscribe (req: Request & { method: 'eth_unsubscribe', params: [SubscriptionId] }): Promise<Subscription<any>>
     }
 
     export type Request = {
@@ -33,25 +33,32 @@ export namespace TTransport {
     }
 
     export interface Subscription <T> {
-        id: number
+        id: SubscriptionId
         unsubscribe(cb?: Function): void | Promise<boolean>
         subscribe (cb: (x: T) => void, onError?: (x: Error | any) => void, once?): any
     }
 
+    export type SubscriptionId = string | number;
+
     export namespace Options {
 
+        export type Timeout = {
+            /** Maximum time for an RPC request in milliseconds. Set to 0 to disable. */
+            timeout?: number
+        }
+
         export type Any = string | Http | Ws | Wrapped | Transport | Web3Wrapper | IEip1193Provider;
 
         export type Http = {
             url: string
         } & Omit<Parameters<typeof fetch>[1], 'headers'> & {
             headers?: Record<string, string | ((req) => Promise<string>)>
-        };
+        } & Timeout;
 
         export type Ws = {
             url: string
             clientConfig?: ClientOptions
-        }
+        } & Timeout
 
         export type Wrapped = {
             transport: Transport
@@ -64,6 +71,65 @@ export namespace TTransport {
 }
 
 
+export const DEFAULT_RPC_REQUEST_TIMEOUT = 3 * 60 * 1000;
+
+export class RpcRequestTimeoutError extends Error {
+    override name = 'RpcRequestTimeoutError';
+    code = 1006;
+    reason = 'connection failed';
+
+    constructor(public timeout: number, context?: string) {
+        super(`RPC request timed out after ${timeout}ms${context ? ` (${context})` : ''}`);
+    }
+}
+
+export function getRpcRequestTimeout(options?: unknown): number {
+    if (options != null && typeof options === 'object' && 'timeout' in options) {
+        let timeout = Number((options as TTransport.Options.Timeout).timeout);
+        if (Number.isFinite(timeout) && timeout >= 0) {
+            return timeout;
+        }
+    }
+    return DEFAULT_RPC_REQUEST_TIMEOUT;
+}
+
+export function rpcRequestWithTimeout<T>(promise: PromiseLike<T>, timeout: number, context?: string, onTimeout?: () => void): Promise<T> {
+    if (timeout === 0 || Number.isFinite(timeout) === false) {
+        return Promise.resolve(promise);
+    }
+    return new Promise<T>((resolve, reject) => {
+        let completed = false;
+        let timer = setTimeout(() => {
+            if (completed) {
+                return;
+            }
+            completed = true;
+            onTimeout?.();
+            reject(new RpcRequestTimeoutError(timeout, context));
+        }, timeout);
+
+        Promise.resolve(promise).then(
+            result => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                clearTimeout(timer);
+                resolve(result);
+            },
+            error => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                clearTimeout(timer);
+                reject(error);
+            }
+        );
+    });
+}
+
+
 export class RequestError extends Error {
     override name = 'RequestError'
 

package/src/rpc/transports/MessageBasedTransport.ts

@@ -1,16 +1,19 @@
 import memd from 'memd';
-import { TTransport } from './ITransport';
+import { getRpcRequestTimeout, RpcRequestTimeoutError, TTransport } from './ITransport';
 import { class_Dfr, class_EventEmitter } from 'atma-utils';
 import { RpcSubscription } from '../RpcSubscription';
 import { RpcError } from '../RpcError';
-import { $require } from '@dequanto/utils/$require';
+import { $require } from 'dequanto/utils/$require';
 import { $rpc } from '../$rpc';
-import { l } from '@dequanto/utils/$logger';
+import { l } from 'dequanto/utils/$logger';
 
 export abstract class MessageBasedTransport extends class_EventEmitter implements TTransport.Transport {
 
-    protected requests = new Map() as Map<string, class_Dfr<TTransport.Response | TTransport.Response[]>>;
-    protected subscriptions = new Map() as Map<number, {
+    protected requests = new Map() as Map<string, {
+        deferred: class_Dfr<TTransport.Response | TTransport.Response[]>
+        timeout: ReturnType<typeof setTimeout>
+    }>;
+    protected subscriptions = new Map() as Map<TTransport.SubscriptionId, {
         method: string
         params: any[]
         subscription: RpcSubscription<any>
@@ -19,7 +22,7 @@ export abstract class MessageBasedTransport extends class_EventEmitter implement
 
     protected abstract send(message: string): Promise<void>;
 
-    constructor (protected optionsBase?: { url }) {
+    constructor (protected optionsBase?: { url, timeout? }) {
         super();
 
     }
@@ -30,15 +33,13 @@ export abstract class MessageBasedTransport extends class_EventEmitter implement
     request (req: TTransport.Request | TTransport.Request[]): Promise<TTransport.Response | TTransport.Response[]> {
         let dfr = new class_Dfr<TTransport.Response>();
 
-        if (Array.isArray(req)) {
-            let id = req.map(x => x.id).join('-');
-            this.requests.set(id, dfr);
-        } else {
-            this.requests.set(String(req.id), dfr);
-        }
-
+        let id = Array.isArray(req)
+            ? req.map(x => x.id).join('-')
+            : String(req.id);
+        this.addRequest(id, dfr);
 
         this.send(JSON.stringify(req)).catch(error => {
+            this.deleteRequest(id);
             dfr.resolve($rpc.createConnectionErrorResponse(error, this.optionsBase));
         });
 
@@ -65,7 +66,7 @@ export abstract class MessageBasedTransport extends class_EventEmitter implement
         return subscription;
     }
 
-    async unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe', params: [number] }) {
+    async unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe', params: [TTransport.SubscriptionId] }) {
         let [ id ] = req.params
         let { params, method, subscription } = this.subscriptions.get(id) ?? {};
 
@@ -103,24 +104,48 @@ export abstract class MessageBasedTransport extends class_EventEmitter implement
                 let keys = Array.from(this.requests.keys());
                 for (let i = 0; i < keys.length; i++) {
                     let key = keys[i];
-                    let dfr = this.requests.get(key);
-                    if (dfr != null) {
-                        dfr.resolve(json);
+                    let entry = this.deleteRequest(key);
+                    if (entry != null) {
+                        entry.deferred.resolve(json);
                     }
-                    this.requests.delete(key);
                 }
                 return;
             }
             l`RPC MessageBasedTransport: No ID for message: ${message}`;
         }
 
-        let dfr = this.requests.get(id);
-        if (dfr == null) {
+        let entry = this.deleteRequest(id);
+        if (entry == null) {
             return;
         }
+        entry.deferred.resolve(json);
+    }
 
+    private addRequest(id: string, deferred: class_Dfr<TTransport.Response | TTransport.Response[]>) {
+        let timeoutMs = getRpcRequestTimeout(this.optionsBase);
+        let timeout = timeoutMs === 0
+            ? null
+            : setTimeout(() => {
+                let entry = this.deleteRequest(id);
+                if (entry == null) {
+                    return;
+                }
+                let error = new RpcRequestTimeoutError(timeoutMs, `${this.optionsBase?.url ?? 'WebSocket'}: RPC`);
+                entry.deferred.resolve($rpc.createConnectionErrorResponse(error, this.optionsBase));
+            }, timeoutMs);
+        this.requests.set(id, { deferred, timeout });
+    }
+
+    private deleteRequest(id: string) {
+        let entry = this.requests.get(id);
+        if (entry == null) {
+            return null;
+        }
         this.requests.delete(id);
-        dfr.resolve(json);
+        if (entry.timeout != null) {
+            clearTimeout(entry.timeout);
+        }
+        return entry;
     }
 }
 

package/src/rpc/transports/RpcTransport.ts

@@ -1,10 +1,10 @@
-import { $require } from '@dequanto/utils/$require';
+import { $require } from 'dequanto/utils/$require';
 import { HttpTransport } from './HttpTransport';
 import { WsTransport } from './WsTransport';
 import { TTransport } from './ITransport';
 import { EIP1193Transport, IEip1193Provider } from './compatibility/EIP1193Transport';
 import { Web3Transport } from './compatibility/Web3Transport';
-import { $is } from '@dequanto/utils/$is';
+import { $is } from 'dequanto/utils/$is';
 import { DeferredTransport } from './DeferredTransport';
 
 export namespace RpcTransport {
@@ -67,7 +67,12 @@ export namespace RpcTransport {
         return typeof (mix as any).url === 'string';
     }
     function isEIP1193Compatible (mix: any): mix is IEip1193Provider  {
-        return typeof (mix as any).sendAsync === 'function';
+        if (typeof mix?.sendAsync === 'function') {
+            return true;
+        }
+        return typeof mix?.request === 'function'
+            && typeof mix?.on === 'function'
+            && typeof mix?.removeListener === 'function';
     }
     function isTransport (mix: TTransport.Options.Any): mix is TTransport.Transport  {
         return typeof (mix as any).request === 'function';

package/src/rpc/transports/WsTransport.ts

@@ -11,7 +11,7 @@ export class WsTransport  implements TTransport.Transport {
 
     constructor(private options: TTransport.Options.Ws) {
         this.id = this.options.url;
-        this.ws = WsTransportSingleton.create(this.options.url, {});
+        this.ws = WsTransportSingleton.create(this.options.url, this.options);
     }
 
     async request (req: TTransport.Request)
@@ -23,7 +23,7 @@ export class WsTransport  implements TTransport.Transport {
         return this.ws.subscribe<TResult>(req);
     }
 
-    async unsubscribe (req: TTransport.Request & { method: 'eth_unsubscribe', params: [number] }) {
+    async unsubscribe (req: TTransport.Request & { method: 'eth_unsubscribe', params: [TTransport.SubscriptionId] }) {
         return this.ws.unsubscribe(req);
     }
 }

package/src/rpc/transports/WsTransportIsomorphic.ts

@@ -1,4 +1,4 @@
-import { $dependency } from '@dequanto/utils/$dependency';
+import { $dependency } from 'dequanto/utils/$dependency';
 
 declare var MozWebSocket;
 declare var window;