@sentio/sdk 2.18.1-rc.8 → 2.18.1

package/src/eth/builtin/internal/eacaggregatorproxy-processor.ts

@@ -197,36 +197,40 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
   }
 
   async accessController(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("accessController()")(
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async aggregator(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("aggregator()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async decimals(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("decimals()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async description(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("description()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -234,13 +238,14 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
     _roundId: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("getAnswer(uint256)")(
         _roundId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -256,13 +261,14 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
       answeredInRound: bigint;
     }
   > {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("getRoundData(uint80)")(
         _roundId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -270,29 +276,32 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
     _roundId: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("getTimestamp(uint256)")(
         _roundId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async latestAnswer(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("latestAnswer()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async latestRound(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("latestRound()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -307,30 +316,33 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
       answeredInRound: bigint;
     }
   > {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("latestRoundData()")(
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async latestTimestamp(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("latestTimestamp()")(
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async owner(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("owner()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -338,31 +350,34 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
     arg0: BigNumberish,
     overrides?: Overrides
   ): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("phaseAggregators(uint16)")(
         arg0,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async phaseId(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("phaseId()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async proposedAggregator(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("proposedAggregator()")(
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -378,13 +393,14 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
       answeredInRound: bigint;
     }
   > {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("proposedGetRoundData(uint80)")(
         _roundId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -399,20 +415,22 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
       answeredInRound: bigint;
     }
   > {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("proposedLatestRoundData()")(
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async version(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("version()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -420,57 +438,62 @@ export class EACAggregatorProxyContractView extends ContractView<EACAggregatorPr
     contract: this.contract,
 
     async acceptOwnership(overrides?: Overrides): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("acceptOwnership()")
           .staticCall(overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async confirmAggregator(
       _aggregator: string,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("confirmAggregator(address)")
           .staticCall(_aggregator, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async proposeAggregator(
       _aggregator: string,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("proposeAggregator(address)")
           .staticCall(_aggregator, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async setController(
       _accessController: string,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("setController(address)")
           .staticCall(_accessController, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transferOwnership(_to: string, overrides?: Overrides): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transferOwnership(address)")
           .staticCall(_to, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
   };

package/src/eth/builtin/internal/erc1155-processor.ts

@@ -129,6 +129,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
     id: BigNumberish,
     overrides?: Overrides
   ): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("balanceOf(address,uint256)")(
         account,
@@ -136,7 +137,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -145,12 +146,13 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
     ids: BigNumberish[],
     overrides?: Overrides
   ): Promise<bigint[]> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction(
         "balanceOfBatch(address[],uint256[])"
       )(accounts, ids, overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -159,12 +161,13 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
     operator: string,
     overrides?: Overrides
   ): Promise<boolean> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction(
         "isApprovedForAll(address,address)"
       )(account, operator, overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -172,24 +175,26 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
     interfaceId: BytesLike,
     overrides?: Overrides
   ): Promise<boolean> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("supportsInterface(bytes4)")(
         interfaceId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async uri(id: BigNumberish, overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("uri(uint256)")(
         id,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -204,6 +209,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
       data: BytesLike,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction(
@@ -211,7 +217,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
           )
           .staticCall(from, to, ids, amounts, data, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async safeTransferFrom(
@@ -222,6 +228,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
       data: BytesLike,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction(
@@ -229,7 +236,7 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
           )
           .staticCall(from, to, id, amount, data, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async setApprovalForAll(
@@ -237,12 +244,13 @@ export class ERC1155ContractView extends ContractView<ERC1155> {
       approved: boolean,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("setApprovalForAll(address,bool)")
           .staticCall(operator, approved, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
   };

package/src/eth/builtin/internal/erc20-processor.ts

@@ -175,6 +175,7 @@ export class ERC20ContractView extends ContractView<ERC20> {
     spender: string,
     overrides?: Overrides
   ): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("allowance(address,address)")(
         owner,
@@ -182,66 +183,73 @@ export class ERC20ContractView extends ContractView<ERC20> {
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async balanceOf(account: string, overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("balanceOf(address)")(
         account,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async decimals(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("decimals()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async locker(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("locker()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async name(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("name()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async owner(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("owner()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async symbol(overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("symbol()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
   async totalSupply(overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("totalSupply()")(overrides || {});
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -253,21 +261,23 @@ export class ERC20ContractView extends ContractView<ERC20> {
       amount: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("approve(address,uint256)")
           .staticCall(spender, amount, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async burn(amount: BigNumberish, overrides?: Overrides): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("burn(uint256)")
           .staticCall(amount, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async burnFrom(
@@ -275,12 +285,13 @@ export class ERC20ContractView extends ContractView<ERC20> {
       amount: BigNumberish,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("burnFrom(address,uint256)")
           .staticCall(account, amount, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async decreaseAllowance(
@@ -288,12 +299,13 @@ export class ERC20ContractView extends ContractView<ERC20> {
       subtractedValue: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("decreaseAllowance(address,uint256)")
           .staticCall(spender, subtractedValue, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async increaseAllowance(
@@ -301,30 +313,33 @@ export class ERC20ContractView extends ContractView<ERC20> {
       addedValue: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("increaseAllowance(address,uint256)")
           .staticCall(spender, addedValue, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async renounceOwnership(overrides?: Overrides): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("renounceOwnership()")
           .staticCall(overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async setLocker(_locker: string, overrides?: Overrides): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("setLocker(address)")
           .staticCall(_locker, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transfer(
@@ -332,12 +347,13 @@ export class ERC20ContractView extends ContractView<ERC20> {
       amount: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transfer(address,uint256)")
           .staticCall(recipient, amount, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transferFrom(
@@ -346,24 +362,26 @@ export class ERC20ContractView extends ContractView<ERC20> {
       amount: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transferFrom(address,address,uint256)")
           .staticCall(sender, recipient, amount, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transferOwnership(
       newOwner: string,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transferOwnership(address)")
           .staticCall(newOwner, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
   };