exchange.IO("api",...) est une

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 owner, l'utilisation réelle doit remplir l'adresse spécifique.spender: l'adresse du contrat autorisé, l'exemple est remplacé par la chaîne spender, l'utilisation réelle doit remplir l'adresse spécifique, par exemple, il peut êtreUniswap 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 publicUniswap V3 Trade Modèle

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.

"Clé" ou "clé" Le numéro de téléphone de l'échange.