@dodoex/dodo-contract-request 1.1.0 → 1.2.0

package/src/contract/DODOMineV3ProxyWithoutPlatform.ts

@@ -102,12 +102,12 @@ export function encodeDODOMineV3ProxyWithoutPlatformClaimOwnership() {
  * @param {string} stakeToken - address
  * @param {boolean} isLpToken - bool
  * @param {Array<string>} rewardTokens - address[]
- * @param {Array<number>} rewardPerBlock - uint256[]
- * @param {Array<number>} startBlock - uint256[]
- * @param {Array<number>} endBlock - uint256[]
+ * @param {Array<string>} rewardPerBlock - uint256[]
+ * @param {Array<string>} startBlock - uint256[]
+ * @param {Array<string>} endBlock - uint256[]
  * @returns {string} encode data
  */
-export function encodeDODOMineV3ProxyWithoutPlatformCreateDODOMineV3(stakeToken: string, isLpToken: boolean, rewardTokens: Array<string>, rewardPerBlock: Array<number>, startBlock: Array<number>, endBlock: Array<number>) {
+export function encodeDODOMineV3ProxyWithoutPlatformCreateDODOMineV3(stakeToken: string, isLpToken: boolean, rewardTokens: Array<string>, rewardPerBlock: Array<string>, startBlock: Array<string>, endBlock: Array<string>) {
   const __encodeData = defaultAbiCoder.encode(["address","bool","address[]","uint256[]","uint256[]","uint256[]"], [stakeToken,isLpToken,rewardTokens,rewardPerBlock,startBlock,endBlock]);
   return hexlify(concat(['0xb9b1135c', __encodeData]));
 }
@@ -116,10 +116,10 @@ export function encodeDODOMineV3ProxyWithoutPlatformCreateDODOMineV3(stakeToken:
  * encode depositRewardToMine
  * @param {string} mineV3 - address
  * @param {string} rewardToken - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOMineV3ProxyWithoutPlatformDepositRewardToMine(mineV3: string, rewardToken: string, amount: number) {
+export function encodeDODOMineV3ProxyWithoutPlatformDepositRewardToMine(mineV3: string, rewardToken: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [mineV3,rewardToken,amount]);
   return hexlify(concat(['0xe17ff361', __encodeData]));
 }
@@ -128,10 +128,10 @@ export function encodeDODOMineV3ProxyWithoutPlatformDepositRewardToMine(mineV3:
  * encode depositRewardToVault
  * @param {string} mineV3 - address
  * @param {string} rewardToken - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOMineV3ProxyWithoutPlatformDepositRewardToVault(mineV3: string, rewardToken: string, amount: number) {
+export function encodeDODOMineV3ProxyWithoutPlatformDepositRewardToVault(mineV3: string, rewardToken: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [mineV3,rewardToken,amount]);
   return hexlify(concat(['0x9cb297cd', __encodeData]));
 }

package/src/contract/DODONFT.ts

@@ -204,20 +204,20 @@ export function fetchDODONFTTotalSupply(chainId: number) {
 /**
  * encode approve
  * @param {string} to - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTApprove(to: string, tokenId: number) {
+export function encodeDODONFTApprove(to: string, tokenId: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,tokenId]);
   return hexlify(concat(['0x095ea7b3', __encodeData]));
 }
 
 /**
  * encode burn
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTBurn(tokenId: number) {
+export function encodeDODONFTBurn(tokenId: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [tokenId]);
   return hexlify(concat(['0x42966c68', __encodeData]));
 }
@@ -268,10 +268,10 @@ export function encodeDODONFTMint(uri: string) {
  * encode safeTransferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTSafeTransferFrom(from: string, to: string, tokenId: number) {
+export function encodeDODONFTSafeTransferFrom(from: string, to: string, tokenId: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [from,to,tokenId]);
   return hexlify(concat(['0x42842e0e', __encodeData]));
 }
@@ -280,11 +280,11 @@ export function encodeDODONFTSafeTransferFrom(from: string, to: string, tokenId:
  * encode safeTransferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @param {string} _data - bytes
  * @returns {string} encode data
  */
-export function encodeDODONFTSafeTransferFrom2(from: string, to: string, tokenId: number, _data: string) {
+export function encodeDODONFTSafeTransferFrom2(from: string, to: string, tokenId: string, _data: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256","bytes"], [from,to,tokenId,_data]);
   return hexlify(concat(['0xb88d4fde', __encodeData]));
 }
@@ -304,10 +304,10 @@ export function encodeDODONFTSetApprovalForAll(operator: string, approved: boole
  * encode transferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTTransferFrom(from: string, to: string, tokenId: number) {
+export function encodeDODONFTTransferFrom(from: string, to: string, tokenId: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256"], [from,to,tokenId]);
   return hexlify(concat(['0x23b872dd', __encodeData]));
 }

package/src/contract/DODONFT1155.ts

@@ -124,11 +124,11 @@ export function fetchDODONFT1155Uri(chainId: number, tokenId: number) {
 /**
  * encode burn
  * @param {string} account - address
- * @param {number} tokenId - uint256
- * @param {number} amount - uint256
+ * @param {string} tokenId - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFT1155Burn(account: string, tokenId: number, amount: number) {
+export function encodeDODONFT1155Burn(account: string, tokenId: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint256"], [account,tokenId,amount]);
   return hexlify(concat(['0xf5298aca', __encodeData]));
 }
@@ -156,10 +156,10 @@ export function encodeDODONFT1155InitOwner(newOwner: string) {
 /**
  * encode mint
  * @param {string} uri - string
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFT1155Mint(uri: string, amount: number) {
+export function encodeDODONFT1155Mint(uri: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["string","uint256"], [uri,amount]);
   return hexlify(concat(['0x056b01ce', __encodeData]));
 }
@@ -168,12 +168,12 @@ export function encodeDODONFT1155Mint(uri: string, amount: number) {
  * encode safeBatchTransferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {Array<number>} ids - uint256[]
- * @param {Array<number>} amounts - uint256[]
+ * @param {Array<string>} ids - uint256[]
+ * @param {Array<string>} amounts - uint256[]
  * @param {string} data - bytes
  * @returns {string} encode data
  */
-export function encodeDODONFT1155SafeBatchTransferFrom(from: string, to: string, ids: Array<number>, amounts: Array<number>, data: string) {
+export function encodeDODONFT1155SafeBatchTransferFrom(from: string, to: string, ids: Array<string>, amounts: Array<string>, data: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256[]","uint256[]","bytes"], [from,to,ids,amounts,data]);
   return hexlify(concat(['0x2eb2c2d6', __encodeData]));
 }
@@ -182,12 +182,12 @@ export function encodeDODONFT1155SafeBatchTransferFrom(from: string, to: string,
  * encode safeTransferFrom
  * @param {string} from - address
  * @param {string} to - address
- * @param {number} id - uint256
- * @param {number} amount - uint256
+ * @param {string} id - uint256
+ * @param {string} amount - uint256
  * @param {string} data - bytes
  * @returns {string} encode data
  */
-export function encodeDODONFT1155SafeTransferFrom(from: string, to: string, id: number, amount: number, data: string) {
+export function encodeDODONFT1155SafeTransferFrom(from: string, to: string, id: string, amount: string, data: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256","uint256","bytes"], [from,to,id,amount,data]);
   return hexlify(concat(['0xf242432a', __encodeData]));
 }

package/src/contract/DODONFTApprove.ts

@@ -104,11 +104,11 @@ export function encodeDODONFTApproveAddDODOProxy() {
  * @param {string} nftContract - address
  * @param {string} who - address
  * @param {string} dest - address
- * @param {number} tokenId - uint256
- * @param {number} amount - uint256
+ * @param {string} tokenId - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTApproveClaimERC1155(nftContract: string, who: string, dest: string, tokenId: number, amount: number) {
+export function encodeDODONFTApproveClaimERC1155(nftContract: string, who: string, dest: string, tokenId: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","address","uint256","uint256"], [nftContract,who,dest,tokenId,amount]);
   return hexlify(concat(['0x3a86185c', __encodeData]));
 }
@@ -118,11 +118,11 @@ export function encodeDODONFTApproveClaimERC1155(nftContract: string, who: strin
  * @param {string} nftContract - address
  * @param {string} who - address
  * @param {string} dest - address
- * @param {Array<number>} tokenIds - uint256[]
- * @param {Array<number>} amounts - uint256[]
+ * @param {Array<string>} tokenIds - uint256[]
+ * @param {Array<string>} amounts - uint256[]
  * @returns {string} encode data
  */
-export function encodeDODONFTApproveClaimERC1155Batch(nftContract: string, who: string, dest: string, tokenIds: Array<number>, amounts: Array<number>) {
+export function encodeDODONFTApproveClaimERC1155Batch(nftContract: string, who: string, dest: string, tokenIds: Array<string>, amounts: Array<string>) {
   const __encodeData = defaultAbiCoder.encode(["address","address","address","uint256[]","uint256[]"], [nftContract,who,dest,tokenIds,amounts]);
   return hexlify(concat(['0xc87dadb6', __encodeData]));
 }
@@ -132,10 +132,10 @@ export function encodeDODONFTApproveClaimERC1155Batch(nftContract: string, who:
  * @param {string} nftContract - address
  * @param {string} who - address
  * @param {string} dest - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTApproveClaimERC721(nftContract: string, who: string, dest: string, tokenId: number) {
+export function encodeDODONFTApproveClaimERC721(nftContract: string, who: string, dest: string, tokenId: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","address","uint256"], [nftContract,who,dest,tokenId]);
   return hexlify(concat(['0x45467cf8', __encodeData]));
 }

package/src/contract/DODONFTPoolProxy.ts

@@ -194,17 +194,17 @@ export function encodeDODONFTPoolProxyClaimOwnership() {
 
 /**
  * encode createFilterV1
- * @param {number} key - uint256
+ * @param {string} key - uint256
  * @param {string} filterAdmin - address
  * @param {string} nftCollection - address
  * @param {Array<boolean>} toggles - bool[]
  * @param {string} filterName - string
- * @param {Array<number>} numParams - uint256[]
- * @param {Array<number>} priceRules - uint256[]
- * @param {Array<number>} spreadIds - uint256[]
+ * @param {Array<string>} numParams - uint256[]
+ * @param {Array<string>} priceRules - uint256[]
+ * @param {Array<string>} spreadIds - uint256[]
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyCreateFilterV1(key: number, filterAdmin: string, nftCollection: string, toggles: Array<boolean>, filterName: string, numParams: Array<number>, priceRules: Array<number>, spreadIds: Array<number>) {
+export function encodeDODONFTPoolProxyCreateFilterV1(key: string, filterAdmin: string, nftCollection: string, toggles: Array<boolean>, filterName: string, numParams: Array<string>, priceRules: Array<string>, spreadIds: Array<string>) {
   const __encodeData = defaultAbiCoder.encode(["uint256","address","address","bool[]","string","uint256[]","uint256[]","uint256[]"], [key,filterAdmin,nftCollection,toggles,filterName,numParams,priceRules,spreadIds]);
   return hexlify(concat(['0xb13e0cfc', __encodeData]));
 }
@@ -213,10 +213,10 @@ export function encodeDODONFTPoolProxyCreateFilterV1(key: number, filterAdmin: s
  * encode createLiteNFTPool
  * @param {string} filterAdminOwner - address
  * @param {Array<string>} infos - string[]
- * @param {Array<number>} numParams - uint256[]
+ * @param {Array<string>} numParams - uint256[]
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyCreateLiteNFTPool(filterAdminOwner: string, infos: Array<string>, numParams: Array<number>) {
+export function encodeDODONFTPoolProxyCreateLiteNFTPool(filterAdminOwner: string, infos: Array<string>, numParams: Array<string>) {
   const __encodeData = defaultAbiCoder.encode(["address","string[]","uint256[]"], [filterAdminOwner,infos,numParams]);
   return hexlify(concat(['0x6388b541', __encodeData]));
 }
@@ -225,16 +225,16 @@ export function encodeDODONFTPoolProxyCreateLiteNFTPool(filterAdminOwner: string
  * encode createNewNFTPoolV1
  * @param {string} filterAdminOwner - address
  * @param {string} nftCollection - address
- * @param {number} filterKey - uint256
+ * @param {string} filterKey - uint256
  * @param {Array<string>} infos - string[]
- * @param {Array<number>} numParams - uint256[]
+ * @param {Array<string>} numParams - uint256[]
  * @param {Array<boolean>} toggles - bool[]
- * @param {Array<number>} filterNumParams - uint256[]
- * @param {Array<number>} priceRules - uint256[]
- * @param {Array<number>} spreadIds - uint256[]
+ * @param {Array<string>} filterNumParams - uint256[]
+ * @param {Array<string>} priceRules - uint256[]
+ * @param {Array<string>} spreadIds - uint256[]
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyCreateNewNFTPoolV1(filterAdminOwner: string, nftCollection: string, filterKey: number, infos: Array<string>, numParams: Array<number>, toggles: Array<boolean>, filterNumParams: Array<number>, priceRules: Array<number>, spreadIds: Array<number>) {
+export function encodeDODONFTPoolProxyCreateNewNFTPoolV1(filterAdminOwner: string, nftCollection: string, filterKey: string, infos: Array<string>, numParams: Array<string>, toggles: Array<boolean>, filterNumParams: Array<string>, priceRules: Array<string>, spreadIds: Array<string>) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256","string[]","uint256[]","bool[]","uint256[]","uint256[]","uint256[]"], [filterAdminOwner,nftCollection,filterKey,infos,numParams,toggles,filterNumParams,priceRules,spreadIds]);
   return hexlify(concat(['0x74fc6e25', __encodeData]));
 }
@@ -243,13 +243,13 @@ export function encodeDODONFTPoolProxyCreateNewNFTPoolV1(filterAdminOwner: strin
  * encode erc1155In
  * @param {string} filter - address
  * @param {string} nftCollection - address
- * @param {Array<number>} tokenIds - uint256[]
- * @param {Array<number>} amounts - uint256[]
+ * @param {Array<string>} tokenIds - uint256[]
+ * @param {Array<string>} amounts - uint256[]
  * @param {string} to - address
- * @param {number} minMintAmount - uint256
+ * @param {string} minMintAmount - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyErc1155In(filter: string, nftCollection: string, tokenIds: Array<number>, amounts: Array<number>, to: string, minMintAmount: number) {
+export function encodeDODONFTPoolProxyErc1155In(filter: string, nftCollection: string, tokenIds: Array<string>, amounts: Array<string>, to: string, minMintAmount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256[]","uint256[]","address","uint256"], [filter,nftCollection,tokenIds,amounts,to,minMintAmount]);
   return hexlify(concat(['0x8ec0766a', __encodeData]));
 }
@@ -258,12 +258,12 @@ export function encodeDODONFTPoolProxyErc1155In(filter: string, nftCollection: s
  * encode erc721In
  * @param {string} filter - address
  * @param {string} nftCollection - address
- * @param {Array<number>} tokenIds - uint256[]
+ * @param {Array<string>} tokenIds - uint256[]
  * @param {string} to - address
- * @param {number} minMintAmount - uint256
+ * @param {string} minMintAmount - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyErc721In(filter: string, nftCollection: string, tokenIds: Array<number>, to: string, minMintAmount: number) {
+export function encodeDODONFTPoolProxyErc721In(filter: string, nftCollection: string, tokenIds: Array<string>, to: string, minMintAmount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","uint256[]","address","uint256"], [filter,nftCollection,tokenIds,to,minMintAmount]);
   return hexlify(concat(['0x9aeb2db2', __encodeData]));
 }
@@ -273,13 +273,13 @@ export function encodeDODONFTPoolProxyErc721In(filter: string, nftCollection: st
  * @param {string} filterAdmin - address
  * @param {string} filter - address
  * @param {string} nftContract - address
- * @param {number} tokenId - uint256
+ * @param {string} tokenId - uint256
  * @param {string} toToken - address
  * @param {string} dodoProxy - address
  * @param {string} dodoSwapData - bytes
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxyErc721ToErc20(filterAdmin: string, filter: string, nftContract: string, tokenId: number, toToken: string, dodoProxy: string, dodoSwapData: string) {
+export function encodeDODONFTPoolProxyErc721ToErc20(filterAdmin: string, filter: string, nftContract: string, tokenId: string, toToken: string, dodoProxy: string, dodoSwapData: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","address","uint256","address","address","bytes"], [filterAdmin,filter,nftContract,tokenId,toToken,dodoProxy,dodoSwapData]);
   return hexlify(concat(['0xb32f2d92', __encodeData]));
 }
@@ -296,11 +296,11 @@ export function encodeDODONFTPoolProxyInitOwner(newOwner: string) {
 
 /**
  * encode setFilterTemplate
- * @param {number} idx - uint256
+ * @param {string} idx - uint256
  * @param {string} newFilterTemplate - address
  * @returns {string} encode data
  */
-export function encodeDODONFTPoolProxySetFilterTemplate(idx: number, newFilterTemplate: string) {
+export function encodeDODONFTPoolProxySetFilterTemplate(idx: string, newFilterTemplate: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","address"], [idx,newFilterTemplate]);
   return hexlify(concat(['0x9b2721c6', __encodeData]));
 }

package/src/contract/DODONFTProxy.ts

@@ -168,12 +168,12 @@ export function fetchDODONFTProxy_WETH_(chainId: number) {
 /**
  * encode buyout
  * @param {string} fragment - address
- * @param {number} quoteMaxAmount - uint256
- * @param {number} flag - uint8
- * @param {number} deadLine - uint256
+ * @param {string} quoteMaxAmount - uint256
+ * @param {string} flag - uint8
+ * @param {string} deadLine - uint256
  * @returns {string} encode data
  */
-export function encodeDODONFTProxyBuyout(fragment: string, quoteMaxAmount: number, flag: number, deadLine: number) {
+export function encodeDODONFTProxyBuyout(fragment: string, quoteMaxAmount: string, flag: string, deadLine: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint8","uint256"], [fragment,quoteMaxAmount,flag,deadLine]);
   return hexlify(concat(['0x8c8f1970', __encodeData]));
 }
@@ -191,12 +191,12 @@ export function encodeDODONFTProxyClaimOwnership() {
 /**
  * encode createFragment
  * @param {Array<string>} addrList - address[]
- * @param {Array<number>} params - uint256[]
+ * @param {Array<string>} params - uint256[]
  * @param {boolean} isOpenTwap - bool
  * @param {string} fragSymbol - string
  * @returns {string} encode data
  */
-export function encodeDODONFTProxyCreateFragment(addrList: Array<string>, params: Array<number>, isOpenTwap: boolean, fragSymbol: string) {
+export function encodeDODONFTProxyCreateFragment(addrList: Array<string>, params: Array<string>, isOpenTwap: boolean, fragSymbol: string) {
   const __encodeData = defaultAbiCoder.encode(["address[]","uint256[]","bool","string"], [addrList,params,isOpenTwap,fragSymbol]);
   return hexlify(concat(['0x1925bb8d', __encodeData]));
 }

package/src/contract/DODOStarterProxy.ts

@@ -38,12 +38,12 @@ export function fetchDODOStarterProxy_WETH_(chainId: number) {
 /**
  * encode bid
  * @param {string} pool - address
- * @param {number} fundAmount - uint256
- * @param {number} flag - uint8
- * @param {number} deadLine - uint256
+ * @param {string} fundAmount - uint256
+ * @param {string} flag - uint8
+ * @param {string} deadLine - uint256
  * @returns {string} encode data
  */
-export function encodeDODOStarterProxyBid(pool: string, fundAmount: number, flag: number, deadLine: number) {
+export function encodeDODOStarterProxyBid(pool: string, fundAmount: string, flag: string, deadLine: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256","uint8","uint256"], [pool,fundAmount,flag,deadLine]);
   return hexlify(concat(['0xdb70b5c7', __encodeData]));
 }

package/src/contract/DODOV1.ts

@@ -487,12 +487,12 @@ export function fetchDODOV1Version(chainId: number, __to: string) {
 
 /**
  * encode buyBaseToken
- * @param {number} amount - uint256
- * @param {number} maxPayQuote - uint256
+ * @param {string} amount - uint256
+ * @param {string} maxPayQuote - uint256
  * @param {string} data - bytes
  * @returns {string} encode data
  */
-export function encodeDODOV1BuyBaseToken(amount: number, maxPayQuote: number, data: string) {
+export function encodeDODOV1BuyBaseToken(amount: string, maxPayQuote: string, data: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","bytes"], [amount,maxPayQuote,data]);
   return hexlify(concat(['0xe67ce706', __encodeData]));
 }
@@ -519,10 +519,10 @@ export function encodeDODOV1ClaimOwnership() {
 
 /**
  * encode depositBase
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DepositBase(amount: number) {
+export function encodeDODOV1DepositBase(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0x27bed8ee', __encodeData]));
 }
@@ -530,20 +530,20 @@ export function encodeDODOV1DepositBase(amount: number) {
 /**
  * encode depositBaseTo
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DepositBaseTo(to: string, amount: number) {
+export function encodeDODOV1DepositBaseTo(to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,amount]);
   return hexlify(concat(['0xaa06ce9b', __encodeData]));
 }
 
 /**
  * encode depositQuote
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DepositQuote(amount: number) {
+export function encodeDODOV1DepositQuote(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0xf3ae6c5f', __encodeData]));
 }
@@ -551,10 +551,10 @@ export function encodeDODOV1DepositQuote(amount: number) {
 /**
  * encode depositQuoteTo
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DepositQuoteTo(to: string, amount: number) {
+export function encodeDODOV1DepositQuoteTo(to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,amount]);
   return hexlify(concat(['0x5f179f64', __encodeData]));
 }
@@ -591,20 +591,20 @@ export function encodeDODOV1DisableTrading() {
 
 /**
  * encode donateBaseToken
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DonateBaseToken(amount: number) {
+export function encodeDODOV1DonateBaseToken(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0xed0aa428', __encodeData]));
 }
 
 /**
  * encode donateQuoteToken
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1DonateQuoteToken(amount: number) {
+export function encodeDODOV1DonateQuoteToken(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0x387b0c11', __encodeData]));
 }
@@ -657,13 +657,13 @@ export function encodeDODOV1FinalSettlement() {
  * @param {string} baseToken - address
  * @param {string} quoteToken - address
  * @param {string} oracle - address
- * @param {number} lpFeeRate - uint256
- * @param {number} mtFeeRate - uint256
- * @param {number} k - uint256
- * @param {number} gasPriceLimit - uint256
+ * @param {string} lpFeeRate - uint256
+ * @param {string} mtFeeRate - uint256
+ * @param {string} k - uint256
+ * @param {string} gasPriceLimit - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1Init(owner: string, supervisor: string, maintainer: string, baseToken: string, quoteToken: string, oracle: string, lpFeeRate: number, mtFeeRate: number, k: number, gasPriceLimit: number) {
+export function encodeDODOV1Init(owner: string, supervisor: string, maintainer: string, baseToken: string, quoteToken: string, oracle: string, lpFeeRate: string, mtFeeRate: string, k: string, gasPriceLimit: string) {
   const __encodeData = defaultAbiCoder.encode(["address","address","address","address","address","address","uint256","uint256","uint256","uint256"], [owner,supervisor,maintainer,baseToken,quoteToken,oracle,lpFeeRate,mtFeeRate,k,gasPriceLimit]);
   return hexlify(concat(['0xf00f9a09', __encodeData]));
 }
@@ -671,52 +671,52 @@ export function encodeDODOV1Init(owner: string, supervisor: string, maintainer:
 /**
  * encode retrieve
  * @param {string} token - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1Retrieve(token: string, amount: number) {
+export function encodeDODOV1Retrieve(token: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [token,amount]);
   return hexlify(concat(['0xc3a2a665', __encodeData]));
 }
 
 /**
  * encode sellBaseToken
- * @param {number} amount - uint256
- * @param {number} minReceiveQuote - uint256
+ * @param {string} amount - uint256
+ * @param {string} minReceiveQuote - uint256
  * @param {string} data - bytes
  * @returns {string} encode data
  */
-export function encodeDODOV1SellBaseToken(amount: number, minReceiveQuote: number, data: string) {
+export function encodeDODOV1SellBaseToken(amount: string, minReceiveQuote: string, data: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256","uint256","bytes"], [amount,minReceiveQuote,data]);
   return hexlify(concat(['0x8dae7333', __encodeData]));
 }
 
 /**
  * encode setGasPriceLimit
- * @param {number} newGasPriceLimit - uint256
+ * @param {string} newGasPriceLimit - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1SetGasPriceLimit(newGasPriceLimit: number) {
+export function encodeDODOV1SetGasPriceLimit(newGasPriceLimit: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [newGasPriceLimit]);
   return hexlify(concat(['0x09231602', __encodeData]));
 }
 
 /**
  * encode setK
- * @param {number} newK - uint256
+ * @param {string} newK - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1SetK(newK: number) {
+export function encodeDODOV1SetK(newK: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [newK]);
   return hexlify(concat(['0x67de8be9', __encodeData]));
 }
 
 /**
  * encode setLiquidityProviderFeeRate
- * @param {number} newLiquidityPorviderFeeRate - uint256
+ * @param {string} newLiquidityPorviderFeeRate - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1SetLiquidityProviderFeeRate(newLiquidityPorviderFeeRate: number) {
+export function encodeDODOV1SetLiquidityProviderFeeRate(newLiquidityPorviderFeeRate: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [newLiquidityPorviderFeeRate]);
   return hexlify(concat(['0x5bb7552a', __encodeData]));
 }
@@ -733,10 +733,10 @@ export function encodeDODOV1SetMaintainer(newMaintainer: string) {
 
 /**
  * encode setMaintainerFeeRate
- * @param {number} newMaintainerFeeRate - uint256
+ * @param {string} newMaintainerFeeRate - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1SetMaintainerFeeRate(newMaintainerFeeRate: number) {
+export function encodeDODOV1SetMaintainerFeeRate(newMaintainerFeeRate: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [newMaintainerFeeRate]);
   return hexlify(concat(['0xf2220416', __encodeData]));
 }
@@ -813,10 +813,10 @@ export function encodeDODOV1WithdrawAllQuoteTo(to: string) {
 
 /**
  * encode withdrawBase
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1WithdrawBase(amount: number) {
+export function encodeDODOV1WithdrawBase(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0xf98bea15', __encodeData]));
 }
@@ -824,20 +824,20 @@ export function encodeDODOV1WithdrawBase(amount: number) {
 /**
  * encode withdrawBaseTo
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1WithdrawBaseTo(to: string, amount: number) {
+export function encodeDODOV1WithdrawBaseTo(to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,amount]);
   return hexlify(concat(['0x947cf92b', __encodeData]));
 }
 
 /**
  * encode withdrawQuote
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1WithdrawQuote(amount: number) {
+export function encodeDODOV1WithdrawQuote(amount: string) {
   const __encodeData = defaultAbiCoder.encode(["uint256"], [amount]);
   return hexlify(concat(['0xc0a5f6ff', __encodeData]));
 }
@@ -845,10 +845,10 @@ export function encodeDODOV1WithdrawQuote(amount: number) {
 /**
  * encode withdrawQuoteTo
  * @param {string} to - address
- * @param {number} amount - uint256
+ * @param {string} amount - uint256
  * @returns {string} encode data
  */
-export function encodeDODOV1WithdrawQuoteTo(to: string, amount: number) {
+export function encodeDODOV1WithdrawQuoteTo(to: string, amount: string) {
   const __encodeData = defaultAbiCoder.encode(["address","uint256"], [to,amount]);
   return hexlify(concat(['0x108db744', __encodeData]));
 }