Dalam Platform Perdagangan Kuantum FMZ, ia terutamanya melaksanakan pelbagai fungsi, panggilan yang berkaitan dengan blockchain melaluiexchange.IO()Dokumen berikut menerangkanexchange.IO()Cara panggilan sistem penghantaranexchange.IO("abi", ...)fungsi digunakan untuk mendaftarkan ABI.
exchange.IO(k, alamat, abiContent)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"abi"bermaksud bahawa fungsi digunakan untuk mendaftarABI.
k
betul
senar
Peraturanaddressparameter digunakan untuk menentukan alamat kontrak pintar.
alamat
betul
senar
PeraturanabiContentparameter digunakan untuk menentukanABIdaripada kontrak pintar.
abiContent
betul
senar
function main() {
// register Uniswap SwapRouter02 abi
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
// Get the ```ABI``` content of the contract can be obtained with the following URL, taking the ```result``` field only, e.g:
exchange.IO("abi", routerAddress, abi)
}
Kaedah panggilan kontrak pintar tidak perlu didaftarkan jika ia adalah kaedah ERC20 standard.
DapatkanABIkandungan kontrak boleh didapati dengan URL berikut, mengambilresultHanya bidang, contohnya:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
Kaedah panggilanexchange.IO("api", "eth", ...)fungsi digunakan untuk memanggil kaedah Ethereum RPC.
Peraturanexchange.IO("api", "eth", ...)fungsi mengembalikan nilai pulangan kaedah RPC yang dipanggil.
string, nombor, bool, objek, array, null dan semua jenis lain yang disokong oleh sistem
exchange.IO(k, blockChain, rpcMethod)exchange.IO(k, blockChain, rpcMethod,...args)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"api"menunjukkan bahawa fungsi digunakan untuk memperluaskan permintaan panggilan.
k
betul
senar
PeraturanblockChainparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"eth"menunjukkan bahawa fungsi digunakan untuk panggilan kaedah RPC di Rangkaian Ethereum.
blockChain
betul
senar
PerkhidmatanrpcMethodParameter digunakan untuk menetapkan kaedah RPC yang akan dipanggil olehexchange.IO()fungsi.
rpcMethod
betul
senar
Peraturanargparameter digunakan untuk menentukan parameter kaedah RPC yang akan dipanggil.argJenis dan bilanganargparameter bergantung kepada kaedah RPC yang ditentukan olehrpcMethodparameter.
arg
palsu
string, nombor, bool, objek, array, fungsi, null, dan semua jenis lain yang disokong oleh sistem
function main() {
// "owner" needs to be replaced with the specific wallet address
// Parameter labels for the "latest" string position: 'latest', 'earliest' or 'pending', please refrer to https://eth.wiki/json-rpc/API#the-default-block-parameter
// The return value ethBalance is a hexadecimal string: 0x9b19ce56113070
var ethBalance = exchange.IO("api", "eth", "eth_getBalance", "owner", "latest")
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Because of the JavaScript language precision, it is necessary to use the system underlying package function BigInt, BigDecimal to process
// Convert ethBalance to readable amount, 0x9b19ce56113070 to 0.043656995388076145
Log(Number((BigDecimal(BigInt(ethBalance))/BigDecimal(Math.pow(10, ethDecimal))).toString()))
}
Periksa baki ETH dalam dompet anda:
function mian() {
// ETH has a precision unit of 1e18
var ethDecimal = 18
// Number of transfers, readable amount e.g. 0.01 ETH
var sendAmount = 0.01
// Due to the JavaScript language precision, it is necessary to use the system underlying encapsulated functions BigInt, BigDecimal to process, and to convert the readable amount to the data processed on the chain
var toAmount = (BigDecimal(sendAmount)*BigDecimal(Math.pow(10, ethDecimal))).toFixed(0)
// "toAddress" is the address of the recipient's ETH wallet at the time of the transfer, which needs to be filled in specifically, and toAmount is the number of transfers
exchange.IO("api", "eth", "send", "toAddress", toAmount)
}
Untuk pemindahan ETH, anda boleh menetapkan{gasPrice: 11, gasLimit: 111, nonce: 111}parameter, yang ditetapkan pada parameter terakhirexchange.IO()Anda boleh mengabaikannoncedan menggunakan sistem lalai, atau meninggalkangasLimit/gasPrice/noncemematikan dan menggunakan nilai lalai sistem untuk semua.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0)) // 5000000000 , in wei (5 gwei)
}
SoalangasPrice:
function toAmount(s, decimals) {
// The toAmount function can convert hex-encoded values to decimal values
return Number((BigDecimal(BigInt(s))/BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// Coding approve (authorization) method calls
var data = exchange.IO("encode", "0x111111111117dC0aa78b770fA6A738034120C302", "approve", "0xe592427a0aece92de3edee1f18e0157c05861564", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("data:", data)
var gasPrice = exchange.IO("api", "eth", "eth_gasPrice")
Log("gasPrice:", toAmount(gasPrice, 0))
var obj = {
"from" : "0x0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", // walletAddress
"to" : "0x111111111117dC0aa78b770fA6A738034120C302",
"gasPrice" : gasPrice,
"value" : "0x0",
"data" : "0x" + data,
}
var gasLimit = exchange.IO("api", "eth", "eth_estimateGas", obj)
Log("gasLimit:", toAmount(gasLimit, 0))
Log("gas fee", toAmount(gasLimit, 0) * toAmount(gasPrice, 0) / 1e18)
}
Soalaneth_estimateGas:
Parameter keduaexchange.IO()fungsi dengan"eth"boleh langsung memanggil kaedah RPC yang tersedia untuk pelayan node Ethereum.
{@fun BigDecimal}, {@fun BigInt}
Peraturanexchange.IO("encode", ...)fungsi dipanggil untuk pengekodan data.
Peraturanexchange.IO("encode", ...)fungsi mengembalikan data yang dikodkan.
senar
exchange.IO(k, dataFormat,...args)exchange.IO(k, alamat, dataFormat)exchange.IO(k, alamat, dataFormat,...args)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"encode"bermaksud fungsi digunakan untuk pengekodan data.
k
betul
senar
Peraturanaddressparameter digunakan untuk menetapkan alamat kontrak pintar.exchange.IO("encode", ...)Fungsi, melalui dalamaddressparameter menunjukkan pengekodan panggilan kaedah pada kontrak pintar.exchange.IO("encode", ...)fungsi, jikaaddressparameter tidak diteruskan, fungsi ini digunakan untuk mengkod perintah jenis yang ditentukan dan berfungsi bersamaan denganabi.encodedalamSolidity.
alamat
palsu
senar
PeraturandataFormatParameter digunakan untuk menentukan kaedah, jenis, dan urutan data yang dikodkan.
dataFormat
betul
senar
Perkhidmatanargparameter digunakan untuk menentukan nilai data tertentu yang sepadan dengandataFormatMungkin ada lebih daripada satu parameterargparameter, dan jenis dan bilanganargparameter bergantung kepadadataFormattetapan parameter.
arg
palsu
rentetan, nombor, tuple, array, dan semua jenis lain yang disokong oleh sistem
function main() {
// Main network address of ContractV3SwapRouterV2: 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
// Calling the unwrapWETH9 method requires registering the ABI first, which is omitted here
// "owner" represents the wallet address, which need to fill in the specific, 1 represents the number of unpacking, unpacking a WETH into ETH
var data = exchange.IO("encode", "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45", "unwrapWETH9(uint256,address)", 1, "owner")
Log(data)
}
Sebagai contoh, memanggil kaedah pengekodanunwrapWETH9:
function main() {
var x = 10
var address = "0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9"
var str = "Hello World"
var array = [1, 2, 3]
var ret = exchange.IO("encode", "uint256,address,string,uint256[]", x, address, str, array) // uint i.e. uint256 , the type length needs to be specified on FMZ
Log("ret:", ret)
/*
000000000000000000000000000000000000000000000000000000000000000a // x
00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address
0000000000000000000000000000000000000000000000000000000000000080 // Offset of str
00000000000000000000000000000000000000000000000000000000000000c0 // Offset of array
000000000000000000000000000000000000000000000000000000000000000b // The length of str
48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str data
0000000000000000000000000000000000000000000000000000000000000003 // The length of the array
0000000000000000000000000000000000000000000000000000000000000001 // array the first data
0000000000000000000000000000000000000000000000000000000000000002 // array the second data
0000000000000000000000000000000000000000000000000000000000000003 // array the third data
*/
}
Ia sama dengan contoh pengekodanabi.encodedalamSolidity:
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
}
Ia menyokong pengekodan tuple atau urutan jenis yang mengandungi tuple.
Perintah jenis ini terdiri daripada:tuple, bytes, jadi apabila memanggilexchange.IO()untuk pengekodan, anda perlu terus lulus dua parameter:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Parameter yang dihantar juga harus konsisten dengan struktur dan jenistuple, seperti yang ditakrifkan dalamtypesParameter borang:tuple(a uint256,b uint8,c address).
bytes:"0011"
function main() {
var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"] // ETH address, USDT address
var ret = exchange.IO("encode", "address[]", path)
Log("encode: ", ret)
}
Ia menyokong pengekodan berurutan array atau jenis yang mengandungi array:
Peraturanexchange.IO()fungsi merangkumiencodekaedah, yang boleh mengembalikan kod panggilan fungsi kehexUntuk kegunaan khusus, anda boleh merujuk kepada platform
Peraturanexchange.IO("encodePacked", ...)fungsi dipanggil dengan cara yang digunakan untukencodePacked encoding.
Peraturanexchange.IO("encodePacked", ...)fungsi mengembalikanencodePackeddata dikodkan.
senar
exchange.IO(k, dataFormat,...args)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"encodePacked"bermaksud bahawa fungsi digunakan untuk dataencodePackedpengekodan.
k
betul
senar
PeraturandataFormatparameter digunakan untuk menentukan jenis dan urutanencodePackeddata dikodkan.
dataFormat
betul
senar
Peraturanargparameter digunakan untuk menentukan nilai data tertentu yang sepadan dengandataFormatMungkin ada lebih daripada satu parameterargparameter, dan jenis dan bilanganargparameter bergantung kepadadataFormattetapan parameter.
arg
betul
rentetan, nombor, tuple, array, dan semua jenis lain yang disokong oleh sistem
function main() {
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
var tokenOutAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
}
Apabila digunakanUniswap V3, anda perlu lulus dalam parameter seperti laluan pertukaran, anda perlu menggunakanencodePackedOperasi pengekodan:
Peraturanexchange.IO("decode", ...)Fungsi dipanggil dengan cara yang digunakan untuk mendekod.
Peraturanexchange.IO("decode", ...)fungsi mengembalikan data yang telah didekodkan. Mengembalikan rentetan apabila hanya ada satu data yang ditentukan olehdataFormatMengembalikan array apabila terdapat lebih daripada satu data yang ditentukan olehdataFormatparameter.
arrayćstring
exchange.IO(k, dataFormat, data)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, dan menetapkannya kepada"decode"bermaksud bahawa fungsi digunakan untuk mendekod data.
k
betul
senar
PeraturandataFormatParameter digunakan untuk menentukan jenis dan urutan data yang didekodkan.
dataFormat
betul
senar
Perkhidmatandataparameter digunakan untuk menetapkan data yang akan didekodkan.
data
betul
senar
function main() {
var types = "tuple(a uint256,b uint8,c address),bytes"
var ret = exchange.IO("encode", types, {
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}, "0011")
Log("encode: ", ret)
var rawData = exchange.IO("decode", types, ret)
Log("decode:", rawData)
}
Pengoperasian terbalikexchange.IO("encode", ...)fungsi:
function main() {
// register SwapRouter02 abi
var walletAddress = "0x398a93ca23CBdd2642a07445bCD2b8435e0a373f"
var routerAddress = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var abi = `[{"inputs":[{"components":[{"internalType":"bytes","name":"path","type":"bytes"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"amountInMaximum","type":"uint256"}],"internalType":"struct IV3SwapRouter.ExactOutputParams","name":"params","type":"tuple"}],"name":"exactOutput","outputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"}],"stateMutability":"payable","type":"function"}]`
exchange.IO("abi", routerAddress, abi) // abi only uses the contents of the local exactOutput method, the full abi can be searched on the Internet
// encode path
var fee = exchange.IO("encodePacked", "uint24", 3000)
var tokenInAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
var tokenOutAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var path = tokenInAddress.slice(2).toLowerCase()
path += fee + tokenOutAddress.slice(2).toLowerCase()
Log("path:", path)
var dataTuple = {
"path" : path,
"recipient" : walletAddress,
"amountOut" : 1000,
"amountInMaximum" : 1,
}
// encode SwapRouter02 exactOutput
var rawData = exchange.IO("encode", routerAddress, "exactOutput", dataTuple)
Log("method hash:", rawData.slice(0, 8)) // 09b81346
Log("params hash:", rawData.slice(8))
// decode exactOutput params
var decodeRaw = exchange.IO("decode", "tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)", rawData.slice(8))
Log("decodeRaw:", decodeRaw)
}
Contoh berikut pertama melakukanencodePackedoperasi padapathpemprosesan parameter, keranaexactOutputpanggilan kaedah yang perlu dikodkan kemudian memerlukanpathsebagai parameter. KemudianencodeKesemuaexactOutputkaedah kontrak laluan, yang hanya mempunyai satu parameter jenistuple. Nama kaedahexactOutputdikodkan sebagai:0x09b81346, dan menggunakanexchange.IO("decode", ...)kaedah untuk memecahkan kod hasildecodeRaw, konsisten dengan pembolehubahdataTuple.
Untuk pemprosesan data,exchange.IO()Fungsi menyokong bukan sahaja pengekodan, tetapi juga dekod.
Peraturanexchange.IO("key", ...)fungsi dipanggil dengan cara untuk menukar kunci peribadi.
exchange.IO(k, kunci)
Parameterkdigunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"key"bermakna fungsi digunakan untuk menukar kunci peribadi.
k
betul
senar
PeraturankeyParameter digunakan untuk menetapkan kunci peribadi.
kunci
betul
senar
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Peraturanexchange.IO()fungsi menyokong menukar kunci peribadi dan ia boleh memanipulasi pelbagai alamat dompet. Ia juga mungkin untuk menambah pelbagai objek pertukaran (lihat: {@var/EXCHANGE/exchanges exchanges}) untuk memanipulasi pelbagai alamat dompet.
Peraturanexchange.IO("api", ...)fungsi dipanggil dengan cara yang digunakan untuk memanggil kaedah kontrak pintar.
Peraturanexchange.IO("api", ...)fungsi mengembalikan nilai pulangan kaedah kontrak pintar yang dipanggil.
string, nombor, bool, objek, array, null dan semua jenis lain yang disokong oleh sistem
exchange.IO(k, alamat, kaedah)exchange.IO(k, alamat, kaedah,... args)exchange.IO(k, alamat, kaedah, nilai,... args)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"api"menunjukkan bahawa fungsi digunakan untuk memperluaskan permintaan panggilan.
k
betul
senar
Peraturanaddressparameter digunakan untuk menentukan alamat kontrak pintar.
alamat
betul
senar
Peraturanmethodparameter digunakan untuk menentukan kaedah kontrak pintar yang akan dipanggil.
kaedah
betul
senar
Perkhidmatanvalueparameter digunakan untuk menetapkan jumlah ETH yang akan dihantar.stateMutabilityatribut kaedah kontrak pintar yang akan dilaksanakan adalahpayable, kemudianvalueparameter perlu lulus."stateMutability": "payable"Atribut boleh dilihat dari ABI.exchange.IO()fungsi akan menentukan parameter yang diperlukan berdasarkanstateMutabilityAtribut dalam ABI yang telah didaftarkan.stateMutabilityatribut adalahnonpayable, kemudianvalueParameter tidak perlu dihantar.
nilai
palsu
nombor,string
Peraturanargparameter digunakan untuk menentukan parameter kaedah kontrak pintar yang akan dipanggil.argparameter, dan jenis dan bilanganargparameter bergantung kepada kaedah kontrak pintar yang akan dipanggil.
arg
palsu
rentetan, nombor, bool, dan semua jenis lain yang disokong oleh sistem
function main(){
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302" // The contract address of the token, the token is 1INCH in the example
Log(exchange.IO("api", tokenAddress, "decimals")) // Query, print 1INCH tokens with precision index of 18
}
Peraturandecimalskaedah adalahconstantkaedah ERC20 yang tidak menimbulkan penggunaan gas dan ia boleh menyoal data ketepatan token.decimalsNilai pulangan: data ketepatan token.
function main(){
// The contract address of the token, in the example the token is 1INCH
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// For example, the query yields 1000000000000000000, divided by the precision unit of the token 1e18, the wallet to which the current exchange object is bound has authorized 1 1INCH to the spender address
Log(exchange.IO("api", tokenAddress, "allowance", "owner", "spender"))
}
Peraturanallowancekaedah adalahconstantkaedah ERC20 yang tidak menjana penggunaan gas dan boleh pertanyaan jumlah yang dibenarkan token untuk alamat kontrak tertentu.allowancekaedah mengambil 2 parameter, yang pertama adalah alamat dompet dan yang kedua adalah alamat yang dibenarkan.
owner: alamat dompet, contoh digantikan dengan rentetan spender: alamat kontrak yang dibenarkan, contoh digantikan oleh rentetan Uniswap V3 router v1 address.
function main(){
// The contract address of the token, the token is 1INCH in the example
var tokenAddress = "0x111111111117dC0aa78b770fA6A738034120C302"
// The hexadecimal string of the authorization amount: 0xde0b6b3a7640000 , the corresponding decimal string: 1e18 , 1e18 divided by the precision unit of the token, i.e. 1 token amount, so this refers to the authorization of one token
Log(exchange.IO("api", tokenAddress, "approve", "spender", "0xde0b6b3a7640000"))
}```
The ```approve``` method is a non-```constant``` method of ERC20, which generates gas consumption and is used to authorize the operation amount of a token to a contract address. The ```approve``` method takes 2 parameters, the first one is the address to be authorized and the second one is the amount to be authorized. Return value: txid.
```spender```: the address of the authorized contract, the example is replaced by the string "spender", the actual use needs to fill in the specific address, for example, it can be ```Uniswap V3 router v1``` address. ```0xde0b6b3a7640000```: the number of authorizations, here is the hexadecimal string, the corresponding decimal value is 1e18, divided by the token precision unit in the example (i.e. 1e18). The result is that 1 token is authorized. The third parameter of the ```exchange.IO()``` function is passed to the method name ```approve```, which can also be written in the form of methodId, such as "0x571ac8b0". It is also possible to write the full standard method name, for example: "approve(address,uint256)".
```javascript
function main() {
var ContractV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var tokenInName = "ETH"
var amountIn = 0.01
var options = {gasPrice: 5000000000, gasLimit: 21000, nonce: 100} // This is an example, depending on the actual scene settings
var data = "" // The encoded data, here is the empty string, depending on the actual scene settings
var tx = exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", (tokenInName == 'ETH' ? amountIn : 0), (new Date().getTime() / 1000) + 3600, data, options || {})
}
Peraturanmulticallkaedah adalah bukan-constantkaedahUniswap V3yang menjana penggunaan gas dan digunakan untuk menebus token dengan pelbagai cara.
Perkhidmatanmulticallkaedah boleh mempunyai pelbagai cara untuk lulus parameter, anda boleh memeriksa ABI yang mengandungi kaedah secara khusus, anda perlu mendaftar ABI sebelum memanggil kaedah.
Untuk contoh khususmulticallanda boleh merujuk kepada platform
Beberapa butiran diterangkan di sini menggunakan kod palsu:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: alamat penghala v2 Uniswap V3.value: jumlah ETH untuk dipindahkan, ditetapkan kepada 0 jika token dalam operasi pertukaran bukan ETH.deadline: deadlineialah parametermulticallkaedah, yang boleh ditetapkan kepada (new Date().getTime() / 1000) + 3600, menunjukkan bahawa ia sah selama satu jam.data: dataialah parametermulticallkaedah, data operasi pembungkusan yang akan dilakukan.
Sama sepertiexchange.IO("api", "eth", "send", "toAddress", toAmount), yanggasLimit/gasPrice/noncetetapan panggilan kaedah boleh ditentukan apabila memanggilmulticallkaedah.
Sekali lagi, kita menggunakan kod palsu untuk menerangkan:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Parameter{gasPrice: 11, gasLimit: 111, nonce: 111}boleh ditetapkan mengikut keperluan khusus, yang ditetapkan kepada parameter terakhirexchange.IO()fungsi.
Anda boleh terlepasnoncedan menggunakan sistem nilai lalai, atau meninggalkangasLimit/gasPrice/noncemematikan dan menggunakan nilai lalai sistem untuk semua.
Peraturanexchange.IO("address")fungsi dipanggil sedemikian rupa untuk mendapatkan alamat dompet yang dikonfigurasikan oleh objek pertukaran {@var/EXCHANGE exchange}.
Peraturanexchange.IO("address")fungsi mengembalikan alamat dompet yang dikonfigurasikan.
senar
exchange.IO(k)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"address"bermaksud bahawa fungsi digunakan untuk mendapatkan alamat dompet yang dikonfigurasikan.
k
betul
senar
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Peraturanexchange.IO("base", ...)fungsi dipanggil dengan cara untuk menetapkan alamat nod RPC.
exchange.IO(k, alamat)
Peraturankparameter digunakan untuk menetapkan fungsiexchange.IO()fungsi, ditetapkan kepada"base"bermaksud fungsi digunakan untuk menukar nod RPC.
k
betul
senar
Peraturanaddressparameter digunakan untuk menetapkan alamat nod RPC.
alamat
betul
senar
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}