En la plataforma de negociación FMZ Quant, implementa principalmente varias funciones, llamadas relacionadas con blockchain a través deexchange.IO()El siguiente documento describe elexchange.IO()El método de llamada del sistema deexchange.IO("abi", ...)la función se utiliza para registrar un ABI.
exchange.IO(k, dirección, abiContenido)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"abi"significa que la función se utiliza para registrarABI- ¿ Por qué?
el
verdadero
la cuerda
EladdressParámetro utilizado para especificar la dirección del contrato inteligente.
Dirección
verdadero
la cuerda
ElabiContentParámetro se utiliza para especificar elABIdel contrato inteligente.
AbiContenido
verdadero
la cuerda
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)
}
No es necesario registrar los métodos de llamada de contratos inteligentes si se trata de métodos ERC20 estándar.
Toma elABIEl contenido del contrato se puede obtener en la siguiente dirección URL, tomando elresultsólo en el campo, por ejemplo:
https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45
El método de llamada deexchange.IO("api", "eth", ...)La función se utiliza para llamar al método Ethereum RPC.
Elexchange.IO("api", "eth", ...)La función devuelve el valor de retorno del método RPC llamado.
cadena, número, bool, objeto, matriz, nulo y todos los demás tipos compatibles con el sistema
exchange.IO(k, cadena de bloques, método rpc)exchange.IO(k, cadena de bloques, método rpc,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"api"indica que la función se utiliza para extender la solicitud de llamada.
el
verdadero
la cuerda
ElblockChainParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"eth"indica que la función se utiliza para las llamadas de métodos RPC en la red Ethereum.
el bloqueChain
verdadero
la cuerda
ElrpcMethodParámetro se utiliza para establecer el método RPC a ser llamado por elexchange.IO()la función.
Método rpc
verdadero
la cuerda
ElargParámetro se utiliza para especificar los parámetros del método RPC a ser llamado.argEl tipo y el número deargLos parámetros dependen del método RPC especificado por elrpcMethodel parámetro.
el
falsos
cadena, número, bool, objeto, matriz, función, nulo y todos los demás tipos compatibles con el sistema
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()))
}
Compruebe el saldo de ETH en su billetera:
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)
}
Para las transferencias de ETH, puede configurar el{gasPrice: 11, gasLimit: 111, nonce: 111}Parámetro, que se establece en el último parámetro delexchange.IO()En el caso de los productos que no se encuentran en la lista de productos, el número de productos que se encuentran en la lista de productos que se encuentran en la lista denoncey utilizar el sistema por defecto, o dejargasLimit/gasPrice/noncedesactivar y utilizar el valor predeterminado del sistema para todos.
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)
}
CuestionariogasPrice:
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)
}
Cuestionarioeth_estimateGas:
El segundo parámetro delexchange.IO()Función con"eth"puede llamar directamente a los métodos RPC disponibles para el servidor de nodo Ethereum.
¿Por qué no lo haces?
Elexchange.IO("encode", ...)La función es llamada para codificar datos.
Elexchange.IO("encode", ...)función devuelve los datos codificados.
la cuerda
exchange.IO(k, formato de datos,...args)exchange.IO(k, dirección, formato de datos)exchange.IO(k, dirección, datosFormato,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"encode"significa que la función se utiliza para codificar datos.
el
verdadero
la cuerda
EladdressEl parámetro se utiliza para establecer la dirección del contrato inteligente.exchange.IO("encode", ...)función, pasando en eladdressParámetro indica la codificación de la llamada del método en el contrato inteligente.exchange.IO("encode", ...)La función, si eladdresssi el parámetro no se pasa, la función se utiliza para codificar el orden de tipo especificado y es funcionalmente equivalente aabi.encodeEn elSolidity- ¿ Por qué?
Dirección
falsos
la cuerda
EldataFormatParámetro utilizado para especificar el método, el tipo y el orden de los datos codificados.
DatosFormato
verdadero
la cuerda
ElargParámetro se utiliza para especificar el valor de datos específicos que coincide con eldataFormatPuede haber más de unaargParámetro, y el tipo y el número deargLos parámetros dependen de ladataFormatConfiguración de parámetros.
el
falsos
cadena, número, tuple, matriz y todos los otros tipos compatibles con el sistema
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)
}
Por ejemplo, llamando el método de codificaciónunwrapWETH9:
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 equivalente al ejemplo de codificación deabi.encodeEn elSolidity:
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)
}
Soporta la codificación de un tuplo o un orden de tipo que contiene un tuplo.
Este tipo de orden consiste en:tuple, bytes, así que cuando llamasexchange.IO()para codificar, usted necesita seguir pasando dos parámetros:
{
a: 30,
b: 20,
c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
Los parámetros transmitidos deben ser también coherentes con la estructura y el tipo detuple, tal como se define en eltypesParámetro del formulario: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)
}
Apoya la codificación secuencial de matrices o tipos que contienen matrices:
Elexchange.IO()La función encapsula elencodemétodo, que puede devolver el código de llamada de la función ahexPara un uso específico, puede consultar las plataformas disponibles públicamente.
Elexchange.IO("encodePacked", ...)La función se llama de una manera que se utiliza paraencodePacked encoding.
Elexchange.IO("encodePacked", ...)Función devuelve elencodePackeddatos codificados.
la cuerda
exchange.IO(k, formato de datos,...args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"encodePacked"significa que la función se utiliza para datosencodePackedcodificación.
el
verdadero
la cuerda
EldataFormatParámetro se utiliza para especificar el tipo y el orden de laencodePackeddatos codificados.
DatosFormato
verdadero
la cuerda
ElargParámetro se utiliza para especificar el valor de datos específicos que coincide con eldataFormatPuede haber más de unaargParámetro, y el tipo y el número deargLos parámetros dependen de ladataFormatConfiguración de parámetros.
el
verdadero
cadena, número, tuple, matriz y todos los otros tipos compatibles con el sistema
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)
}
Cuando se utilizaUniswap V3, usted necesita para pasar en parámetros como la ruta de intercambio, usted necesita utilizar elencodePackedoperación de codificación:
Elexchange.IO("decode", ...)La función se llama de una manera que se utiliza para la decodificación.
Elexchange.IO("decode", ...)Devuelve una cadena cuando sólo hay un dato especificado por eldataFormatRetorna una matriz cuando hay más de un dato especificado por eldataFormatel parámetro.
la matriz, la cadena
exchange.IO(k, datosFormato, datos)
ElkParámetro se utiliza para establecer la función de laexchange.IO()la función, y la configuración a"decode"significa que la función se utiliza para decodificar datos.
el
verdadero
la cuerda
EldataFormatParámetro utilizado para especificar el tipo y el orden de los datos decodificados.
DatosFormato
verdadero
la cuerda
EldataEl parámetro se utiliza para establecer los datos a descifrar.
datos
verdadero
la cuerda
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)
}
El funcionamiento inverso de laexchange.IO("encode", ...)Función:
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)
}
El siguiente ejemplo realiza primero unaencodePackedLa operación en elpathEl procesamiento de parámetros, porque elexactOutputllamada de método que necesita ser codificado más tarde requierepathcomo un parámetro.encodeElexactOutputmétodo del contrato de ruta, que sólo tiene un parámetro de tipotuple. Nombre del métodoexactOutputestá codificado como:0x09b81346, y utilizando elexchange.IO("decode", ...)método para decodificar el resultadodecodeRaw, coherente con la variabledataTuple.
Para el tratamiento de datos, elexchange.IO()Función soporta no sólo la codificación, sino también la decodificación.
Elexchange.IO("key", ...)La función se llama de una manera para cambiar las claves privadas.
exchange.IO(K, tecla)
El parámetrokse utiliza para establecer la función de laexchange.IO()función, fijada en"key"significa que la función se utiliza para cambiar la clave privada.
el
verdadero
la cuerda
ElkeyEl parámetro se utiliza para establecer la clave privada.
llave
verdadero
la cuerda
function main() {
exchange.IO("key", "Private Key") // "Private Key" represents the private key string, which needs to be filled in specifically
}
Elexchange.IO()También es posible agregar múltiples objetos de intercambio (ver: {@var/EXCHANGE/exchanges exchanges}) para manipular múltiples direcciones de billetera.
Elexchange.IO("api", ...)La función se llama de una manera que se utiliza para llamar a los métodos del contrato inteligente.
Elexchange.IO("api", ...)La función devuelve el valor de retorno del método llamado contrato inteligente.
cadena, número, bool, objeto, matriz, nulo y todos los demás tipos compatibles con el sistema
exchange.IO(k, dirección, método)exchange.IO(k, dirección, método,...args)exchange.IO(k, dirección, método, valor,... args)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"api"indica que la función se utiliza para extender la solicitud de llamada.
el
verdadero
la cuerda
EladdressParámetro utilizado para especificar la dirección del contrato inteligente.
Dirección
verdadero
la cuerda
ElmethodEl parámetro se utiliza para especificar el método del contrato inteligente que se va a llamar.
Método
verdadero
la cuerda
ElvalueEl parámetro se utiliza para establecer la cantidad de ETH a enviar.stateMutabilityel atributo del método de contrato inteligente a ejecutar espayable, luego elvalueEl parámetro debe ser pasado."stateMutability": "payable"Los atributos pueden ser vistos desde el ABI.exchange.IO()La función determinará el parámetro requerido basado en elstateMutabilitySi el atributo en el ABI que se ha registrado.stateMutabilityel atributo esnonpayable, luego elvalueNo es necesario pasar el parámetro.
Valor
falsos
número, cadena
ElargParámetro se utiliza para especificar los parámetros del método del contrato inteligente a ser llamado.argParámetro, y el tipo y el número deargLos parámetros dependen del método del contrato inteligente que se va a llamar.
el
falsos
cadena, número, bool y todos los otros tipos compatibles con el sistema
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
}
Eldecimalsel método es unconstantEl método de ERC20 que no incurre en el consumo de gas y puede consultar los datos de precisión de un token.decimalsEl método no tiene parámetros. Valor de retorno: datos de precisión del 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"))
}
Elallowanceel método es unconstantEl método de ERC20 que no genera consumo de gas y puede consultar la cantidad autorizada de un token para una determinada dirección de contrato.allowanceEl método toma 2 parámetros, el primero es la dirección de la billetera y el segundo es la dirección autorizada.
owner: la dirección de la billetera, el ejemplo se sustituye por la cadena spender: la dirección del contrato autorizado, el ejemplo se sustituye por la cadena 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 || {})
}
ElmulticallEl método es un no-constantmétodo deUniswap V3que genera consumo de gas y se utiliza para canjear fichas de múltiples maneras.
ElmulticallEl método puede tener varias formas de pasar parámetros, puede comprobar el ABI que contiene el método específicamente, debe registrar el ABI antes de llamar al método.
Para ejemplos concretos demulticallEn el caso de las llamadas de método, puede consultar las plataformas accesibles al público.
Algunos detalles se describen aquí usando pseudo-código:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)
ContractV3SwapRouterV2: dirección del router v2 de Uniswap V3.value: la cantidad de ETH a transferir, fijada en 0 si el token de la operación de intercambio no es ETH.deadline: deadlinees el parámetro delmulticallmétodo, que puede establecerse en (new Date().getTime() / 1000) + 3600, lo que indica que es válido durante una hora.data: dataes el parámetro delmulticallel método, los datos de la operación de embalaje que debe realizarse.
Similar aexchange.IO("api", "eth", "send", "toAddress", toAmount), elgasLimit/gasPrice/noncela configuración de la llamada de método puede especificarse al llamar elmulticallel método.
Una vez más, usamos pseudo-código para describir:
exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})
El parámetro{gasPrice: 11, gasLimit: 111, nonce: 111}El valor de la función de control puede ajustarse de acuerdo con las necesidades específicas, que se ajusta al último parámetro de laexchange.IO()la función.
Puede omitir elnoncey utilizar el valor predeterminado del sistema, o dejargasLimit/gasPrice/noncedesactivar y utilizar el valor predeterminado del sistema para todos.
Elexchange.IO("address")la función se llama de tal manera que obtenga la dirección de la billetera configurada por el objeto de intercambio {@var/EXCHANGE exchange}.
Elexchange.IO("address")La función devuelve la dirección de la billetera configurada.
la cuerda
exchange.IO(k) El
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"address"significa que la función se utiliza para obtener la dirección de cartera configurada.
el
verdadero
la cuerda
function main() {
Log(exchange.IO("address")) // Print the wallet address of the private key configured on the exchange object
}
Elexchange.IO("base", ...)La función se llama de una manera para establecer la dirección del nodo RPC.
exchange.IO(k, dirección)
ElkParámetro se utiliza para establecer la función de laexchange.IO()función, fijada en"base"significa que la función se utiliza para cambiar los nodos RPC.
el
verdadero
la cuerda
Eladdressel parámetro se utiliza para establecer la dirección del nodo RPC.
Dirección
verdadero
la cuerda
function main() {
var chainRpc = "https://bsc-dataseed.binance.org"
e.IO("base", chainRpc) // Switching to BSC chain
}