Hướng dẫn cú pháp

Tài nguyên đang được tải lên... tải...

Web3

exchange.IO("abi",...)

Trong nền tảng giao dịch FMZ Quant, nó chủ yếu thực hiện các chức năng khác nhau, gọi liên quan đến blockchain thông quaexchange.IO()Các tài liệu sau đây mô tảexchange.IO()Phương pháp gọi củaexchange.IO("abi", ...)chức năng được sử dụng để đăng ký ABI.

exchange.IO(k, địa chỉ, abiContent)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"abi"có nghĩa là chức năng được sử dụng để đăng kýABI. k đúng chuỗi Cácaddresstham số được sử dụng để chỉ định địa chỉ của hợp đồng thông minh. địa chỉ đúng chuỗi CácabiContenttham số được sử dụng để xác địnhABIcủa hợp đồng thông minh. abiContent đúng chuỗi

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)
}

Các phương pháp gọi hợp đồng thông minh không cần phải được đăng ký nếu chúng là các phương pháp ERC20 tiêu chuẩn. Đưa nó ra.ABInội dung của hợp đồng có thể được lấy bằng URL sau đây, lấyresultChỉ trường, ví dụ:

https://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45

exchange.IO("api", eth,...)

Phương pháp gọi củaexchange.IO("api", "eth", ...)hàm được sử dụng để gọi phương thức Ethereum RPC.

Cácexchange.IO("api", "eth", ...)hàm trả về giá trị trả về của phương thức RPC được gọi. chuỗi, số, bool, đối tượng, mảng, null và tất cả các loại khác được hỗ trợ bởi hệ thống

exchange.IO(k, blockChain, rpcMethod)exchange.IO(k, blockChain, rpcMethod,...args)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"api"chỉ ra rằng hàm được sử dụng để mở rộng yêu cầu gọi. k đúng chuỗi CácblockChaintham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"eth"chỉ ra rằng hàm được sử dụng cho các cuộc gọi phương thức RPC trên Mạng Ethereum. BlockChain đúng chuỗi CácrpcMethodtham số được sử dụng để thiết lập phương pháp RPC được gọi bởi cácexchange.IO()chức năng. phương pháp rpc đúng chuỗi Cácargtham số được sử dụng để chỉ định các tham số của phương thức RPC được gọi. Có thể có nhiều hơn mộtargLoại và số lượngargCác thông số phụ thuộc vào phương pháp RPC được chỉ định bởirpcMethodtham số. arg sai chuỗi, số, bool, đối tượng, mảng, hàm, null, và tất cả các loại khác được hỗ trợ bởi hệ thống

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()))
}

Kiểm tra số dư ETH trong ví của bạn:

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)
}

Đối với chuyển tiền ETH, bạn có thể thiết lập{gasPrice: 11, gasLimit: 111, nonce: 111}tham số, được thiết lập trên tham số cuối cùng củaexchange.IO()Bạn có thể bỏ quanoncevà sử dụng hệ thống mặc định, hoặc để lạigasLimit/gasPrice/noncetắt và sử dụng giá trị mặc định của hệ thống cho tất cả.

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)
}

Câu hỏigasPrice:

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)
}

Câu hỏieth_estimateGas:

Các tham số thứ hai củaexchange.IO()chức năng với"eth"có thể trực tiếp gọi các phương pháp RPC có sẵn cho máy chủ node Ethereum.

{@fun BigDecimal}, {@fun BigInt}

exchange.IO("đã mã hóa",...)

Cácexchange.IO("encode", ...)hàm được gọi cho mã hóa dữ liệu.

Cácexchange.IO("encode", ...)hàm trả về dữ liệu được mã hóa. chuỗi

exchange.IO(k, dataFormat,...args)exchange.IO(k, địa chỉ, định dạng dữ liệu)exchange.IO(k, địa chỉ, dataFormat,...args)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"encode"có nghĩa là hàm được sử dụng để mã hóa dữ liệu. k đúng chuỗi CácaddressCác tham số được sử dụng để thiết lập địa chỉ của hợp đồng thông minh.exchange.IO("encode", ...)chức năng, đi qua trongaddresstham số chỉ ra mã hóa phương thức gọi trên hợp đồng thông minh.exchange.IO("encode", ...)chức năng, nếuaddresstham số không được truyền, chức năng được sử dụng để mã hóa thứ tự loại được chỉ định và tương đương về chức năng vớiabi.encodetrongSolidity. địa chỉ sai chuỗi CácdataFormattham số được sử dụng để xác định phương pháp, loại và thứ tự của dữ liệu được mã hóa. dataFormat đúng chuỗi Cácargtham số được sử dụng để chỉ định giá trị dữ liệu cụ thể phù hợp vớidataFormatcó thể có nhiều hơn mộtargtham số, và loại và số lượngargcác thông số phụ thuộc vàodataFormatcài đặt tham số. arg sai chuỗi, số, tuple, mảng, và tất cả các loại khác được hỗ trợ bởi hệ thống

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)
}

Ví dụ, gọi phương thức mã hóaunwrapWETH9:

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
    */
}

Nó tương đương với ví dụ mã hóa củaabi.encodetrongSolidity:

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)
}

Nó hỗ trợ mã hóa một tuple hoặc một thứ tự loại chứa một tuple. Lệnh kiểu này bao gồm:tuple, bytesVì vậy khi gọiexchange.IO()để mã hóa, bạn cần tiếp tục truyền hai tham số:

1. Các biến tương ứng với loại tuple:
```
{
    a: 30,
    b: 20,
    c: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
}
```
Các thông số được truyền phải phù hợp với cấu trúc và loạituple, như được định nghĩa trongtypestham số của biểu mẫu:tuple(a uint256,b uint8,c address).
1. Các biến tương ứng với loạibytes:
```
"0011"
```

function main() {
    var path = ["0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2", "0xdac17f958d2ee523a2206206994597c13d831ec7"]   // ETH address, USDT address
    var ret = exchange.IO("encode", "address[]", path)
    Log("encode: ", ret)
}

Nó hỗ trợ mã hóa thứ tự của mảng hoặc các loại chứa mảng:

Cácexchange.IO()chức năng bao gồm cácencodephương pháp, mà có thể trả lại mã gọi chức năng đểhexĐối với việc sử dụng cụ thể, bạn có thể tham khảo các nền tảng s có sẵn công khaiUniswap V3 Trade Mẫu. Khi phương pháp mã hóa gọi các hợp đồng thông minh, ABI tương ứng cần phải được đăng ký trước.

exchange.IO("EncodePacked",...)

Cácexchange.IO("encodePacked", ...)hàm được gọi theo cách được sử dụng choencodePacked encoding.

Cácexchange.IO("encodePacked", ...)hàm trả vềencodePackeddữ liệu được mã hóa. chuỗi

exchange.IO(k, dataFormat,...args)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"encodePacked"có nghĩa là hàm được sử dụng cho dữ liệuencodePackedmã hóa. k đúng chuỗi CácdataFormattham số được sử dụng để xác định loại và thứ tự củaencodePackeddữ liệu được mã hóa. dataFormat đúng chuỗi Cácargtham số được sử dụng để chỉ định giá trị dữ liệu cụ thể phù hợp vớidataFormatcó thể có nhiều hơn mộtargtham số, và loại và số lượngargcác thông số phụ thuộc vàodataFormatcài đặt tham số. arg đúng chuỗi, số, tuple, mảng, và tất cả các loại khác được hỗ trợ bởi hệ thống

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)
}

Khi sử dụngUniswap V3, bạn cần phải truyền vào các thông số như đường dẫn trao đổi, bạn cần phải sử dụngencodePackedHoạt động mã hóa:

exchange.IO("đã giải mã",...)

Cácexchange.IO("decode", ...)hàm được gọi theo cách được sử dụng để giải mã.

Cácexchange.IO("decode", ...)Trả về một chuỗi khi chỉ có một dữ liệu được chỉ định bởidataFormatTrả về một mảng khi có nhiều hơn một dữ liệu được chỉ định bởidataFormattham số. mảng,string

exchange.IO(k, dataTình hình, dữ liệu)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, và thiết lập nó để"decode"có nghĩa là chức năng được sử dụng để giải mã dữ liệu. k đúng chuỗi CácdataFormattham số được sử dụng để xác định loại và thứ tự của dữ liệu giải mã. dataFormat đúng chuỗi Cácdatatham số được sử dụng để thiết lập dữ liệu được giải mã. dữ liệu đúng chuỗi

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)
}

Hoạt động ngược củaexchange.IO("encode", ...)chức năng:

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)
}

Ví dụ sau đây đầu tiên thực hiện mộtencodePackedhoạt động trênpathxử lý tham số, bởi vìexactOutputgọi phương thức mà cần được mã hóa sau đó đòi hỏipathnhư một tham số. sau đóencodecácexactOutputphương pháp của hợp đồng tuyến đường, chỉ có một tham số loạituple. Tên phương phápexactOutputđược mã hóa như sau:0x09b81346, và sử dụngexchange.IO("decode", ...)phương pháp giải mã kết quảdecodeRaw, phù hợp với biếndataTuple.

Đối với xử lý dữ liệu,exchange.IO()chức năng hỗ trợ không chỉ mã hóa, mà còn giải mã.

exchange.IO("khóa",...)

Cácexchange.IO("key", ...)chức năng được gọi theo cách để chuyển đổi khóa riêng.

exchange.IO(k, phím)

Các thông sốkđược sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"key"nghĩa là chức năng được sử dụng để chuyển đổi khóa riêng. k đúng chuỗi Cáckeytham số được sử dụng để thiết lập khóa riêng. chìa khóa đúng chuỗi

function main() {
    exchange.IO("key", "Private Key")   // "Private Key" represents the private key string, which needs to be filled in specifically
}

Cácexchange.IO()chức năng hỗ trợ chuyển đổi khóa riêng và nó có thể thao tác nhiều địa chỉ ví. Nó cũng có thể thêm nhiều đối tượng trao đổi (xem: {@var/EXCHANGE/exchanges exchanges}) để thao tác nhiều địa chỉ ví.

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

Cácexchange.IO("api", ...)hàm được gọi theo cách được sử dụng để gọi các phương thức của hợp đồng thông minh.

Cácexchange.IO("api", ...)hàm trả về giá trị trả về của phương thức gọi là hợp đồng thông minh. chuỗi, số, bool, đối tượng, mảng, null và tất cả các loại khác được hỗ trợ bởi hệ thống

exchange.IO(k, địa chỉ, phương pháp)exchange.IO(k, địa chỉ, phương pháp,...args)exchange.IO(k, địa chỉ, phương pháp, giá trị,...args)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"api"chỉ ra rằng hàm được sử dụng để mở rộng yêu cầu gọi. k đúng chuỗi Cácaddresstham số được sử dụng để chỉ định địa chỉ của hợp đồng thông minh. địa chỉ đúng chuỗi Cácmethodtham số được sử dụng để xác định phương thức của hợp đồng thông minh được gọi. phương pháp đúng chuỗi Cácvaluetham số được sử dụng để thiết lập số tiền ETH được gửi.stateMutabilitythuộc tính của phương thức hợp đồng thông minh được thực thi làpayable, sau đó làvaluetham số cần phải được thông qua."stateMutability": "payable"có thể xem từ ABI.exchange.IO()chức năng sẽ xác định các thông số cần thiết dựa trênstateMutabilitytính năng trong ABI đã được đăng ký.stateMutabilitythuộc tính lànonpayable, sau đó làvaluetham số không cần phải được truyền. giá trị sai số, chuỗi Cácargtham số được sử dụng để xác định các tham số của phương thức của hợp đồng thông minh được gọi. Có thể có nhiều hơn mộtargtham số, và loại và số lượngargCác tham số phụ thuộc vào phương pháp của hợp đồng thông minh được gọi. arg sai chuỗi, số, bool, và tất cả các loại khác được hỗ trợ bởi hệ thống

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
}

Cácdecimalsphương pháp là mộtconstantphương pháp ERC20 mà không phải chịu tiêu thụ khí và nó có thể truy vấn các dữ liệu chính xác của một token.decimalsreturn value: các dữ liệu chính xác của 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"))   
}

Cácallowancephương pháp là mộtconstantphương pháp ERC20 mà không tạo ra tiêu thụ khí và có thể truy vấn số tiền được ủy quyền của một token cho một địa chỉ hợp đồng nhất định.allowancePhương pháp này có 2 tham số, đầu tiên là địa chỉ ví và thứ hai là địa chỉ được ủy quyền.
owner: địa chỉ của ví, ví dụ được thay thế bằng chuỗi owner, việc sử dụng thực tế cần phải điền vào địa chỉ cụ thể.spender: địa chỉ của hợp đồng được ủy quyền, ví dụ được thay thế bằng chuỗi spender, việc sử dụng thực tế cần phải điền vào địa chỉ cụ thể, ví dụ: nó có thể đượcUniswap 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 || {})
}

CácmulticallPhương pháp này không phải là...constantphương phápUniswap V3tạo ra tiêu thụ khí và được sử dụng để đổi token theo nhiều cách. Cácmulticallphương thức có thể có nhiều cách để truyền tham số, bạn có thể kiểm tra ABI có chứa phương thức cụ thể, bạn cần đăng ký ABI trước khi gọi phương thức.

Đối với các ví dụ cụ thể vềmulticallcác cuộc gọi phương pháp, bạn có thể tham khảo các nền tảngUniswap V3 Trade Mẫu

Một số chi tiết được mô tả ở đây bằng cách sử dụng mã giả:


exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data)

ContractV3SwapRouterV2: địa chỉ của bộ định tuyến v2 của Uniswap V3.value: số tiền ETH để chuyển, được đặt thành 0 nếu token trong giao dịch trao đổi không phải là ETH.deadline: deadlinelà tham số củamulticallphương pháp, có thể được đặt thành (new Date().getTime() / 1000) + 3600, cho thấy nó có hiệu lực trong một giờ.data: datalà tham số củamulticallphương pháp, dữ liệu của hoạt động đóng gói được thực hiện.

Tương tự nhưexchange.IO("api", "eth", "send", "toAddress", toAmount), cácgasLimit/gasPrice/noncethiết lập của phương thức gọi có thể được chỉ định khi gọimulticallphương pháp. Một lần nữa, chúng tôi sử dụng mã giả để mô tả:


exchange.IO("api", ContractV3SwapRouterV2, "multicall(uint256,bytes[])", value, deadline, data, {gasPrice: 123456, gasLimit: 21000})

Các thông số{gasPrice: 11, gasLimit: 111, nonce: 111}có thể được thiết lập theo nhu cầu cụ thể, được thiết lập cho tham số cuối cùng củaexchange.IO()chức năng. Bạn có thể bỏ quanoncevà sử dụng hệ thống mặc định giá trị, hoặc đểgasLimit/gasPrice/noncetắt và sử dụng giá trị mặc định của hệ thống cho tất cả.

exchange.IO("địa chỉ")

Cácexchange.IO("address")hàm được gọi theo cách để có được địa chỉ của ví được cấu hình bởi đối tượng trao đổi {@var/EXCHANGE exchange}.

Cácexchange.IO("address")function trả về địa chỉ ví được cấu hình. chuỗi

exchange.IO(k)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"address"có nghĩa là hàm được sử dụng để lấy địa chỉ ví được cấu hình. k đúng chuỗi

function main() {
    Log(exchange.IO("address"))         // Print the wallet address of the private key configured on the exchange object
}

exchange.IO("cơ sở",...)

Cácexchange.IO("base", ...)hàm được gọi theo cách để đặt địa chỉ nút RPC.

exchange.IO(k, địa chỉ)

Cácktham số được sử dụng để thiết lập chức năng củaexchange.IO()chức năng, được thiết lập thành"base"có nghĩa là chức năng được sử dụng để chuyển đổi các nút RPC. k đúng chuỗi Cácaddresstham số được sử dụng để thiết lập địa chỉ nút RPC. địa chỉ đúng chuỗi

function main() {
    var chainRpc = "https://bsc-dataseed.binance.org"
    e.IO("base", chainRpc)    // Switching to BSC chain
}

Sợi TA

2019 FMZ - Tất cả các quyền được bảo lưu