Dalam Platform Perdagangan Kuantum FMZ, terutama menerapkan berbagai fungsi, panggilan terkait dengan blockchain melaluiexchange.IO()Dokumen berikut menggambarkanexchange.IO()metode panggilan dariexchange.IO("abi", ...)fungsi digunakan untuk mendaftarkan ABI.
exchange.IO(k, alamat, abiContent)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"abi"berarti bahwa fungsi ini digunakan untuk mendaftarABIAku tidak tahu.
k
benar
string
PeraturanaddressParameter digunakan untuk menentukan alamat kontrak pintar.
alamat
benar
string
PeraturanabiContentparameter digunakan untuk menentukanABIdari kontrak pintar.
abiContent
benar
string
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)
}
Metode panggilan kontrak pintar tidak perlu didaftarkan jika metode ERC20 standar.
DapatkanABIisi kontrak dapat diperoleh dengan URL berikut, mengambilresulthanya bidang, misalnya:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
Metode panggilan dariexchange.IO("api", "eth", ...)fungsi digunakan untuk memanggil metode Ethereum RPC.
Peraturanexchange.IO("api", "eth", ...)fungsi mengembalikan nilai yang dikembalikan dari metode RPC yang disebut.
string, number, bool, object, array, null dan semua tipe lain yang didukung oleh sistem
exchange.IO(k, blockChain, rpcMethod)exchange.IO(k, blockChain, rpcMethod,...args)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"api"menunjukkan bahwa fungsi digunakan untuk memperluas permintaan panggilan.
k
benar
string
PeraturanblockChainparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"eth"menunjukkan bahwa fungsi ini digunakan untuk panggilan metode RPC di Jaringan Ethereum.
blockChain
benar
string
PeraturanrpcMethodParameter digunakan untuk mengatur metode RPC yang akan dipanggil olehexchange.IO()fungsi.
rpcMethod
benar
string
Peraturanargparameter digunakan untuk menentukan parameter metode RPC yang akan dipanggil.argJenis dan jumlahargparameter tergantung pada metode RPC yang ditentukan olehrpcMethodParameter.
arg
palsu
string, number, bool, object, array, function, null, dan semua tipe lain yang didukung 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 saldo ETH di 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 transfer ETH, Anda dapat mengatur{gasPrice: 11, gasLimit: 111, nonce: 111}parameter, yang ditetapkan pada parameter terakhir dariexchange.IO()Anda dapat melewatkannoncedan menggunakan sistem default, atau meninggalkangasLimit/gasPrice/nonceUnduh dan gunakan nilai default 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)
}
PertanyaangasPrice:
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)
}
Pertanyaaneth_estimateGas:
Parameter kedua dariexchange.IO()fungsi dengan"eth"dapat langsung memanggil metode RPC yang tersedia untuk server node Ethereum.
{@fun BigDecimal}, {@fun BigInt}
Peraturanexchange.IO("encode", ...)fungsi dipanggil untuk pengkodean data.
Peraturanexchange.IO("encode", ...)fungsi mengembalikan data yang dikodekan.
string
exchange.IO(k, dataFormat,...args)exchange.IO(k, alamat, dataFormat)exchange.IO(k, alamat, dataFormat,...args)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"encode"berarti fungsi digunakan untuk pengkodean data.
k
benar
string
Peraturanaddressparameter digunakan untuk mengatur alamat kontrak pintar.exchange.IO("encode", ...)fungsi, melewati dalamaddressparameter menunjukkan pengkodean metode panggilan pada kontrak pintar.exchange.IO("encode", ...)fungsi, jikaaddressparameter tidak dilewati, fungsi ini digunakan untuk mengkode urutan jenis yang ditentukan dan secara fungsional setara denganabi.encodedalamSolidityAku tidak tahu.
alamat
palsu
string
PeraturandataFormatParameter digunakan untuk menentukan metode, jenis, dan urutan data yang dikodekan.
dataFormat
benar
string
Peraturanargparameter digunakan untuk menentukan nilai data spesifik yang sesuai dengandataFormatMungkin ada lebih dari satu parameterargparameter, dan jenis dan jumlahargparameter tergantung padadataFormatpengaturan parameter.
arg
palsu
string, number, tuple, array, dan semua jenis lain yang didukung 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)
}
Misalnya, memanggil metode pengkodeanunwrapWETH9:
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
*/
}
Ini setara dengan contoh pengkodean dariabi.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)
}
Ini mendukung pengkodean tuple atau urutan tipe yang berisi tuple.
Urutan jenis ini terdiri dari:tuple, bytes, jadi ketika meneleponexchange.IO()untuk pengkodean, Anda perlu terus melewati dua parameter:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Parameter yang diberikan juga harus konsisten dengan struktur dan jenistuple, sebagaimana didefinisikan dalamtypesParameter dari formulir: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)
}
Ini mendukung untuk pengkodean berurutan array atau jenis yang mengandung array:
Peraturanexchange.IO()fungsi merangkumencodemetode, yang dapat mengembalikan kode panggilan fungsi kehexUntuk penggunaan khusus, Anda dapat merujuk ke platform yang tersedia untuk umum
Peraturanexchange.IO("encodePacked", ...)fungsi dipanggil dengan cara yang digunakan untukencodePacked encoding.
Peraturanexchange.IO("encodePacked", ...)fungsi mengembalikanencodePackeddata terenkripsi.
string
exchange.IO(k, dataFormat,...args)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"encodePacked"berarti bahwa fungsi digunakan untuk dataencodePackedmengkodekan.
k
benar
string
PeraturandataFormatparameter digunakan untuk menentukan jenis dan urutanencodePackeddata terenkripsi.
dataFormat
benar
string
Peraturanargparameter digunakan untuk menentukan nilai data spesifik yang sesuai dengandataFormatMungkin ada lebih dari satu parameterargparameter, dan jenis dan jumlahargparameter tergantung padadataFormatpengaturan parameter.
arg
benar
string, number, tuple, array, dan semua jenis lain yang didukung 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)
}
Saat digunakanUniswap V3, Anda perlu untuk lulus dalam parameter seperti jalur pertukaran, Anda perlu menggunakanencodePackedoperasi pengkodean:
Peraturanexchange.IO("decode", ...)fungsi dipanggil dengan cara yang digunakan untuk dekoding.
Peraturanexchange.IO("decode", ...)fungsi mengembalikan data yang didekode. Mengembalikan string ketika hanya ada satu data yang ditentukan olehdataFormatMengembalikan array ketika ada lebih dari satu data yang ditentukan olehdataFormatParameter.
arrayćstring
exchange.IO(k, data)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, dan mengaturnya ke"decode"berarti bahwa fungsi digunakan untuk dekoding data.
k
benar
string
PeraturandataFormatParameter digunakan untuk menentukan jenis dan urutan data yang didekode.
dataFormat
benar
string
PeraturandataParameter digunakan untuk mengatur data yang akan didekode.
data
benar
string
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)
}
Operasi terbalik dariexchange.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 padapathproses parameter, karenaexactOutputpanggilan metode yang perlu dikodekan kemudian membutuhkanpathsebagai parameter. KemudianencodeyangexactOutputmetode kontrak rute, yang hanya memiliki satu parameter jenistuple. Nama metodeexactOutputdikodekan sebagai:0x09b81346, dan menggunakanexchange.IO("decode", ...)metode untuk mendekode hasildecodeRaw, konsisten dengan variabeldataTuple.
Untuk pengolahan data,exchange.IO()fungsi mendukung tidak hanya pengkodean, tetapi juga dekodean.
Peraturanexchange.IO("key", ...)fungsi dipanggil dengan cara untuk beralih kunci pribadi.
exchange.IO(k, kunci)
Parameterkdigunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"key"berarti fungsi digunakan untuk beralih kunci pribadi.
k
benar
string
PeraturankeyParameter digunakan untuk mengatur kunci pribadi.
kunci
benar
string
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Peraturanexchange.IO()fungsi mendukung beralih kunci pribadi dan dapat memanipulasi beberapa alamat dompet.
Peraturanexchange.IO("api", ...)fungsi dipanggil dengan cara yang digunakan untuk memanggil metode kontrak pintar.
Peraturanexchange.IO("api", ...)fungsi mengembalikan nilai yang dikembalikan dari metode yang disebut kontrak pintar.
string, number, bool, object, array, null dan semua tipe lain yang didukung oleh sistem
exchange.IO(k, alamat, metode)exchange.IO(k, alamat, metode,... args)exchange.IO(k, alamat, metode, nilai,... args)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"api"menunjukkan bahwa fungsi digunakan untuk memperluas permintaan panggilan.
k
benar
string
PeraturanaddressParameter digunakan untuk menentukan alamat kontrak pintar.
alamat
benar
string
PeraturanmethodParameter digunakan untuk menentukan metode kontrak pintar yang akan dipanggil.
metode
benar
string
Peraturanvalueparameter digunakan untuk mengatur jumlah ETH yang akan dikirim.stateMutabilityAtribut metode kontrak pintar yang akan dieksekusi adalahpayable, kemudianvalueParameter harus dilewati."stateMutability": "payable"Atribut dapat dilihat dari ABI.exchange.IO()fungsi akan menentukan parameter yang diperlukan berdasarkanstateMutabilityAtribut dalam ABI yang telah terdaftar.stateMutabilityatribut adalahnonpayable, kemudianvalueParameter tidak perlu dilewati.
nilai
palsu
nomor, string
Peraturanargparameter digunakan untuk menentukan parameter metode kontrak pintar yang akan dipanggil.argparameter, dan jenis dan jumlahargparameter tergantung pada metode kontrak pintar yang akan dipanggil.
arg
palsu
string, number, bool, dan semua jenis lain yang didukung 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
}
Peraturandecimalsmetode adalahconstantmetode ERC20 yang tidak menimbulkan konsumsi gas dan dapat menanyakan data presisi token.decimalsNilai pengembalian: data presisi 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"))
}
Peraturanallowancemetode adalahconstantmetode ERC20 yang tidak menghasilkan konsumsi gas dan dapat menanyakan jumlah yang sah dari token untuk alamat kontrak tertentu.allowancemetode mengambil 2 parameter, yang pertama adalah alamat dompet dan yang kedua adalah alamat otorisasi.
owner: alamat dompet, contohnya diganti dengan string spender: alamat kontrak yang sah, contohnya digantikan oleh string 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 || {})
}
Peraturanmulticallmetode ini adalah non-constantmetodeUniswap V3yang menghasilkan konsumsi gas dan digunakan untuk menebus token dengan berbagai cara.
Peraturanmulticallmetode mungkin memiliki berbagai cara untuk melewati parameter, Anda dapat memeriksa ABI yang berisi metode secara khusus, Anda perlu mendaftarkan ABI sebelum memanggil metode.
Untuk contoh spesifik darimulticallmetode panggilan, Anda dapat merujuk ke platform yang tersedia untuk umum
Beberapa detail dijelaskan di sini menggunakan pseudo-kode:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: alamat router v2 dari Uniswap V3.value: jumlah ETH yang akan ditransfer, ditetapkan menjadi 0 jika tokenIn token dari operasi pertukaran bukan ETH.deadline: deadlineadalah parameter darimulticallmetode, yang dapat diatur untuk (new Date().getTime() / 1000) + 3600, menunjukkan bahwa itu berlaku selama satu jam.data: dataadalah parameter darimulticallmetode, data dari operasi pengemasan yang akan dilakukan.
Mirip denganexchange.IO("api", "eth", "send", "toAddress", toAmount), yanggasLimit/gasPrice/noncepengaturan panggilan metode dapat ditentukan saat memanggilmulticallmetode.
Sekali lagi, kita menggunakan pseudo-kode untuk menggambarkan:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Parameter{gasPrice: 11, gasLimit: 111, nonce: 111}dapat diatur sesuai dengan kebutuhan khusus, yang diatur ke parameter terakhir dariexchange.IO()fungsi.
Anda bisa melewatkannoncedan menggunakan sistem default nilai, atau meninggalkangasLimit/gasPrice/nonceUnduh dan gunakan nilai default sistem untuk semua.
Peraturanexchange.IO("address")fungsi dipanggil sedemikian rupa untuk mendapatkan alamat dompet yang dikonfigurasi oleh objek pertukaran {@var/EXCHANGE exchange}.
Peraturanexchange.IO("address")fungsi mengembalikan alamat dompet yang dikonfigurasi.
string
exchange.IO(k)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"address"berarti bahwa fungsi ini digunakan untuk mendapatkan alamat dompet yang dikonfigurasi.
k
benar
string
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 mengatur alamat node RPC.
exchange.IO(k, alamat)
Peraturankparameter digunakan untuk mengatur fungsi dariexchange.IO()fungsi, diatur untuk"base"berarti fungsi digunakan untuk beralih node RPC.
k
benar
string
PeraturanaddressParameter digunakan untuk mengatur alamat node RPC.
alamat
benar
string
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}