dequanto 0.2.33 → 0.2.35

package/lib/esm/rpc/RpcContract.mjs

@@ -32,18 +32,30 @@ export class RpcContract {
             throw err;
         }
     }
-    async batch(req) {
+    async batch(req, options) {
         let requests = await this.getCallRequestsRaw(req);
         try {
-            let responseArr = await this.client.batch(requests.map(x => x.methodRequest));
+            let responseArr = await this.client.batch(requests.map(x => x.methodRequest), options);
             return responseArr.map((resp, i) => {
                 let abi = requests[i].methodAbi;
                 if (abi == null) {
                     return resp;
                 }
-                let outputs = abi.outputs;
+                let returnABI = abi.outputs;
+                if (resp != null && typeof resp === 'object' && 'error' in resp) {
+                    let defaults = null;
+                    try {
+                        const defaultHex = $abiCoder.encode(returnABI, [null]);
+                        defaults = utils.deserializeOutput(defaultHex, returnABI);
+                    }
+                    catch (error) { }
+                    return {
+                        defaults,
+                        ...resp
+                    };
+                }
                 let hex = typeof resp === 'string' ? resp : resp.data;
-                let result = utils.deserializeOutput(hex, outputs);
+                let result = utils.deserializeOutput(hex, returnABI);
                 return result;
             });
         }

package/lib/types/clients/ClientPool.d.ts

@@ -132,7 +132,9 @@ export declare class WClient {
     sendTransaction(tx: any): PromiseEvent<TEth.TxReceipt>;
     sign(address: TEth.Address, message: string): Promise<string>;
     signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex>;
-    callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]>;
+    callBatched<TResult = any>(requests: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean;
+    }): Promise<TResult[]>;
     call<TResult extends PromiseLike<any>>(fn: (wClient: WClient) => TResult, options?: {
         batchRequestCount?: number;
     }): Promise<{

package/lib/types/clients/Web3BatchRequests.d.ts

@@ -16,6 +16,8 @@ export declare namespace Web3BatchRequests {
         private rpc;
         private requests;
         constructor(rpc: Rpc, requests: TRpc.IRpcAction[]);
-        execute(): Promise<any[]>;
+        execute(options?: {
+            allowErrors?: boolean;
+        }): Promise<any[]>;
     }
 }

package/lib/types/clients/Web3Client.d.ts

@@ -34,7 +34,9 @@ export declare abstract class Web3Client implements IWeb3Client {
     constructor(options: IWeb3ClientOptions);
     constructor(endpoints: IRpcConfig[]);
     request<TResult = any>(req: TRpc.IRpcAction): Promise<TResult>;
-    batch(requests: TRpc.IRpcAction[]): Promise<any[]>;
+    batch(requests: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean;
+    }): Promise<any[]>;
     getEventStream(address: TEth.Address, abi: TAbiItem[], event: string): ClientEventsStream<any>;
     with<TResult>(fn: (wClient: WClient) => Promise<TResult>): Promise<TResult>;
     getWeb3(options?: IPoolWeb3Request): Promise<void>;
@@ -44,7 +46,9 @@ export declare abstract class Web3Client implements IWeb3Client {
     subscribe(type: 'newHeads' | 'newBlockHeaders', callback?: (error: Error, blockHeader: TEth.Block) => void): Promise<RpcSubscription<TEth.Block>>;
     subscribe(type: 'newPendingTransactions' | 'pendingTransactions', callback?: (error: Error, transactionHash: TEth.Hex) => void): Promise<RpcSubscription<TEth.Hex>>;
     readContract(req: TRpcContractCall): Promise<any>;
-    readContractBatch(requests: TRpcContractCall[]): Promise<any[]>;
+    readContractBatch(requests: TRpcContractCall[], options?: {
+        allowErrors?: boolean;
+    }): Promise<any[]>;
     getBalance(address: TEth.Address, blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint>;
     getBalances(addresses: TEth.Address[], blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint[]>;
     getTransactionCount(address: TEth.Address, blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint>;

package/lib/types/contracts/ContractBase.d.ts

@@ -77,8 +77,8 @@ export declare abstract class ContractBase {
         value?: number | string | bigint;
     }, ...params: any[]): Promise<TxWriter>;
     protected $getAbiItem(type: 'event' | 'function' | 'string', name: string, argsCount?: number): TAbiItem;
-    protected $getAbiItemOverload(fnName: string, args: any[]): any;
-    protected $getAbiItemOverload(abis: (string | TAbiItem)[], args: any[]): any;
+    protected $getAbiItemOverload(fnName: string, args: any[]): TAbiItem;
+    protected $getAbiItemOverload(abis: (string | TAbiItem)[], args: any[]): TAbiItem;
     protected $extractLogs(tx: TEth.TxReceipt, abiItem: TAbiItem): ITxLogItem<{
         [name: string]: any;
     }, string>[];

package/lib/types/contracts/ContractReader.d.ts

@@ -87,5 +87,7 @@ export declare namespace ContractReaderUtils {
     type TIContractReadParamsInferredMany<T extends IContractReadParams[]> = {
         [P in keyof T]: T[P] extends IContractReadParams<infer P> ? P : never;
     };
-    function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[]): Promise<any[]>;
+    function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[], options?: {
+        allowErrors?: boolean;
+    }): Promise<any[]>;
 }

package/lib/types/rpc/RpcBase.d.ts

@@ -8,7 +8,9 @@ export declare abstract class RpcBase {
     };
     constructor(transportInfo?: TTransport.Options.Any);
     request<TResult = any>(req: TRpc.IRpcAction): Promise<TResult>;
-    batch(arr: TRpc.IRpcAction[]): Promise<any[]>;
+    batch(arr: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean;
+    }): Promise<any[]>;
     extend(rpcInfos: {
         name: string;
         call: string;

package/lib/types/rpc/RpcContract.d.ts

@@ -24,7 +24,9 @@ export declare class RpcContract {
     private defaults?;
     constructor(client: Web3Client, defaults?: TRpcContract);
     request(req: TRpcContractCall): Promise<any>;
-    batch(req: TRpcContractCall[]): Promise<any[]>;
+    batch(req: TRpcContractCall[], options?: {
+        allowErrors?: boolean;
+    }): Promise<any[]>;
     private getCallRequestsRaw;
     private getCallRequestRaw;
     static createCalldata(request: TRpcContractCall, options?: {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.2.33",
+    "version": "0.2.35",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"

package/src/clients/ClientPool.ts

@@ -911,7 +911,9 @@ export class WClient {
             .eth_signTypedData_v4(address, typedData);
     }
 
-    async callBatched<TResult = any>(requests: TRpc.IRpcAction[]): Promise<TResult[]> {
+    async callBatched<TResult = any>(requests: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean
+    }): Promise<TResult[]> {
         let total = requests.length;
         let spanLimit = this.getSpanLimit(requests.length);
         let output = [] as TResult[];
@@ -925,7 +927,7 @@ export class WClient {
             }
             let { status, error, result: pageResult } = await this.call(async (client) => {
                 let batch = new Web3BatchRequests.BatchRequest(client.rpc, page);
-                let results = await batch.execute();
+                let results = await batch.execute(options);
                 return results;
             });
             if (status === ClientStatus.Ok) {

package/src/clients/Web3BatchRequests.ts

@@ -38,13 +38,15 @@ export namespace Web3BatchRequests {
         constructor(private rpc: Rpc, private requests: TRpc.IRpcAction[]) {
         }
 
-        async execute(): Promise<any[]> {
+        async execute(options?: {
+            allowErrors?: boolean
+        }): Promise<any[]> {
             if (this.requests.length === 0) {
                 return [];
             }
 
             let rpc = this.rpc;
-            let response = await rpc.batch(this.requests);
+            let response = await rpc.batch(this.requests, options);
            return response;
         }
 

package/src/clients/Web3Client.ts

@@ -97,9 +97,11 @@ export abstract class Web3Client implements IWeb3Client {
         });
     }
 
-    async batch(requests: TRpc.IRpcAction[]): Promise<any[]> {
+    async batch(requests: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean
+    }): Promise<any[]> {
         return this.with (async web3 => {
-            return web3.callBatched(requests);
+            return web3.callBatched(requests, options);
         });
     }
 
@@ -187,9 +189,11 @@ export abstract class Web3Client implements IWeb3Client {
         return result;
     }
 
-    async readContractBatch(requests: TRpcContractCall[]) {
+    async readContractBatch(requests: TRpcContractCall[], options?: {
+        allowErrors?: boolean
+    }) {
         let reader = new RpcContract(this);
-        let result = await reader.batch(requests);
+        let result = await reader.batch(requests, options);
         return result;
     }
 

package/src/contracts/ContractBase.ts

@@ -65,7 +65,7 @@ export abstract class ContractBase {
         public client: Web3Client,
         public explorer: IBlockchainExplorer
     ) {
-        if ($is.Address(address) && $contract.store.has(address) === false) {
+        if ($is.Address(address) && address !== $address.ZERO && $contract.store.has(address) === false) {
             const Ctor = this.constructor as Constructor<ContractBase>;
             const cloned = new Ctor(null, null, null);
             const meta = {
@@ -388,13 +388,12 @@ export abstract class ContractBase {
         return ContractBaseUtils.$getAbiItem(this.abi, type, name, argsCount);
     }
 
-    protected $getAbiItemOverload(fnName: string, args: any[])
-    protected $getAbiItemOverload(abis: (string | TAbiItem)[], args: any[])
-    protected $getAbiItemOverload(mix: string | (string | TAbiItem)[], args: any[]) {
+    protected $getAbiItemOverload(fnName: string, args: any[]): TAbiItem
+    protected $getAbiItemOverload(abis: (string | TAbiItem)[], args: any[]): TAbiItem
+    protected $getAbiItemOverload(mix: string | (string | TAbiItem)[], args: any[]): TAbiItem {
         let abis = typeof mix === 'string'
             ? this.abi.filter(x => x.type === 'function' && x.name === mix)
             : mix;
-
         let $abis = abis
             .map(methodAbi => {
                 if (typeof methodAbi === 'string') {
@@ -643,9 +642,20 @@ function filterABIbyArguments(abis: TAbiItem[], args: any[], tupleCheck: 'shallo
             if (item.type === 'string' && typeof arg === 'string') {
                 continue;
             }
-            if (/^u?int/.test(item.type) && (typeof arg === 'number' || typeof arg === 'bigint')) {
+            if (item.type === 'bytes32' && $is.HexBytes32(arg)) {
+                continue;
+            }
+            if (item.type === 'bytes' && $is.HexBytes32(arg)) {
                 continue;
             }
+            if (/^u?int/.test(item.type)) {
+                if (typeof arg === 'number' || typeof arg === 'bigint') {
+                    continue;
+                }
+                if (typeof arg === 'string' && /^\d+$/.test(arg)) {
+                    continue;
+                }
+            }
             if (/tuple/.test(item.type)) {
                 arg ??= {};
                 if (tupleCheck === 'shallow') {
@@ -679,7 +689,6 @@ function filterABIbyArguments(abis: TAbiItem[], args: any[], tupleCheck: 'shallo
                     }
                     continue;
                 }
-
             }
             return false;
         }

package/src/contracts/ContractReader.ts

@@ -354,7 +354,9 @@ export namespace ContractReaderUtils {
 
     ;
 
-    export async function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[]) {
+    export async function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[], options?: {
+        allowErrors?: boolean
+    }) {
 
         let rpcRequests = await alot(requests).map(async request => {
             if (request == null) {
@@ -389,7 +391,7 @@ export namespace ContractReaderUtils {
             mapped[i] = idx;
         }
 
-        let outputs = await client.readContractBatch(rpcRequestsNotEmpty);
+        let outputs = await client.readContractBatch(rpcRequestsNotEmpty, options);
         return rpcRequests.map((_, i) => {
             return outputs[mapped[i]] ?? null;
         });

package/src/rpc/RpcBase.ts

@@ -39,7 +39,9 @@ export abstract class RpcBase {
         return this._deserialize(req.method, result);
     }
 
-    async batch (arr: TRpc.IRpcAction[]): Promise<any[]> {
+    async batch (arr: TRpc.IRpcAction[], options?: {
+        allowErrors?: boolean
+    }): Promise<any[]> {
         let body = arr.map(req => this._wrapBody(req));
         let resp = await this._transport.request(body);
         if (Array.isArray(resp) === false && arr.length === 1 && 'error' in resp === false && 'result' in resp === true) {
@@ -56,9 +58,14 @@ export abstract class RpcBase {
         return resp.map((resp, i) => {
             let req = arr[i];
             if ('error' in resp) {
+                if (options?.allowErrors) {
+                    return {
+                        error: new Error(resp.error.message),
+                        request: req
+                    };
+                }
                 throw new RpcError(resp.error, `BatchRequest ${i + 1}/${arr.length} (${req.method} ${JSON.stringify(req.params)})`);
             }
-
             let result = this._unwrapBody(resp);
             return this._deserialize(req.method, result);
         });

package/src/rpc/RpcContract.ts

@@ -63,20 +63,34 @@ export class RpcContract {
         }
     }
 
-    async batch (req: TRpcContractCall[]) {
+    async batch (req: TRpcContractCall[], options?: {
+        allowErrors?: boolean
+    }) {
 
         let requests = await this.getCallRequestsRaw(req);
         try {
-            let responseArr = await this.client.batch(requests.map(x => x.methodRequest));
+            let responseArr = await this.client.batch(requests.map(x => x.methodRequest), options);
 
             return responseArr.map((resp, i) => {
                 let abi = requests[i].methodAbi;
                 if (abi == null) {
                     return resp;
                 }
-                let outputs = abi.outputs;
+                let returnABI = abi.outputs;
+
+                if (resp != null && typeof resp === 'object' && 'error' in resp) {
+                    let defaults = null;
+                    try {
+                        const defaultHex = $abiCoder.encode(returnABI, [null]);
+                        defaults = utils.deserializeOutput(defaultHex, returnABI);
+                    } catch (error) {}
+                    return {
+                        defaults,
+                        ...resp
+                    };
+                }
                 let hex = typeof resp === 'string' ? resp : resp.data;
-                let result = utils.deserializeOutput(hex, outputs);
+                let result = utils.deserializeOutput(hex, returnABI);
                 return result;
             });