@dodoex/dodo-contract-request 1.1.0 → 1.2.0

package/src/contract/InitializableERC20.ts

@@ -94,10 +94,10 @@ export function fetchInitializableERC20TotalSupply(chainId: number, __to: string
 /**
  * encode approve
  * @param {string} spender - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeInitializableERC20Approve(spender: string, amount: number) {
+export function encodeInitializableERC20Approve(spender: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [spender,amount]);
   return hexlify(concat(['0x095ea7b3', __encodeData]));
 }
@@ -105,13 +105,13 @@ export function encodeInitializableERC20Approve(spender: string, amount: number)
 /**
  * encode init
  * @param {string} _creator - address
- * @param {number} _totalSupply - uint256
+ * @param {string} _totalSupply - uint256
  * @param {string} _name - string
  * @param {string} _symbol - string
- * @param {number} _decimals - uint8
+ * @param {string} _decimals - uint8
  * @returns {string} encode data
  */
-export function encodeInitializableERC20Init(_creator: string, _totalSupply: number, _name: string, _symbol: string, _decimals: number) {
+export function encodeInitializableERC20Init(_creator: string, _totalSupply: string, _name: string, _symbol: string, _decimals: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","string","string","uint8"], [_creator,_totalSupply,_name,_symbol,_decimals]);
   return hexlify(concat(['0xfc90ef18', __encodeData]));
 }
@@ -119,10 +119,10 @@ export function encodeInitializableERC20Init(_creator: string, _totalSupply: num
 /**
  * encode transfer
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeInitializableERC20Transfer(to: string, amount: number) {
+export function encodeInitializableERC20Transfer(to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,amount]);
   return hexlify(concat(['0xa9059cbb', __encodeData]));
 }
@@ -131,10 +131,10 @@ export function encodeInitializableERC20Transfer(to: string, amount: number) {
  * encode transferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeInitializableERC20TransferFrom(from: string, to: string, amount: number) {
+export function encodeInitializableERC20TransferFrom(from: string, to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [from,to,amount]);
   return hexlify(concat(['0x23b872dd', __encodeData]));
 }

package/src/contract/LimitOrder.ts

@@ -186,14 +186,14 @@ export function encodeLimitOrderClaimOwnership() {
 
 /**
  * encode fillLimitOrder
- * @param {{makerToken: string; takerToken: string; makerAmount: number; takerAmount: number; maker: string; taker: string; expiration: number; salt: number}} order - tuple
+ * @param {{makerToken: string; takerToken: string; makerAmount: string; takerAmount: string; maker: string; taker: string; expiration: string; salt: string}} order - tuple
  * @param {string} signature - bytes
- * @param {number} takerFillAmount - uint256
- * @param {number} thresholdTakerAmount - uint256
+ * @param {string} takerFillAmount - uint256
+ * @param {string} thresholdTakerAmount - uint256
  * @param {string} takerInteraction - bytes
  * @returns {string} encode data
  */
-export function encodeLimitOrderFillLimitOrder(order: {makerToken: string; takerToken: string; makerAmount: number; takerAmount: number; maker: string; taker: string; expiration: number; salt: number}, signature: string, takerFillAmount: number, thresholdTakerAmount: number, takerInteraction: string) {
+export function encodeLimitOrderFillLimitOrder(order: {makerToken: string; takerToken: string; makerAmount: string; takerAmount: string; maker: string; taker: string; expiration: string; salt: string}, signature: string, takerFillAmount: string, thresholdTakerAmount: string, takerInteraction: string) {
   const __encodeData = defaultAbiCoder.encode(["tuple(address, address, uint256, uint256, address, address, uint256, uint256)","bytes","uint256","uint256","bytes"], [order,signature,takerFillAmount,thresholdTakerAmount,takerInteraction]);
   return hexlify(concat(['0x1dd76cc3', __encodeData]));
 }
@@ -222,16 +222,16 @@ export function encodeLimitOrderInitOwner(newOwner: string) {
 
 /**
  * encode matchingRFQByPlatform
- * @param {{makerToken: string; takerToken: string; makerAmount: number; takerAmount: number; makerTokenFeeAmount: number; takerFillAmount: number; maker: string; taker: string; expiration: number; slot: number}} order - tuple
+ * @param {{makerToken: string; takerToken: string; makerAmount: string; takerAmount: string; makerTokenFeeAmount: string; takerFillAmount: string; maker: string; taker: string; expiration: string; slot: string}} order - tuple
  * @param {string} makerSignature - bytes
  * @param {string} takerSignature - bytes
- * @param {number} takerFillAmount - uint256
- * @param {number} thresholdMakerAmount - uint256
- * @param {number} makerTokenFeeAmount - uint256
+ * @param {string} takerFillAmount - uint256
+ * @param {string} thresholdMakerAmount - uint256
+ * @param {string} makerTokenFeeAmount - uint256
  * @param {string} taker - address
  * @returns {string} encode data
  */
-export function encodeLimitOrderMatchingRFQByPlatform(order: {makerToken: string; takerToken: string; makerAmount: number; takerAmount: number; makerTokenFeeAmount: number; takerFillAmount: number; maker: string; taker: string; expiration: number; slot: number}, makerSignature: string, takerSignature: string, takerFillAmount: number, thresholdMakerAmount: number, makerTokenFeeAmount: number, taker: string) {
+export function encodeLimitOrderMatchingRFQByPlatform(order: {makerToken: string; takerToken: string; makerAmount: string; takerAmount: string; makerTokenFeeAmount: string; takerFillAmount: string; maker: string; taker: string; expiration: string; slot: string}, makerSignature: string, takerSignature: string, takerFillAmount: string, thresholdMakerAmount: string, makerTokenFeeAmount: string, taker: string) {
   const __encodeData = defaultAbiCoder.encode(["tuple(address, address, uint256, uint256, uint256, uint256, address, address, uint256, uint256)","bytes","bytes","uint256","uint256","uint256","address"], [order,makerSignature,takerSignature,takerFillAmount,thresholdMakerAmount,makerTokenFeeAmount,taker]);
   return hexlify(concat(['0x18c8f2ae', __encodeData]));
 }

package/src/contract/LimitOrderBot.ts

@@ -120,15 +120,15 @@ export function encodeLimitOrderBotClaimOwnership() {
 
 /**
  * encode doLimitOrderSwap
- * @param {number} curTakerFillAmount - uint256
- * @param {number} curMakerFillAmount - uint256
+ * @param {string} curTakerFillAmount - uint256
+ * @param {string} curMakerFillAmount - uint256
  * @param {string} makerToken - address
  * @param {string} takerToken - address
  * @param {string} dodoRouteProxy - address
  * @param {string} dodoApiData - bytes
  * @returns {string} encode data
  */
-export function encodeLimitOrderBotDoLimitOrderSwap(curTakerFillAmount: number, curMakerFillAmount: number, makerToken: string, takerToken: string, dodoRouteProxy: string, dodoApiData: string) {
+export function encodeLimitOrderBotDoLimitOrderSwap(curTakerFillAmount: string, curMakerFillAmount: string, makerToken: string, takerToken: string, dodoRouteProxy: string, dodoApiData: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address","address","address","bytes"], [curTakerFillAmount,curMakerFillAmount,makerToken,takerToken,dodoRouteProxy,dodoApiData]);
   return hexlify(concat(['0x89143c25', __encodeData]));
 }
@@ -137,10 +137,10 @@ export function encodeLimitOrderBotDoLimitOrderSwap(curTakerFillAmount: number,
  * encode fillDODOLimitOrder
  * @param {string} callExternalData - bytes
  * @param {string} takerToken - address
- * @param {number} minTakerTokenAmount - uint256
+ * @param {string} minTakerTokenAmount - uint256
  * @returns {string} encode data
  */
-export function encodeLimitOrderBotFillDODOLimitOrder(callExternalData: string, takerToken: string, minTakerTokenAmount: number) {
+export function encodeLimitOrderBotFillDODOLimitOrder(callExternalData: string, takerToken: string, minTakerTokenAmount: string) {
   const __encodeData = defaultAbiCoder.encode(["bytes","address","uint256"], [callExternalData,takerToken,minTakerTokenAmount]);
   return hexlify(concat(['0x272a16bd', __encodeData]));
 }

package/src/contract/UniswapV2Factory.ts

@@ -82,10 +82,10 @@ export function fetchUniswapV2FactoryGetPair(chainId: number, __input1: string,
  * encode createPair
  * @param {string} tokenA - address
  * @param {string} tokenB - address
- * @param {number} feeRate - uint256
+ * @param {string} feeRate - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2FactoryCreatePair(tokenA: string, tokenB: string, feeRate: number) {
+export function encodeUniswapV2FactoryCreatePair(tokenA: string, tokenB: string, feeRate: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [tokenA,tokenB,feeRate]);
   return hexlify(concat(['0x6b600d1c', __encodeData]));
 }
@@ -113,10 +113,10 @@ export function encodeUniswapV2FactorySetFeeToSetter(_feeToSetter: string) {
 /**
  * encode setLpMtRatio
  * @param {string} pool - address
- * @param {number} ratio - uint256
+ * @param {string} ratio - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2FactorySetLpMtRatio(pool: string, ratio: number) {
+export function encodeUniswapV2FactorySetLpMtRatio(pool: string, ratio: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [pool,ratio]);
   return hexlify(concat(['0x4a4f2ace', __encodeData]));
 }

package/src/contract/UniswapV2Router02.ts

@@ -121,16 +121,16 @@ export function fetchUniswapV2Router02Quote(chainId: number, amountA: number, re
  * encode addLiquidity
  * @param {string} tokenA - address
  * @param {string} tokenB - address
- * @param {number} fee - uint256
- * @param {number} amountADesired - uint256
- * @param {number} amountBDesired - uint256
- * @param {number} amountAMin - uint256
- * @param {number} amountBMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} amountADesired - uint256
+ * @param {string} amountBDesired - uint256
+ * @param {string} amountAMin - uint256
+ * @param {string} amountBMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02AddLiquidity(tokenA: string, tokenB: string, fee: number, amountADesired: number, amountBDesired: number, amountAMin: number, amountBMin: number, to: string, deadline: number) {
+export function encodeUniswapV2Router02AddLiquidity(tokenA: string, tokenB: string, fee: string, amountADesired: string, amountBDesired: string, amountAMin: string, amountBMin: string, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256","uint256","uint256","uint256","uint256","address","uint256"], [tokenA,tokenB,fee,amountADesired,amountBDesired,amountAMin,amountBMin,to,deadline]);
   return hexlify(concat(['0x426e40b1', __encodeData]));
 }
@@ -138,15 +138,15 @@ export function encodeUniswapV2Router02AddLiquidity(tokenA: string, tokenB: stri
 /**
  * encode addLiquidityETH
  * @param {string} token - address
- * @param {number} fee - uint256
- * @param {number} amountTokenDesired - uint256
- * @param {number} amountTokenMin - uint256
- * @param {number} amountETHMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} amountTokenDesired - uint256
+ * @param {string} amountTokenMin - uint256
+ * @param {string} amountETHMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02AddLiquidityETH(token: string, fee: number, amountTokenDesired: number, amountTokenMin: number, amountETHMin: number, to: string, deadline: number) {
+export function encodeUniswapV2Router02AddLiquidityETH(token: string, fee: string, amountTokenDesired: string, amountTokenMin: string, amountETHMin: string, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint256","uint256","uint256","address","uint256"], [token,fee,amountTokenDesired,amountTokenMin,amountETHMin,to,deadline]);
   return hexlify(concat(['0x8d2468e4', __encodeData]));
 }
@@ -155,15 +155,15 @@ export function encodeUniswapV2Router02AddLiquidityETH(token: string, fee: numbe
  * encode removeLiquidity
  * @param {string} tokenA - address
  * @param {string} tokenB - address
- * @param {number} fee - uint256
- * @param {number} liquidity - uint256
- * @param {number} amountAMin - uint256
- * @param {number} amountBMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} liquidity - uint256
+ * @param {string} amountAMin - uint256
+ * @param {string} amountBMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidity(tokenA: string, tokenB: string, fee: number, liquidity: number, amountAMin: number, amountBMin: number, to: string, deadline: number) {
+export function encodeUniswapV2Router02RemoveLiquidity(tokenA: string, tokenB: string, fee: string, liquidity: string, amountAMin: string, amountBMin: string, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256","uint256","uint256","uint256","address","uint256"], [tokenA,tokenB,fee,liquidity,amountAMin,amountBMin,to,deadline]);
   return hexlify(concat(['0x96adb337', __encodeData]));
 }
@@ -171,15 +171,15 @@ export function encodeUniswapV2Router02RemoveLiquidity(tokenA: string, tokenB: s
 /**
  * encode removeLiquidityETH
  * @param {string} token - address
- * @param {number} fee - uint256
- * @param {number} liquidity - uint256
- * @param {number} amountTokenMin - uint256
- * @param {number} amountETHMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} liquidity - uint256
+ * @param {string} amountTokenMin - uint256
+ * @param {string} amountETHMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidityETH(token: string, fee: number, liquidity: number, amountTokenMin: number, amountETHMin: number, to: string, deadline: number) {
+export function encodeUniswapV2Router02RemoveLiquidityETH(token: string, fee: string, liquidity: string, amountTokenMin: string, amountETHMin: string, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint256","uint256","uint256","address","uint256"], [token,fee,liquidity,amountTokenMin,amountETHMin,to,deadline]);
   return hexlify(concat(['0xba3690cb', __encodeData]));
 }
@@ -187,25 +187,25 @@ export function encodeUniswapV2Router02RemoveLiquidityETH(token: string, fee: nu
 /**
  * encode removeLiquidityETHSupportingFeeOnTransferTokens
  * @param {string} token - address
- * @param {number} fee - uint256
- * @param {number} liquidity - uint256
- * @param {number} amountTokenMin - uint256
- * @param {number} amountETHMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} liquidity - uint256
+ * @param {string} amountTokenMin - uint256
+ * @param {string} amountETHMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidityETHSupportingFeeOnTransferTokens(token: string, fee: number, liquidity: number, amountTokenMin: number, amountETHMin: number, to: string, deadline: number) {
+export function encodeUniswapV2Router02RemoveLiquidityETHSupportingFeeOnTransferTokens(token: string, fee: string, liquidity: string, amountTokenMin: string, amountETHMin: string, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint256","uint256","uint256","address","uint256"], [token,fee,liquidity,amountTokenMin,amountETHMin,to,deadline]);
   return hexlify(concat(['0xc194f861', __encodeData]));
 }
 
 /**
  * encode removeLiquidityETHWithPermit
- * @param {{token: string; fee: number; liquidity: number; amountTokenMin: number; amountETHMin: number; to: string; deadline: number; approveMax: boolean; v: number; r: string; s: string}} params - tuple
+ * @param {{token: string; fee: string; liquidity: string; amountTokenMin: string; amountETHMin: string; to: string; deadline: string; approveMax: boolean; v: string; r: string; s: string}} params - tuple
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidityETHWithPermit(params: {token: string; fee: number; liquidity: number; amountTokenMin: number; amountETHMin: number; to: string; deadline: number; approveMax: boolean; v: number; r: string; s: string}) {
+export function encodeUniswapV2Router02RemoveLiquidityETHWithPermit(params: {token: string; fee: string; liquidity: string; amountTokenMin: string; amountETHMin: string; to: string; deadline: string; approveMax: boolean; v: string; r: string; s: string}) {
   const __encodeData = defaultAbiCoder.encode(["tuple(address, uint256, uint256, uint256, uint256, address, uint256, bool, uint8, bytes32, bytes32)"], [params]);
   return hexlify(concat(['0x99230406', __encodeData]));
 }
@@ -213,161 +213,161 @@ export function encodeUniswapV2Router02RemoveLiquidityETHWithPermit(params: {tok
 /**
  * encode removeLiquidityETHWithPermitSupportingFeeOnTransferTokens
  * @param {string} token - address
- * @param {number} fee - uint256
- * @param {number} liquidity - uint256
- * @param {number} amountTokenMin - uint256
- * @param {number} amountETHMin - uint256
+ * @param {string} fee - uint256
+ * @param {string} liquidity - uint256
+ * @param {string} amountTokenMin - uint256
+ * @param {string} amountETHMin - uint256
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @param {boolean} approveMax - bool
- * @param {number} v - uint8
+ * @param {string} v - uint8
  * @param {string} r - bytes32
  * @param {string} s - bytes32
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, fee: number, liquidity: number, amountTokenMin: number, amountETHMin: number, to: string, deadline: number, approveMax: boolean, v: number, r: string, s: string) {
+export function encodeUniswapV2Router02RemoveLiquidityETHWithPermitSupportingFeeOnTransferTokens(token: string, fee: string, liquidity: string, amountTokenMin: string, amountETHMin: string, to: string, deadline: string, approveMax: boolean, v: string, r: string, s: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint256","uint256","uint256","address","uint256","bool","uint8","bytes32","bytes32"], [token,fee,liquidity,amountTokenMin,amountETHMin,to,deadline,approveMax,v,r,s]);
   return hexlify(concat(['0x3cd9979d', __encodeData]));
 }
 
 /**
  * encode removeLiquidityWithPermit
- * @param {{tokenA: string; tokenB: string; fee: number; liquidity: number; amountAMin: number; amountBMin: number; to: string; deadline: number; approveMax: boolean; v: number; r: string; s: string}} params - tuple
+ * @param {{tokenA: string; tokenB: string; fee: string; liquidity: string; amountAMin: string; amountBMin: string; to: string; deadline: string; approveMax: boolean; v: string; r: string; s: string}} params - tuple
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02RemoveLiquidityWithPermit(params: {tokenA: string; tokenB: string; fee: number; liquidity: number; amountAMin: number; amountBMin: number; to: string; deadline: number; approveMax: boolean; v: number; r: string; s: string}) {
+export function encodeUniswapV2Router02RemoveLiquidityWithPermit(params: {tokenA: string; tokenB: string; fee: string; liquidity: string; amountAMin: string; amountBMin: string; to: string; deadline: string; approveMax: boolean; v: string; r: string; s: string}) {
   const __encodeData = defaultAbiCoder.encode(["tuple(address, address, uint256, uint256, uint256, uint256, address, uint256, bool, uint8, bytes32, bytes32)"], [params]);
   return hexlify(concat(['0xe38e161a', __encodeData]));
 }
 
 /**
  * encode swapETHForExactTokens
- * @param {number} amountOut - uint256
+ * @param {string} amountOut - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapETHForExactTokens(amountOut: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapETHForExactTokens(amountOut: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","address[]","uint256[]","address","uint256"], [amountOut,path,fees,to,deadline]);
   return hexlify(concat(['0x8c005948', __encodeData]));
 }
 
 /**
  * encode swapExactETHForTokens
- * @param {number} amountOutMin - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactETHForTokens(amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactETHForTokens(amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","address[]","uint256[]","address","uint256"], [amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0xe36dc876', __encodeData]));
 }
 
 /**
  * encode swapExactETHForTokensSupportingFeeOnTransferTokens
- * @param {number} amountOutMin - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactETHForTokensSupportingFeeOnTransferTokens(amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","address[]","uint256[]","address","uint256"], [amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0x6fee0fa9', __encodeData]));
 }
 
 /**
  * encode swapExactTokensForETH
- * @param {number} amountIn - uint256
- * @param {number} amountOutMin - uint256
+ * @param {string} amountIn - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactTokensForETH(amountIn: number, amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactTokensForETH(amountIn: string, amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountIn,amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0x851d14f5', __encodeData]));
 }
 
 /**
  * encode swapExactTokensForETHSupportingFeeOnTransferTokens
- * @param {number} amountIn - uint256
- * @param {number} amountOutMin - uint256
+ * @param {string} amountIn - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: number, amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactTokensForETHSupportingFeeOnTransferTokens(amountIn: string, amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountIn,amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0x27ec1eff', __encodeData]));
 }
 
 /**
  * encode swapExactTokensForTokens
- * @param {number} amountIn - uint256
- * @param {number} amountOutMin - uint256
+ * @param {string} amountIn - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactTokensForTokens(amountIn: number, amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactTokensForTokens(amountIn: string, amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountIn,amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0xe26997dc', __encodeData]));
 }
 
 /**
  * encode swapExactTokensForTokensSupportingFeeOnTransferTokens
- * @param {number} amountIn - uint256
- * @param {number} amountOutMin - uint256
+ * @param {string} amountIn - uint256
+ * @param {string} amountOutMin - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: number, amountOutMin: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: string, amountOutMin: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountIn,amountOutMin,path,fees,to,deadline]);
   return hexlify(concat(['0x27c1169b', __encodeData]));
 }
 
 /**
  * encode swapTokensForExactETH
- * @param {number} amountOut - uint256
- * @param {number} amountInMax - uint256
+ * @param {string} amountOut - uint256
+ * @param {string} amountInMax - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapTokensForExactETH(amountOut: number, amountInMax: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapTokensForExactETH(amountOut: string, amountInMax: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountOut,amountInMax,path,fees,to,deadline]);
   return hexlify(concat(['0xedb2af1f', __encodeData]));
 }
 
 /**
  * encode swapTokensForExactTokens
- * @param {number} amountOut - uint256
- * @param {number} amountInMax - uint256
+ * @param {string} amountOut - uint256
+ * @param {string} amountInMax - uint256
  * @param {Array<string>} path - address[]
- * @param {Array<number>} fees - uint256[]
+ * @param {Array<string>} fees - uint256[]
  * @param {string} to - address
- * @param {number} deadline - uint256
+ * @param {string} deadline - uint256
  * @returns {string} encode data
  */
-export function encodeUniswapV2Router02SwapTokensForExactTokens(amountOut: number, amountInMax: number, path: Array<string>, fees: Array<number>, to: string, deadline: number) {
+export function encodeUniswapV2Router02SwapTokensForExactTokens(amountOut: string, amountInMax: string, path: Array<string>, fees: Array<string>, to: string, deadline: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","address[]","uint256[]","address","uint256"], [amountOut,amountInMax,path,fees,to,deadline]);
   return hexlify(concat(['0x55a7cf78', __encodeData]));
 }

package/src/contract/dodoTeam.ts

@@ -225,10 +225,10 @@ export function fetchDodoTeamSignedMessages(chainId: number, __input1: string) {
 /**
  * encode addOwnerWithThreshold
  * @param {string} owner - address
- * @param {number} _threshold - uint256
+ * @param {string} _threshold - uint256
  * @returns {string} encode data
  */
-export function encodeDodoTeamAddOwnerWithThreshold(owner: string, _threshold: number) {
+export function encodeDodoTeamAddOwnerWithThreshold(owner: string, _threshold: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [owner,_threshold]);
   return hexlify(concat(['0x0d582f13', __encodeData]));
 }
@@ -255,10 +255,10 @@ export function encodeDodoTeamChangeMasterCopy(_masterCopy: string) {
 
 /**
  * encode changeThreshold
- * @param {number} _threshold - uint256
+ * @param {string} _threshold - uint256
  * @returns {string} encode data
  */
-export function encodeDodoTeamChangeThreshold(_threshold: number) {
+export function encodeDodoTeamChangeThreshold(_threshold: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [_threshold]);
   return hexlify(concat(['0x694e80c3', __encodeData]));
 }
@@ -287,18 +287,18 @@ export function encodeDodoTeamEnableModule(module: string) {
 /**
  * encode execTransaction
  * @param {string} to - address
- * @param {number} value - uint256
+ * @param {string} value - uint256
  * @param {string} data - bytes
- * @param {number} operation - uint8
- * @param {number} safeTxGas - uint256
- * @param {number} baseGas - uint256
- * @param {number} gasPrice - uint256
+ * @param {string} operation - uint8
+ * @param {string} safeTxGas - uint256
+ * @param {string} baseGas - uint256
+ * @param {string} gasPrice - uint256
  * @param {string} gasToken - address
  * @param {string} refundReceiver - address
  * @param {string} signatures - bytes
  * @returns {string} encode data
  */
-export function encodeDodoTeamExecTransaction(to: string, value: number, data: string, operation: number, safeTxGas: number, baseGas: number, gasPrice: number, gasToken: string, refundReceiver: string, signatures: string) {
+export function encodeDodoTeamExecTransaction(to: string, value: string, data: string, operation: string, safeTxGas: string, baseGas: string, gasPrice: string, gasToken: string, refundReceiver: string, signatures: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","bytes","uint8","uint256","uint256","uint256","address","address","bytes"], [to,value,data,operation,safeTxGas,baseGas,gasPrice,gasToken,refundReceiver,signatures]);
   return hexlify(concat(['0x6a761202', __encodeData]));
 }
@@ -306,12 +306,12 @@ export function encodeDodoTeamExecTransaction(to: string, value: number, data: s
 /**
  * encode execTransactionFromModule
  * @param {string} to - address
- * @param {number} value - uint256
+ * @param {string} value - uint256
  * @param {string} data - bytes
- * @param {number} operation - uint8
+ * @param {string} operation - uint8
  * @returns {string} encode data
  */
-export function encodeDodoTeamExecTransactionFromModule(to: string, value: number, data: string, operation: number) {
+export function encodeDodoTeamExecTransactionFromModule(to: string, value: string, data: string, operation: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","bytes","uint8"], [to,value,data,operation]);
   return hexlify(concat(['0x468721a7', __encodeData]));
 }
@@ -319,12 +319,12 @@ export function encodeDodoTeamExecTransactionFromModule(to: string, value: numbe
 /**
  * encode execTransactionFromModuleReturnData
  * @param {string} to - address
- * @param {number} value - uint256
+ * @param {string} value - uint256
  * @param {string} data - bytes
- * @param {number} operation - uint8
+ * @param {string} operation - uint8
  * @returns {string} encode data
  */
-export function encodeDodoTeamExecTransactionFromModuleReturnData(to: string, value: number, data: string, operation: number) {
+export function encodeDodoTeamExecTransactionFromModuleReturnData(to: string, value: string, data: string, operation: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","bytes","uint8"], [to,value,data,operation]);
   return hexlify(concat(['0x5229073f', __encodeData]));
 }
@@ -344,10 +344,10 @@ export function encodeDodoTeamIsValidSignature(_data: string, _signature: string
  * encode removeOwner
  * @param {string} prevOwner - address
  * @param {string} owner - address
- * @param {number} _threshold - uint256
+ * @param {string} _threshold - uint256
  * @returns {string} encode data
  */
-export function encodeDodoTeamRemoveOwner(prevOwner: string, owner: string, _threshold: number) {
+export function encodeDodoTeamRemoveOwner(prevOwner: string, owner: string, _threshold: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [prevOwner,owner,_threshold]);
   return hexlify(concat(['0xf8dc5dd9', __encodeData]));
 }
@@ -355,12 +355,12 @@ export function encodeDodoTeamRemoveOwner(prevOwner: string, owner: string, _thr
 /**
  * encode requiredTxGas
  * @param {string} to - address
- * @param {number} value - uint256
+ * @param {string} value - uint256
  * @param {string} data - bytes
- * @param {number} operation - uint8
+ * @param {string} operation - uint8
  * @returns {string} encode data
  */
-export function encodeDodoTeamRequiredTxGas(to: string, value: number, data: string, operation: number) {
+export function encodeDodoTeamRequiredTxGas(to: string, value: string, data: string, operation: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","bytes","uint8"], [to,value,data,operation]);
   return hexlify(concat(['0xc4ca3a9c', __encodeData]));
 }
@@ -378,16 +378,16 @@ export function encodeDodoTeamSetFallbackHandler(handler: string) {
 /**
  * encode setup
  * @param {Array<string>} _owners - address[]
- * @param {number} _threshold - uint256
+ * @param {string} _threshold - uint256
  * @param {string} to - address
  * @param {string} data - bytes
  * @param {string} fallbackHandler - address
  * @param {string} paymentToken - address
- * @param {number} payment - uint256
+ * @param {string} payment - uint256
  * @param {string} paymentReceiver - address
  * @returns {string} encode data
  */
-export function encodeDodoTeamSetup(_owners: Array<string>, _threshold: number, to: string, data: string, fallbackHandler: string, paymentToken: string, payment: number, paymentReceiver: string) {
+export function encodeDodoTeamSetup(_owners: Array<string>, _threshold: string, to: string, data: string, fallbackHandler: string, paymentToken: string, payment: string, paymentReceiver: string) {
   const __encodeData = defaultAbiCoder.encode(["address[]","uint256","address","bytes","address","address","uint256","address"], [_owners,_threshold,to,data,fallbackHandler,paymentToken,payment,paymentReceiver]);
   return hexlify(concat(['0xb63e800d', __encodeData]));
 }