hermes-swap 0.0.21 → 0.0.23

package/dist/esm/abis/quoter.js

@@ -62,7 +62,7 @@ var QuoterAbi = [{
     type: 'uint256[][]',
     internalType: 'uint256[][]'
   }],
-  stateMutability: 'view'
+  stateMutability: 'nonpayable'
 }, {
   type: 'function',
   name: 'contractList',
@@ -128,7 +128,7 @@ var QuoterAbi = [{
     type: 'bool',
     internalType: 'bool'
   }],
-  stateMutability: 'view'
+  stateMutability: 'nonpayable'
 }, {
   type: 'function',
   name: 'isWhitelist',
@@ -181,7 +181,7 @@ var QuoterAbi = [{
     type: 'uint256[]',
     internalType: 'uint256[]'
   }],
-  stateMutability: 'view'
+  stateMutability: 'nonpayable'
 }, {
   type: 'function',
   name: 'owner',
@@ -230,47 +230,42 @@ var QuoterAbi = [{
     type: 'uint256',
     internalType: 'uint256'
   }],
-  stateMutability: 'view'
+  stateMutability: 'nonpayable'
 }, {
   type: 'function',
   name: 'quoteBridge',
   inputs: [{
-    name: 'bridgeParams',
+    name: 'bridgeParam',
     type: 'tuple',
-    internalType: 'struct BridgeParams',
+    internalType: 'struct BridgeParam',
     components: [{
       name: 'bridge',
       type: 'string',
       internalType: 'string'
     }, {
-      name: 'bridgeParam',
-      type: 'tuple',
-      internalType: 'struct BridgeParam',
-      components: [{
-        name: 'token',
-        type: 'address',
-        internalType: 'address'
-      }, {
-        name: 'amount',
-        type: 'uint256',
-        internalType: 'uint256'
-      }, {
-        name: 'bridgeAddress',
-        type: 'address',
-        internalType: 'address'
-      }, {
-        name: 'refundAddress',
-        type: 'address',
-        internalType: 'address'
-      }, {
-        name: 'destinationChain',
-        type: 'string',
-        internalType: 'string'
-      }, {
-        name: 'adapterParams',
-        type: 'bytes',
-        internalType: 'bytes'
-      }]
+      name: 'token',
+      type: 'address',
+      internalType: 'address'
+    }, {
+      name: 'amount',
+      type: 'uint256',
+      internalType: 'uint256'
+    }, {
+      name: 'bridgeAddress',
+      type: 'address',
+      internalType: 'address'
+    }, {
+      name: 'destChain',
+      type: 'string',
+      internalType: 'string'
+    }, {
+      name: 'destUser',
+      type: 'address',
+      internalType: 'address'
+    }, {
+      name: 'extra',
+      type: 'bytes',
+      internalType: 'bytes'
     }]
   }],
   outputs: [{
@@ -278,7 +273,7 @@ var QuoterAbi = [{
     type: 'uint256',
     internalType: 'uint256'
   }],
-  stateMutability: 'view'
+  stateMutability: 'nonpayable'
 }, {
   type: 'function',
   name: 'removeContract',
@@ -377,5 +372,29 @@ var QuoterAbi = [{
     internalType: 'address'
   }],
   anonymous: false
+}, {
+  type: 'error',
+  name: 'NotExecutor',
+  inputs: [{
+    name: 'caller',
+    type: 'address',
+    internalType: 'address'
+  }, {
+    name: 'executor',
+    type: 'address',
+    internalType: 'address'
+  }]
+}, {
+  type: 'error',
+  name: 'NotOwner',
+  inputs: [{
+    name: 'caller',
+    type: 'address',
+    internalType: 'address'
+  }, {
+    name: 'owner',
+    type: 'address',
+    internalType: 'address'
+  }]
 }];
 export default QuoterAbi;

package/dist/esm/index.d.ts

@@ -12,7 +12,9 @@ declare class Hermes {
     expect(params: IExpectParams): Promise<bigint>;
     swap(params: ISwapParams): Promise<IReceipt>;
     bridge(params: IBridgeParams): Promise<IReceipt>;
+    estimateBridgeFee(params: IBridgeParams): Promise<bigint>;
     swapAndBridge(params: ISwapAndBridgeParams): Promise<IReceipt>;
+    private checkIsEnoughToken;
     private validateParams;
     private getQuoterAddress;
     private getAggregatorAddress;

package/dist/esm/index.js

@@ -43,7 +43,6 @@ var Hermes = /*#__PURE__*/function () {
         this.walletMap.set(chainName, new ethers.Wallet(rpc.privateKey, provider));
       }
     }
-    console.log(Object.entries(this.config.rpc), this.walletMap);
     for (var _i2 = 0, _Object$entries2 = Object.entries(this.config.quoterAddress); _i2 < _Object$entries2.length; _i2++) {
       var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
         _chainName = _Object$entries2$_i[0],
@@ -247,7 +246,11 @@ var Hermes = /*#__PURE__*/function () {
               return _context2.abrupt("return", {
                 fromToken: fromTokenAddress,
                 toToken: toTokenAddress,
-                amountOut: amountOut
+                amountOut: amountOut,
+                hash: receipt.hash,
+                from: receipt.from,
+                to: receipt.from,
+                logs: receipt.logs
               });
             case 76:
             case "end":
@@ -264,18 +267,104 @@ var Hermes = /*#__PURE__*/function () {
     key: "bridge",
     value: function () {
       var _bridge = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
-        var receipt;
+        var _params$extra;
+        var aggregatorAddress, wallet, provider, nativeBalance, aggregator, bridgeArgs, txOverrides, txResponse, receipt;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
               this.validateParams(params);
-              receipt = {};
+
+              // set up
+              aggregatorAddress = this.getAggregatorAddress(params.chain);
+              wallet = this.walletMap.get(params.chain);
+              if (wallet) {
+                _context3.next = 5;
+                break;
+              }
+              throw new Error("Wallet not configured for chain: ".concat(params.chain));
+            case 5:
+              if (!(params.tokenAddress && params.tokenAddress !== ethers.ZeroAddress)) {
+                _context3.next = 8;
+                break;
+              }
+              _context3.next = 8;
+              return this.checkIsEnoughToken(params.tokenAddress, params.user, params.amountInWei, aggregatorAddress, wallet);
+            case 8:
+              if (!(params.bridgeFee > 0n)) {
+                _context3.next = 17;
+                break;
+              }
+              provider = this.providerMap.get(params.chain);
+              if (provider) {
+                _context3.next = 12;
+                break;
+              }
+              throw new Error("Provider not configured for chain: ".concat(params.chain));
+            case 12:
+              _context3.next = 14;
+              return provider.getBalance(params.user);
+            case 14:
+              nativeBalance = _context3.sent;
+              if (!(nativeBalance < params.bridgeFee)) {
+                _context3.next = 17;
+                break;
+              }
+              throw new Error('Insufficient native balance for bridge fee');
+            case 17:
+              aggregator = new Contract(aggregatorAddress, AggregatorAbi, wallet); // simulate
+              bridgeArgs = {
+                bridge: params.bridgeType,
+                token: params.tokenAddress,
+                amount: params.amountInWei,
+                bridgeAddress: params.bridgeAddress,
+                destChain: params.destChain,
+                destUser: params.destUser,
+                extra: (_params$extra = params.extra) !== null && _params$extra !== void 0 ? _params$extra : '0x'
+              };
+              txOverrides = {
+                from: wallet.address,
+                value: params.bridgeFee
+              }; // simulate
+              _context3.prev = 20;
+              _context3.next = 23;
+              return aggregator.bridge.estimateGas(params.user, bridgeArgs, txOverrides);
+            case 23:
+              _context3.next = 29;
+              break;
+            case 25:
+              _context3.prev = 25;
+              _context3.t0 = _context3["catch"](20);
+              console.error('Bridge gas estimation reverted', _context3.t0);
+              throw _context3.t0;
+            case 29:
+              _context3.prev = 29;
+              _context3.next = 32;
+              return aggregator.bridge(params.user, bridgeArgs, txOverrides);
+            case 32:
+              txResponse = _context3.sent;
+              _context3.next = 39;
+              break;
+            case 35:
+              _context3.prev = 35;
+              _context3.t1 = _context3["catch"](29);
+              console.error('Aggregator swap transaction failed', _context3.t1);
+              throw _context3.t1;
+            case 39:
+              receipt = {
+                fromToken: params.tokenAddress,
+                toToken: params.tokenAddress,
+                amountOut: params.amountInWei,
+                hash: txResponse.hash,
+                from: txResponse.from,
+                to: txResponse.to,
+                logs: txResponse.logs
+              };
               return _context3.abrupt("return", Promise.resolve(receipt));
-            case 3:
+            case 41:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this);
+        }, _callee3, this, [[20, 25], [29, 35]]);
       }));
       function bridge(_x3) {
         return _bridge.apply(this, arguments);
@@ -283,27 +372,127 @@ var Hermes = /*#__PURE__*/function () {
       return bridge;
     }()
   }, {
-    key: "swapAndBridge",
+    key: "estimateBridgeFee",
     value: function () {
-      var _swapAndBridge = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(params) {
-        var receipt;
+      var _estimateBridgeFee = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(params) {
+        var _params$extra2;
+        var wallet, address, quoter, bridgeArgs, bridgeFee;
         return _regeneratorRuntime().wrap(function _callee4$(_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
               this.validateParams(params);
-              receipt = {};
-              return _context4.abrupt("return", Promise.resolve(receipt));
-            case 3:
+              wallet = this.walletMap.get(params.chain);
+              if (wallet) {
+                _context4.next = 4;
+                break;
+              }
+              throw new Error("Wallet not configured for chain: ".concat(params.chain));
+            case 4:
+              address = this.getQuoterAddress(params.chain);
+              if (address) {
+                _context4.next = 7;
+                break;
+              }
+              throw new Error("Quoter address not found for chain: ".concat(params.chain));
+            case 7:
+              quoter = new Contract(address, QuoterAbi, wallet);
+              bridgeArgs = {
+                bridge: params.bridgeType,
+                token: params.tokenAddress,
+                amount: params.amountInWei,
+                bridgeAddress: params.bridgeAddress,
+                destChain: params.destChain,
+                destUser: params.destUser,
+                extra: (_params$extra2 = params.extra) !== null && _params$extra2 !== void 0 ? _params$extra2 : '0x'
+              };
+              _context4.next = 11;
+              return quoter.quoteBridge.staticCall(bridgeArgs, {
+                from: wallet.address
+              });
+            case 11:
+              bridgeFee = _context4.sent;
+              return _context4.abrupt("return", bridgeFee);
+            case 13:
             case "end":
               return _context4.stop();
           }
         }, _callee4, this);
       }));
-      function swapAndBridge(_x4) {
+      function estimateBridgeFee(_x4) {
+        return _estimateBridgeFee.apply(this, arguments);
+      }
+      return estimateBridgeFee;
+    }()
+  }, {
+    key: "swapAndBridge",
+    value: function () {
+      var _swapAndBridge = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(params) {
+        var receipt;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              this.validateParams(params);
+              receipt = {
+                fromToken: params.path[0].fromCoinAddress,
+                toToken: params.path[params.path.length - 1].toCoinAddress,
+                amountOut: params.minAmountOutList[params.minAmountOutList.length - 1],
+                hash: '',
+                from: '',
+                to: '',
+                logs: []
+              };
+              return _context5.abrupt("return", Promise.resolve(receipt));
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function swapAndBridge(_x5) {
         return _swapAndBridge.apply(this, arguments);
       }
       return swapAndBridge;
     }()
+  }, {
+    key: "checkIsEnoughToken",
+    value: function () {
+      var _checkIsEnoughToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(fromTokenAddress, userAddress, amountInWei, aggregatorAddress, wallet) {
+        var erc20, userBalance, currentAllowance;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              erc20 = new Contract(fromTokenAddress, ['function balanceOf(address) view returns (uint256)', 'function allowance(address, address) view returns (uint256)'], wallet);
+              _context6.next = 3;
+              return erc20.balanceOf(userAddress);
+            case 3:
+              userBalance = _context6.sent;
+              if (!(userBalance < amountInWei)) {
+                _context6.next = 6;
+                break;
+              }
+              throw new Error('Insufficient balance token amount');
+            case 6:
+              _context6.next = 8;
+              return erc20.allowance(userAddress, aggregatorAddress);
+            case 8:
+              currentAllowance = _context6.sent;
+              console.log(currentAllowance);
+              if (!(currentAllowance < amountInWei)) {
+                _context6.next = 12;
+                break;
+              }
+              throw new Error('Insufficient allowance token amount');
+            case 12:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function checkIsEnoughToken(_x6, _x7, _x8, _x9, _x10) {
+        return _checkIsEnoughToken.apply(this, arguments);
+      }
+      return checkIsEnoughToken;
+    }()
   }, {
     key: "validateParams",
     value: function validateParams(params) {

package/dist/esm/types.d.ts

@@ -1,4 +1,4 @@
-import type { BytesLike } from 'ethers';
+import type { BytesLike, JsonRpcProvider } from 'ethers';
 export interface IConfig {
     rpc: Record<string, IRpcConfig>;
     quoterAddress: Record<string, string>;
@@ -24,6 +24,8 @@ export interface IBridgeParams {
     bridgeAddress: string;
     tokenAddress: string;
     destChain: string;
+    destUser: string;
+    bridgeFee: bigint;
     extra?: BytesLike;
 }
 export interface ISwapAndBridgeParams {
@@ -36,15 +38,57 @@ export interface ISwapAndBridgeParams {
     bridgeAddress: string;
     tokenAddress: string;
     destChain: string;
+    destUser: string;
+    bridgeFee: bigint;
     extra?: BytesLike;
 }
 export interface IReceipt {
-    fromToken?: string;
-    toToken?: string;
-    amountOut?: bigint;
+    fromToken: string;
+    toToken: string;
+    amountOut: bigint;
+    hash: string;
+    from: string;
+    to: string;
+    logs: ILog[];
+}
+export interface IEthersReceipt {
+    provider: JsonRpcProvider;
+    to: string;
+    from: string;
+    contractAddress: string | null;
+    hash: string;
+    index: number;
+    blockHash: string;
+    blockNumber: number;
+    logsBloom: string;
+    gasUsed: bigint;
+    blobGasUsed: null;
+    cumulativeGasUsed: bigint;
+    gasPrice: bigint;
+    blobGasPrice: null;
+    type: number;
+    status: number;
+    root: undefined;
+    logs: ILog[];
+}
+export interface ILog {
+    provider: JsonRpcProvider;
+    transactionHash: string;
+    blockHash: string;
+    blockNumber: number;
+    removed: undefined;
+    address: string;
+    data: string;
+    topics: string[];
+    index: number;
+    transactionIndex: number;
+    args: any[];
 }
 export declare enum DexType {
-    FX = "f(x)"
+    FX = "f(x)",
+    UNISWAPV2 = "uniswapv2",
+    CURVE128 = "curve128",
+    CURVE256 = "curve256"
 }
 export declare enum ChainNameEnum {
     ETH = "ETH",// Ethereum Mainnet
@@ -218,6 +262,12 @@ export declare const AddressConst: {
     xeth: {
         eth: string;
     };
+    arb: {
+        arb: string;
+    };
+    usdc: {
+        arb: string;
+    };
 };
 export interface IExpectPayload {
 }

package/dist/esm/types.js

@@ -1,5 +1,8 @@
 export var DexType = /*#__PURE__*/function (DexType) {
   DexType["FX"] = "f(x)";
+  DexType["UNISWAPV2"] = "uniswapv2";
+  DexType["CURVE128"] = "curve128";
+  DexType["CURVE256"] = "curve256";
   return DexType;
 }({});
 export var ChainNameEnum = /*#__PURE__*/function (ChainNameEnum) {
@@ -171,5 +174,11 @@ export var AddressConst = {
   },
   xeth: {
     eth: '0xe063F04f280c60aECa68b38341C2eEcBeC703ae2'
+  },
+  arb: {
+    arb: '0x912CE59144191C1204E64559FE8253a0e49E6548'
+  },
+  usdc: {
+    arb: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-swap",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "A TypeScript utility library for swap and bridge",
   "type": "module",
   "main": "dist/esm/index.js",