Dans la plateforme de trading FMZ Quant, il implémente principalement diverses fonctions, appels liés à la blockchain viaexchange.IO()Le document suivant décrit lesexchange.IO()La méthode d'appel de l'appareilexchange.IO("abi", ...)fonction est utilisée pour enregistrer un ABI.
exchange.IO(k, adresse, contenu abi)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"abi"signifie que la fonction est utilisée pour enregistrerABI- Je ne sais pas.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour spécifier l'adresse du contrat intelligent.
l'adresse
vrai
chaîne
LeabiContentparamètre est utilisé pour spécifier leABIdu contrat intelligent.
Le contenu
vrai
chaîne
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)
}
Les méthodes d'appel de contrats intelligents n'ont pas besoin d'être enregistrées si elles sont des méthodes ERC20 standard.
Prends leABILe contenu du marché peut être obtenu à l'adresse URL suivante, en prenant leresultuniquement sur le terrain, par exemple:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
La méthode d'appel deexchange.IO("api", "eth", ...)fonction est utilisée pour appeler la méthode Ethereum RPC.
Leexchange.IO("api", "eth", ...)la fonction renvoie la valeur de retour de la méthode appelée RPC.
chaîne, nombre, bool, objet, tableau, nul et tous les autres types pris en charge par le système
exchange.IO(k, chaîne de blocs, méthode rpc)exchange.IO(k, chaîne de blocs, méthode rpc,...args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"api"indique que la fonction est utilisée pour étendre la demande d'appel.
K
vrai
chaîne
LeblockChainLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"eth"indique que la fonction est utilisée pour les appels de méthode RPC sur le réseau Ethereum.
Chaîne de blocs
vrai
chaîne
LerpcMethodparamètre est utilisé pour définir la méthode RPC à appeler par leexchange.IO()fonction.
RpcMéthode
vrai
chaîne
Leargparamètre est utilisé pour spécifier les paramètres de la méthode RPC à appeler.argLe type et le nombre deargLes paramètres dépendent de la méthode RPC spécifiée par lerpcMethodparamètre.
arg
faux
chaîne, nombre, bool, objet, tableau, fonction, nul et tous les autres types pris en charge par le système
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()))
}
Vérifiez le solde d'ETH dans votre portefeuille:
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)
}
Pour les virements en ETH, vous pouvez définir le{gasPrice: 11, gasLimit: 111, nonce: 111}paramètre, qui est réglé sur le dernier paramètre duexchange.IO()Vous pouvez omettre lesnonceet utiliser le système par défaut, ou laissergasLimit/gasPrice/noncedésactiver et utiliser la valeur par défaut du système pour tous.
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)
}
RequêtesgasPrice:
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)
}
Requêteseth_estimateGas:
Le deuxième paramètre duexchange.IO()fonction avec"eth"peut appeler directement les méthodes RPC disponibles pour le serveur de nœud Ethereum.
Je ne sais pas.
Leexchange.IO("encode", ...)la fonction est appelée pour l'encodage des données.
Leexchange.IO("encode", ...)fonction renvoie les données codées.
chaîne
exchange.IO(k, format de données,... args)exchange.IO(k, adresse, format des données)exchange.IO(k, adresse, donnéesFormat,...args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"encode"signifie que la fonction est utilisée pour l'encodage des données.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour définir l'adresse du contrat intelligent.exchange.IO("encode", ...)fonction, en passant dans leaddressParamètre indique le codage de l'appel de méthode sur le contrat intelligent.exchange.IO("encode", ...)fonction, si leaddressparamètre n'est pas passé, la fonction est utilisée pour coder l'ordre de type spécifié et est fonctionnellement équivalente àabi.encodedansSolidity- Je ne sais pas.
l'adresse
faux
chaîne
LedataFormatparamètre est utilisé pour spécifier la méthode, le type et l'ordre des données codées.
donnéesFormat
vrai
chaîne
Leargparamètre est utilisé pour spécifier la valeur de données spécifique qui correspond à ladataFormatIl peut y avoir plus d'unargparamètre, ainsi que le type et leargLes paramètres dépendent de ladataFormatréglage des paramètres.
arg
faux
chaîne, nombre, tuple, tableau et tous les autres types pris en charge par le système
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)
}
Par exemple, appeler la méthode d'encodageunwrapWETH9:
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
*/
}
Il est équivalent à l'exemple de codage deabi.encodedansSolidity:
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)
}
Il prend en charge l'encodage d'une tuple ou d'un ordre de type contenant une tuple.
Cet ordre de type est composé de:tuple, bytesAlors quand tu appellesexchange.IO()pour le codage, vous devez continuer à passer deux paramètres:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Les paramètres transmis doivent également être conformes à la structure et au type detuple, au sens de la définitiontypesparamètre du formulaire: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)
}
Il prend en charge le codage séquentiel de tableaux ou de types contenant des tableaux:
Leexchange.IO()fonction encapsule leencodeméthode, qui peut renvoyer le code d'appel de fonction àhexPour une utilisation spécifique, vous pouvez vous référer aux plateformes accessibles au public
Leexchange.IO("encodePacked", ...)fonction est appelée d'une manière qui est utilisé pourencodePacked encoding.
Leexchange.IO("encodePacked", ...)Retourne leencodePackeddonnées codées.
chaîne
exchange.IO(k, format de données,... args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"encodePacked"signifie que la fonction est utilisée pour les donnéesencodePackedle codage.
K
vrai
chaîne
LedataFormatLe paramètre est utilisé pour spécifier le type et l'ordre desencodePackeddonnées codées.
donnéesFormat
vrai
chaîne
Leargparamètre est utilisé pour spécifier la valeur de données spécifique qui correspond à ladataFormatIl peut y avoir plus d'unargparamètre, ainsi que le type et leargLes paramètres dépendent de ladataFormatréglage des paramètres.
arg
vrai
chaîne, nombre, tuple, tableau et tous les autres types pris en charge par le système
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)
}
Lors de l' utilisationUniswap V3, vous devez passer dans les paramètres comme le chemin d'échange, vous devez utiliser leencodePackedopération de codage:
Leexchange.IO("decode", ...)La fonction est appelée d'une manière qui est utilisée pour le décryptage.
Leexchange.IO("decode", ...)Retourne une chaîne quand il n'y a qu'une seule donnée spécifiée par ledataFormatRetourne un tableau lorsqu'il y a plus d'une donnée spécifiée par ledataFormatparamètre.
Le nombre d'éléments
exchange.IO(k, donnéesFormat, données
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, et le régler sur"decode"signifie que la fonction est utilisée pour le décryptage des données.
K
vrai
chaîne
LedataFormatLe paramètre est utilisé pour spécifier le type et l'ordre des données décodées.
donnéesFormat
vrai
chaîne
Ledataparamètre est utilisé pour définir les données à décoder.
données
vrai
chaîne
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)
}
Le fonctionnement inverse de laexchange.IO("encode", ...)fonction:
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)
}
L'exemple suivant effectue d'abord uneencodePackedopération sur lepathLe traitement des paramètres,exactOutputl'appel de méthode qui doit être codé plus tard nécessitepathcomme un paramètre.encodeLeexactOutputméthode du contrat de routage, qui ne comporte qu'un seul paramètre de typetuple. Le nom de la méthodeexactOutputest codé comme suit:0x09b81346, et en utilisant leexchange.IO("decode", ...)méthode de décryptage du code résultantdecodeRaw, cohérente avec la variabledataTuple.
Pour le traitement des données, leexchange.IO()fonction prend en charge non seulement le codage, mais aussi le décodage.
Leexchange.IO("key", ...)La fonction est appelée de manière à changer les clés privées.
exchange.IO(K, clé)
Le paramètrekest utilisé pour régler la fonction duexchange.IO()fonction, réglée sur"key"signifie que la fonction est utilisée pour changer la clé privée.
K
vrai
chaîne
LekeyLe paramètre est utilisé pour définir la clé privée.
clé
vrai
chaîne
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Leexchange.IO()Il est également possible d'ajouter plusieurs objets d'échange (voir: {@var/EXCHANGE/exchanges exchanges}) pour manipuler plusieurs adresses de portefeuille.
Leexchange.IO("api", ...)la fonction est appelée d'une manière qui est utilisée pour appeler les méthodes du contrat intelligent.
Leexchange.IO("api", ...)la fonction renvoie la valeur de retour de la méthode appelée contrat intelligent.
chaîne, nombre, bool, objet, tableau, nul et tous les autres types pris en charge par le système
exchange.IO(k, adresse, méthode)exchange.IO(k, adresse, méthode,... arguments)exchange.IO(k, adresse, méthode, valeur,... args)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"api"indique que la fonction est utilisée pour étendre la demande d'appel.
K
vrai
chaîne
LeaddressLe paramètre est utilisé pour spécifier l'adresse du contrat intelligent.
l'adresse
vrai
chaîne
LemethodLe paramètre est utilisé pour spécifier la méthode du contrat intelligent à appeler.
méthode
vrai
chaîne
LevalueLe paramètre est utilisé pour définir la quantité d'ETH à envoyer.stateMutabilityl'attribut de la méthode de contrat intelligent à exécuter estpayable, puis levalueLe paramètre doit être passé."stateMutability": "payable"L'attribut peut être consulté depuis l'ABI.exchange.IO()La fonction déterminera le paramètre requis sur la base de lastateMutabilityL'attribut dans l'ABI qui a été enregistré.stateMutabilityl'attribut estnonpayable, puis levaluele paramètre n'a pas besoin d'être passé.
valeur
faux
Numéro, chaîne
Leargparamètre est utilisé pour spécifier les paramètres de la méthode du contrat intelligent à appeler.argparamètre, ainsi que le type et leargLes paramètres dépendent de la méthode du contrat intelligent à appeler.
arg
faux
chaîne, nombre, bool, et tous les autres types pris en charge par le système
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
}
Ledecimalsla méthode est uneconstantLa méthode ERC20 qui ne nécessite pas de consommation de gaz et qui peut interroger les données de précision d'un jeton.decimalsLa méthode n'a pas de paramètres. Valeur de retour: les données de précision du jeton.
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"))
}
Leallowancela méthode est uneconstantLa méthode ERC20 qui ne génère pas de consommation de gaz et peut interroger le montant autorisé d'un jeton pour une certaine adresse de contrat.allowanceLa méthode prend 2 paramètres, le premier est l'adresse du portefeuille et le second est l'adresse autorisée.
owner: l'adresse du portefeuille, l'exemple est remplacé par la chaîne spender: l'adresse du contrat autorisé, l'exemple est remplacé par la chaîne 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 || {})
}
LemulticallLa méthode est un non-constantméthode deUniswap V3qui génère une consommation de gaz et est utilisée pour échanger des jetons de plusieurs façons.
Lemulticallméthode peut avoir différentes façons de passer des paramètres, vous pouvez vérifier l'ABI qui contient la méthode spécifiquement, vous devez enregistrer l'ABI avant d'appeler la méthode.
Pour des exemples spécifiques demulticallVous pouvez consulter les plateformes accessibles au public
Certains détails sont décrits ici en utilisant un pseudo-code:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: adresse du routeur v2 de Uniswap V3.value: le montant d'ETH à transférer, défini à 0 si le jeton de l'opération d'échange n'est pas ETH.deadline: deadlineest le paramètre dumulticallméthode, qui peut être réglée sur (new Date().getTime() / 1000) + 3600, ce qui indique qu'elle est valable pendant une heure.data: dataest le paramètre dumulticallméthode, les données de l'opération d'emballage à effectuer.
Semblableexchange.IO("api", "eth", "send", "toAddress", toAmount), legasLimit/gasPrice/nonceLa définition de l'appel de méthode peut être spécifiée lors de l'appel de lamulticallméthode.
Encore une fois, nous utilisons un pseudo-code pour décrire:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
Le paramètre{gasPrice: 11, gasLimit: 111, nonce: 111}Les paramètres d'interface peuvent être réglés en fonction des besoins spécifiques, qui sont réglés sur le dernier paramètre duexchange.IO()fonction.
Vous pouvez omettrenonceet utiliser la valeur par défaut du système, ou laissergasLimit/gasPrice/noncedésactiver et utiliser la valeur par défaut du système pour tous.
Leexchange.IO("address")la fonction est appelée de manière à obtenir l'adresse du portefeuille configuré par l'objet d'échange {@var/EXCHANGE exchange}.
Leexchange.IO("address")la fonction renvoie l'adresse de portefeuille configurée.
chaîne
exchange.IO(k) Le titre
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"address"signifie que la fonction est utilisée pour obtenir l'adresse de portefeuille configurée.
K
vrai
chaîne
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Leexchange.IO("base", ...)la fonction est appelée de manière à définir l'adresse du nœud RPC.
exchange.IO(k, adresse)
LekLe paramètre est utilisé pour définir la fonction deexchange.IO()fonction, réglée sur"base"signifie que la fonction est utilisée pour basculer les nœuds RPC.
K
vrai
chaîne
Leaddressle paramètre est utilisé pour définir l'adresse du nœud RPC.
l'adresse
vrai
chaîne
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}