In der FMZ Quant Trading Plattform implementiert es hauptsächlich verschiedene Funktionen, Anrufe im Zusammenhang mit Blockchain überexchange.IO()Das folgende Dokument beschreibt dieexchange.IO()Die Anrufmethode derexchange.IO("abi", ...)Die Funktion wird zur Registrierung eines ABI verwendet.
exchange.IO(k, Adresse, abiInhalt)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"abi"bedeutet, dass die Funktion zur Registrierung verwendet wirdABI- Ich weiß.
k
wahr
String
DieaddressDer Parameter wird verwendet, um die Adresse des Smart Contracts anzugeben.
Anschrift
wahr
String
DieabiContentParameter wird verwendet, um dieABIder Smart Contract.
abiInhalt
wahr
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)
}
Die Methoden zum Aufrufen von Smart Contracts müssen nicht registriert werden, wenn es sich um Standardmethoden von ERC20 handelt.
Holen Sie dieABIDer Inhalt des Auftrags kann unter folgender URL abgerufen werden:resultnur Feld, z. B.:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
Die Anrufmethode vonexchange.IO("api", "eth", ...)Die Funktion wird verwendet, um die Methode Ethereum RPC aufzurufen.
Dieexchange.IO("api", "eth", ...)Funktion gibt den Rückgabewert der genannten RPC-Methode zurück.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
exchange.IO(k, BlockChain, rpcMethode)exchange.IO(k, BlockChain, rpcMethode,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"api"zeigt an, dass die Funktion zur Erweiterung der Anrufanfrage verwendet wird.
k
wahr
String
DieblockChainParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"eth"zeigt an, dass die Funktion für Anrufe der RPC-Methode im Ethereum-Netzwerk verwendet wird.
BlockChain
- Das stimmt.
String
DierpcMethodParameter wird verwendet, um die von derexchange.IO()Funktion.
rpcMethode
wahr
String
DieargParameter wird verwendet, um die Parameter der zu aufrufenden RPC-Methode anzugeben.argDie Art und Anzahl derargDie Parameter hängen von der von derrpcMethodParameter.
Arg
falsche
String, number, bool, object, array, function, null und alle anderen vom System unterstützten Typen
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()))
}
Überprüfen Sie den ETH-Guthaben in Ihrer Brieftasche:
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)
}
Für ETH-Überweisungen können Sie die{gasPrice: 11, gasLimit: 111, nonce: 111}Parameter, der auf den letzten Parameter desexchange.IO()Sie können dienonceund verwenden Sie die System-Standard, oder lassengasLimit/gasPrice/nonceDeaktivieren und verwenden Sie den Systemstandardwert für alle.
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)
}
AbfragegasPrice:
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)
}
Abfrageeth_estimateGas:
Der zweite Parameter derexchange.IO()Funktion mit"eth"kann direkt die RPC-Methoden aufrufen, die dem Ethereum-Node-Server zur Verfügung stehen.
Ich habe dich nicht gesehen.
Dieexchange.IO("encode", ...)Die Funktion wird für die Datenkodierung aufgerufen.
Dieexchange.IO("encode", ...)Funktion gibt die codierten Daten zurück.
String
exchange.IO(k, Datenformat,...args)exchange.IO(k, Adresse, Datenformat)exchange.IO(k, Adresse, Datenformat,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"encode"bedeutet, dass die Funktion für die Datenkodierung verwendet wird.
k
wahr
String
DieaddressDie Parameter werden verwendet, um die Adresse des Smart Contracts festzulegen.exchange.IO("encode", ...)Funktion, die in deraddressDer Parameter zeigt die Codierung der Methode auf dem Smart Contract an.exchange.IO("encode", ...)Funktion, wennaddresswenn der Parameter nicht übergeben wird, wird die Funktion verwendet, um die angegebene Typfolge zu kodieren, und ist funktionell gleichwertig mitabi.encodeinSolidity- Ich weiß.
Anschrift
falsche
String
DiedataFormatDer Parameter wird verwendet, um die Methode, den Typ und die Reihenfolge der codierten Daten anzugeben.
DatenFormat
- Das stimmt.
String
DieargParameter wird verwendet, um den spezifischen Datenwert anzugeben, der demdataFormatEs kann mehr als eineargParameter und die Art und Anzahl derargParameter hängen von derdataFormatEinstellung der Parameter.
Arg
falsche
String, number, tuple, array und alle anderen vom System unterstützten Typen
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)
}
Zum Beispiel, rufen Sie die CodierungsmethodeunwrapWETH9:
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
*/
}
Es ist gleichbedeutend mit dem Codierungsbeispiel vonabi.encodeinSolidity:
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)
}
Es unterstützt die Codierung eines Tupels oder einer Typreihenfolge, die ein Tupel enthält.
Diese Typordnung besteht austuple, bytesAlso, wenn Sie anrufenexchange.IO()Für die Kodierung müssen Sie zwei Parameter weitergeben:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Die eingegebenen Parameter müssen auch mit der Struktur und dem Typ dertuple, wie sie in dertypesParameter des Formulars: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)
}
Es unterstützt die sequentielle Codierung von Arrays oder Arraytypen, die Arrays enthalten:
Dieexchange.IO()Funktion umfasst dieencodeMethode, die den Funktionsanrufcode zurückgeben kannhexFür spezifische Anwendungen können Sie sich auf die öffentlich zugänglichen Plattformen beziehen
Dieexchange.IO("encodePacked", ...)Funktion wird auf eine Weise aufgerufen, die für verwendet wirdencodePacked encoding.
Dieexchange.IO("encodePacked", ...)Funktion gibt dieencodePackedverschlüsselte Daten.
String
exchange.IO(k, Datenformat,...args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"encodePacked"bedeutet, dass die Funktion für Daten verwendet wirdencodePackedVerschlüsselung.
k
wahr
String
DiedataFormatDer Parameter wird verwendet, um den Typ und die Reihenfolge derencodePackedverschlüsselte Daten.
DatenFormat
wahr
String
DieargParameter wird verwendet, um den spezifischen Datenwert anzugeben, der demdataFormatEs kann mehr als eineargParameter und die Art und Anzahl derargParameter hängen von derdataFormatEinstellung der Parameter.
Arg
- Das stimmt.
String, number, tuple, array und alle anderen vom System unterstützten Typen
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)
}
Bei AnwendungUniswap V3, müssen Sie in den Parametern wie den Austausch Pfad passieren, müssen Sie dieencodePackedCodierung:
Dieexchange.IO("decode", ...)Funktion wird auf eine Art und Weise aufgerufen, die für die Entschlüsselung verwendet wird.
Dieexchange.IO("decode", ...)Funktion gibt die entschlüsselten Daten zurück. Gibt eine Zeichenkette zurück, wenn nur ein von derdataFormatParameter. Gibt ein Array zurück, wenn mehr als ein von derdataFormatParameter.
- Das ist nicht wahr.
exchange.IO(k, Daten)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion und Einstellung auf"decode"bedeutet, dass die Funktion zur Datenentzifferung verwendet wird.
k
wahr
String
DiedataFormatDer Parameter wird verwendet, um den Typ und die Reihenfolge der entschlüsselten Daten anzugeben.
DatenFormat
- Das stimmt.
String
DiedataDer Parameter wird verwendet, um die zu entschlüsselnden Daten festzulegen.
Daten
wahr
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)
}
Umgekehrter Betrieb derexchange.IO("encode", ...)Funktion:
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)
}
Das folgende Beispiel führt zunächst eineencodePackedBetrieb auf derpathParameterverarbeitung, weil dieexactOutputMethodenanruf, der später codiert werden muss, erfordertpathals Parameter. DannencodeDieexactOutputMethode des Routingvertrags, die nur einen Parameter des Typs enthälttuple. Die MethodenbezeichnungexactOutputwird als0x09b81346, und mit Hilfe derexchange.IO("decode", ...)Methode zur Entschlüsselung der resultierendendecodeRaw, entsprechend der VariablendataTuple.
Für die Datenverarbeitung werden dieexchange.IO()Funktion unterstützt nicht nur die Kodierung, sondern auch die Entschlüsselung.
Dieexchange.IO("key", ...)Die Funktion wird so aufgerufen, dass private Schlüssel gewechselt werden können.
exchange.IO(K, Taste)
Der Parameterkwird verwendet, um die Funktion derexchange.IO()Funktion, auf"key"bedeutet, dass die Funktion zum Umschalten des privaten Schlüssels verwendet wird.
k
wahr
String
DiekeyParameter wird verwendet, um den privaten Schlüssel festzulegen.
Schlüssel
wahr
String
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Dieexchange.IO()Die Funktion unterstützt das Wechseln privater Schlüssel und kann mehrere Wallet-Adressen manipulieren.
Dieexchange.IO("api", ...)Funktion wird auf eine Weise aufgerufen, die verwendet wird, um die Methoden des Smart Contracts aufzurufen.
Dieexchange.IO("api", ...)Funktion gibt den Rückgabewert der sogenannten Smart-Contract-Methode zurück.
String, number, bool, object, array, null und alle anderen vom System unterstützten Typen
exchange.IO(k, Anschrift, Methode)exchange.IO(k, Anschrift, Methode,... args)exchange.IO(k, Anschrift, Methode, Wert,... args)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"api"zeigt an, dass die Funktion zur Erweiterung der Anrufanfrage verwendet wird.
k
wahr
String
DieaddressDer Parameter wird verwendet, um die Adresse des Smart Contracts anzugeben.
Anschrift
wahr
String
DiemethodDer Parameter wird verwendet, um die Methode des zu aufrufenden Smart Contracts anzugeben.
Methode
- Das stimmt.
String
DievalueDer ETH-Parameter wird verwendet, um den zu versendenden ETH-Betrag festzulegen.stateMutabilityAttribut der auszuführenden Smart Contract-Methode istpayable, dann dievalueDer Parameter muss übergeben werden."stateMutability": "payable"Das Attribut kann im ABI angezeigt werden.exchange.IO()Funktion wird den erforderlichen Parameter auf der Grundlage derstateMutabilityDas ist ein Attribut in der ABI, das registriert wurde.stateMutabilityAttribut istnonpayable, dann dievalueParameter muss nicht übergeben werden.
Wert
falsche
Zahl, Zeichenfolge
DieargParameter wird verwendet, um die Parameter der Methode des zu aufrufenden Smart Contracts anzugeben.argParameter und die Art und Anzahl derargParameter hängen von der Methode des zu aufrufenden Smart Contracts ab.
Arg
falsche
String, number, bool und alle anderen vom System unterstützten Typen
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
}
DiedecimalsMethode ist eineconstantDie ERC20-Technologie ist eine Methode, die keinen Gasverbrauch verursacht und die Präzisionsdaten eines Tokens abfragen kann.decimalsRückgabewert: die Präzisionsdaten des Tokens.
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"))
}
DieallowanceMethode ist eineconstantDie ERC20-Methode, die keinen Gasverbrauch erzeugt und den zugelassenen Betrag eines Tokens für eine bestimmte Vertragsadresse abfragen kann.allowanceDie Methode nimmt 2 Parameter an, der erste ist die Wallet-Adresse und der zweite die autorisierte Adresse.
owner: die Adresse der Brieftasche, das Beispiel wird durch die Zeichenfolge spender: die Adresse des genehmigten Auftrags, das Beispiel wird durch die Zeichenfolge 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 || {})
}
DiemulticallDie Methode ist nichtconstantVerfahren derUniswap V3die Gasverbrauch erzeugt und zur Einlösung von Token auf verschiedene Arten verwendet wird.
DiemulticallMethode kann verschiedene Möglichkeiten haben, Parameter zu übergeben, Sie können die ABI überprüfen, die die Methode speziell enthält, Sie müssen die ABI registrieren, bevor Sie die Methode aufrufen.
Für konkrete BeispielemulticallSie können sich auf die öffentlich zugänglichen Plattformen beziehen.
Einige Details werden hier mit Pseudo-Code beschrieben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: Adresse des Routers v2 von Uniswap V3.value: der zu übertragende Betrag an ETH, der auf 0 festgelegt ist, wenn das TokenIn-Token der Börsengeschäft nicht ETH ist.deadline: deadlineist der Parameter dermulticallMethode, die auf (neues Datum (().getTime (()) / 1000) + 3600 eingestellt werden kann, was anzeigt, dass sie für eine Stunde gültig ist.data: dataist der Parameter dermulticallMethode, die Daten des zu durchführenden Verpackungsverfahrens.
Ähnlich wieexchange.IO("api", "eth", "send", "toAddress", toAmount), diegasLimit/gasPrice/nonceDie Einstellung des Methodenanrufs kann beim Aufrufen dermulticallMethode.
Wir verwenden Pseudo-Code, um zu beschreiben:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Der Parameter{gasPrice: 11, gasLimit: 111, nonce: 111}Die Anpassung an die spezifischen Bedürfnisse kann auf den letzten Parameter desexchange.IO()Funktion.
Sie können dienonceund verwenden Sie den System-Standardwert, oder lassen SiegasLimit/gasPrice/nonceDeaktivieren und verwenden Sie den Systemstandardwert für alle.
Dieexchange.IO("address")Die Funktion wird so aufgerufen, dass sie die Adresse der von dem Exchange-Objekt {@var/EXCHANGE exchange} konfigurierten Brieftasche erhält.
Dieexchange.IO("address")Funktion gibt die konfigurierte Wallet-Adresse zurück.
String
exchange.IO(k)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"address"bedeutet, dass die Funktion verwendet wird, um die konfigurierte Wallet-Adresse zu erhalten.
k
- Das stimmt.
String
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Dieexchange.IO("base", ...)Die Funktion wird so aufgerufen, dass die RPC-Knotenadresse festgelegt wird.
exchange.IO(k, Anschrift)
DiekParameter wird verwendet, um die Funktion derexchange.IO()Funktion, auf"base"bedeutet, dass die Funktion zum Wechseln von RPC-Knoten verwendet wird.
k
wahr
String
DieaddressParameter wird verwendet, um die RPC-Knotenadresse festzulegen.
Anschrift
wahr
String
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}