@sentio/sdk 2.18.0 → 2.18.1-rc.10

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);
       }
     },
   };
@@ -843,6 +861,9 @@ export function getERC20ContractOnContext(
 ): ERC20BoundContractView {
   const view = getERC20Contract(context.getChainId(), address);
   const boundView = new ERC20BoundContractView(address, view);
-  boundView.context = context as any;
+  boundView.context = context;
+  if (boundView.callStatic) {
+    boundView.callStatic.context = context;
+  }
   return boundView;
 }

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

@@ -103,45 +103,50 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
   }
 
   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 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);
     }
   }
 
   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 balanceOf(who: string, overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("balanceOf(address)")(
         who,
         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);
     }
   }
 
@@ -150,6 +155,7 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
     spender: string,
     overrides?: Overrides
   ): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("allowance(address,address)")(
         owner,
@@ -157,7 +163,7 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -169,12 +175,13 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
       value: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("approve(address,uint256)")
           .staticCall(spender, value, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transferFrom(
@@ -183,12 +190,13 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
       value: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transferFrom(address,address,uint256)")
           .staticCall(from, to, value, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async transfer(
@@ -196,12 +204,13 @@ export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
       value: BigNumberish,
       overrides?: Overrides
     ): Promise<boolean> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transfer(address,uint256)")
           .staticCall(to, value, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
   };
@@ -508,6 +517,9 @@ export function getERC20BytesContractOnContext(
 ): ERC20BytesBoundContractView {
   const view = getERC20BytesContract(context.getChainId(), address);
   const boundView = new ERC20BytesBoundContractView(address, view);
-  boundView.context = context as any;
+  boundView.context = context;
+  if (boundView.callStatic) {
+    boundView.callStatic.context = context;
+  }
   return boundView;
 }

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

@@ -155,21 +155,23 @@ export class ERC721ContractView extends ContractView<ERC721> {
   }
 
   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);
     }
   }
 
   async balanceOf(owner: string, overrides?: Overrides): Promise<bigint> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("balanceOf(address)")(
         owner,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -177,13 +179,14 @@ export class ERC721ContractView extends ContractView<ERC721> {
     tokenId: BigNumberish,
     overrides?: Overrides
   ): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("getApproved(uint256)")(
         tokenId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -192,31 +195,34 @@ export class ERC721ContractView extends ContractView<ERC721> {
     operator: string,
     overrides?: Overrides
   ): Promise<boolean> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction(
         "isApprovedForAll(address,address)"
       )(owner, operator, 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 ownerOf(tokenId: BigNumberish, overrides?: Overrides): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("ownerOf(uint256)")(
         tokenId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -224,21 +230,23 @@ export class ERC721ContractView extends ContractView<ERC721> {
     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 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);
     }
   }
 
@@ -246,13 +254,14 @@ export class ERC721ContractView extends ContractView<ERC721> {
     tokenId: BigNumberish,
     overrides?: Overrides
   ): Promise<string> {
+    const stack = new Error().stack;
     try {
       return await this.contract.getFunction("tokenURI(uint256)")(
         tokenId,
         overrides || {}
       );
     } catch (e) {
-      throw transformEtherError(e, undefined);
+      throw transformEtherError(e, undefined, stack);
     }
   }
 
@@ -264,12 +273,13 @@ export class ERC721ContractView extends ContractView<ERC721> {
       tokenId: BigNumberish,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("approve(address,uint256)")
           .staticCall(to, tokenId, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async safeTransferFrom_address_address_uint256(
@@ -278,12 +288,13 @@ export class ERC721ContractView extends ContractView<ERC721> {
       tokenId: BigNumberish,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("safeTransferFrom(address,address,uint256)")
           .staticCall(from, to, tokenId, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async safeTransferFrom_address_address_uint256_bytes(
@@ -293,12 +304,13 @@ export class ERC721ContractView extends ContractView<ERC721> {
       data: BytesLike,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("safeTransferFrom(address,address,uint256,bytes)")
           .staticCall(from, to, tokenId, data, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
     async setApprovalForAll(
@@ -306,12 +318,13 @@ export class ERC721ContractView extends ContractView<ERC721> {
       _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);
       }
     },
     async transferFrom(
@@ -320,12 +333,13 @@ export class ERC721ContractView extends ContractView<ERC721> {
       tokenId: BigNumberish,
       overrides?: Overrides
     ): Promise<void> {
+      const stack = new Error().stack;
       try {
         return await this.contract
           .getFunction("transferFrom(address,address,uint256)")
           .staticCall(from, to, tokenId, overrides || {});
       } catch (e) {
-        throw transformEtherError(e, undefined);
+        throw transformEtherError(e, undefined, stack);
       }
     },
   };
@@ -777,6 +791,9 @@ export function getERC721ContractOnContext(
 ): ERC721BoundContractView {
   const view = getERC721Contract(context.getChainId(), address);
   const boundView = new ERC721BoundContractView(address, view);
-  boundView.context = context as any;
+  boundView.context = context;
+  if (boundView.callStatic) {
+    boundView.callStatic.context = context;
+  }
   return boundView;
 }