dequanto 0.2.33 → 0.2.34

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/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;
             });