Comece com o desenvolvimento web3 facilmente baseado no Ethereum usando FMZ
Autora:FMZ~Lydia, Criado: 2023-06-25 09:17:53, Atualizado: 2024-11-11 22:34:490000000000164f2434262e1cc",
We can see that there are various events in the logs data, if we only care about ```Transfer``` events, we need to filter out the ```Transfer``` events in these data.
### Retrieving Logs
The Ethereum log is divided into two parts: 1. ```topics```; 2. ```data```.
- ```topics```
Taking the results of the code run for the ```eth_getLogs``` section test as an example, the data in the ```topics``` field is:
```desc
"topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x00000000000000000000000012b791bb27b3a4ee958b5a435fea7d49ec076e9c", "0x000000000000000000000000ef1c6e67703c7bd7107eed8303fbe6ec2554bf6b"],
O valor dotopicscampo é uma estrutura de matriz usada para descrever o evento. É especificado que seu comprimento (matriz) não pode exceder 4 e o primeiro elemento é o hash de assinatura do evento.
Na plataforma de negociação FMZ Quant, podemos calcular este hash assinatura usando oEncodefunção, utilizando o seguinte código:
function main() {
var eventFunction = "Transfer(address,address,uint256)"
var eventHash = Encode("keccak256", "string", "hex", eventFunction)
Log("eventHash:", "0x" + eventHash)
// eventHash: 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
}
Calcular okeccak256valor hash (codificação hexadecimal) deTransfer(address,address,uint256)é0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
O valor dotopicscampo é uma estrutura de matriz, com o segundo elemento, e o terceiro elemento, respectivamente:
-
Endereço de envio
from -
Endereço de recepção
to -
dataOs dados
datacampo são:"data": "0x0000000000000000000000000000000000000000000000000164f2434262e1cc",Certos parâmetros (parâmetros sem declarações indexadas no código de Solididade do contrato inteligente) são armazenados no
datasection.Analise os dados
0x0000000000000000000000000000000000000000000000000164f2434262e1ccfunction toAmount(s, decimals) { return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString()) } function main() { var value = "0x0000000000000000000000000000000000000000000000000164f2434262e1cc" Log(toAmount(value, 0) / 1e18) // 0.10047146239950075 }Estes dados são obtidos como 0,10047146239950075 e o
dataé o montante da transferência correspondente.
O acima foi explicado, praticado e pronto para ir. Podemos começar a recuperar os registros em:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
// getBlockNumber
var blockNumber = exchange.IO("api", "eth", "eth_blockNumber")
Log("blockNumber:", blockNumber)
// get logs
var fromBlock = "0x" + (toAmount(blockNumber, 0) - 1).toString(16)
var toBlock = "0x" + toAmount(blockNumber, 0).toString(16)
var params = {
"fromBlock" : fromBlock,
"toBlock" : toBlock,
"address" : "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
}
var logs = exchange.IO("api", "eth", "eth_getLogs", params)
// Traverse logs
var eventFunction = "Transfer(address,address,uint256)"
var eventHash = "0x" + Encode("keccak256", "string", "hex", eventFunction)
Log("eventHash:", eventHash)
var counter = 0
for (var i = logs.length - 1; i >= 0 && counter < 10; i--) {
if (logs[i].topics[0] == eventHash) {
Log("Event Transfer, data:", toAmount(logs[i].data, 0) / 1e18, ", blockNumber:", toAmount(logs[i].blockNumber, 0), ", transactionHash:", logs[i].transactionHash,
", log:", logs[i])
counter++
}
}
}
Verifique.https://etherscan.io/:
Resultados do código de teste executado na ferramenta de depuração FMZ:
Os dadosfrom, toOs campos também podem ser analisados dependendo das necessidades no momento da recuperação, por exemplo:
function main() {
var from = "0x00000000000000000000000012b791bb27b3a4ee958b5a435fea7d49ec076e9c"
var address = "0x" + exchange.IO("encodePacked", "address", from)
Log("address:", address)
}
Resultados de execução:
Endereço: 0x12b791bb27b3a4ee958b5a435fea7d49ec076e9c
Escuta de eventos contratuais
Desde oferramenta de depuraçãoEsta seção utiliza a plataforma de negociação FMZ Quant para criar negociação ao vivo para testar.
Aqui nós usamos a rede principal Ethereum, e nós ouvimos oTransfer(address,address,uint256)Evento doUSDTBaseado no que aprendemos na última lição, projetamos e escrevemos um exemplo de ouvir continuamente os eventos de um determinado contrato inteligente:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function addEventListener(contractAddress, event, callBack) {
var self = {}
self.eventHash = "0x" + Encode("keccak256", "string", "hex", event)
self.contractAddress = contractAddress
self.latestBlockNumber = 0
self.fromBlockNumber = 0
self.firstBlockNumber = 0
/* TODO: test
self.isFirst = true
*/
self.getBlockNumber = function() {
var maxTry = 10
for (var i = 0; i < maxTry; i++) {
var ret = exchange.IO("api", "eth", "eth_blockNumber")
if (ret) {
return toAmount(ret, 0)
}
Sleep(5000)
}
throw "getBlockNumber failed"
}
self.run = function() {
var currBlockNumber = self.getBlockNumber()
var fromBlock = "0x" + self.fromBlockNumber.toString(16)
var toBlock = "0x" + currBlockNumber.toString(16)
var params = {
"fromBlock" : fromBlock,
"toBlock" : toBlock,
"address" : self.contractAddress,
"topics" : [self.eventHash]
}
// Log("fromBlockNumber:", self.fromBlockNumber, ", currBlockNumber:", currBlockNumber, "#FF0000")
var logs = exchange.IO("api", "eth", "eth_getLogs", params)
if (!logs) {
return
}
for (var i = 0; i < logs.length; i++) {
if (toAmount(logs[i].blockNumber, 0) > self.latestBlockNumber) {
/* TODO: test
if (self.isFirst) {
self.firstBlockNumber = toAmount(logs[i].blockNumber, 0)
Log("firstBlockNumber:", self.firstBlockNumber)
self.isFirst = false
}
*/
callBack(logs[i])
}
}
self.latestBlockNumber = currBlockNumber
self.fromBlockNumber = self.latestBlockNumber - 1
}
self.latestBlockNumber = self.getBlockNumber()
self.fromBlockNumber = self.latestBlockNumber - 1
return self
}
var listener = null
function main() {
var event = "Transfer(address,address,uint256)"
var contractAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7"
var decimals = exchange.IO("api", contractAddress, "decimals")
Log(exchange.IO("api", contractAddress, "name"), " decimals:", decimals)
listener = addEventListener(contractAddress, event, function(log) {
var fromAddress = "0x" + exchange.IO("encodePacked", "address", log.topics[1])
var toAddress = "0x" + exchange.IO("encodePacked", "address", log.topics[2])
Log("Transfer:", fromAddress, "->", toAddress, ", value:", toAmount(log.data, decimals), ", blockNumber:", toAmount(log.blockNumber, 0))
/* TODO: test
arrLog.push(log)
*/
})
while (true) {
listener.run()
Sleep(5000)
}
}
/* TODO: test
var arrLog = []
function onexit() {
Log("End the run and verify the record")
var firstBlockNumber = listener.firstBlockNumber
var endBlockNumber = listener.latestBlockNumber
Log("getLogs, from:", firstBlockNumber, " -> to:", endBlockNumber)
var fromBlock = "0x" + (firstBlockNumber).toString(16)
var toBlock = "0x" + (endBlockNumber).toString(16)
var params = {
"fromBlock" : fromBlock,
"toBlock" : toBlock,
"topics" : ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"],
"address" : "0xdac17f958d2ee523a2206206994597c13d831ec7"
}
var logs = exchange.IO("api", "eth", "eth_getLogs", params)
Log("arrLog:", arrLog.length)
Log("logs:", logs.length)
if (arrLog.length != logs.length) {
Log("Length varies!")
return
}
for (var i = 0; i < arrLog.length; i++) {
Log("Determine the blockNumber:", logs[i].blockNumber == arrLog[i].blockNumber, ", Determine from:", logs[i].topics[1] == arrLog[i].topics[1],
"Determine to:", logs[i].topics[2] == arrLog[i].topics[2])
}
}
*/
A funcionar em negociação ao vivo:
Para os resultados da execução, é também escrita no código uma secção de validação (TODO: test).TransferO evento do contrato USDT é continuamente monitorizado e os dados são registados e uma comparação entre esses dados e os dados do evento obtidos de uma só vez pode observar que os dados são consistentes com:
Filtragem de eventos
Baseado na lição anteriorListening to contract eventsQuando um contrato inteligente cria um log (ou seja, libera um evento), os dados do logtopicsEntão nós projetamos uma regra de filtro com[[A1, A2, ...An], null, [C1], D]como exemplo.
[A1, A2, ...An]corresponde aos dados na posiçãotopics[0].Nullcorresponde aos dados na posiçãotopics[1].[C1]corresponde aos dados na posiçãotopics[2].Dcorresponde aos dados na posiçãotopics[3].
- Se um elemento da estrutura de condições for definido
nullsignifica que não é filtrado, por exemplo:nullcorresponde atopics[1]e quaisquer correspondências de valor. - Se o elemento da estrutura de condições definir um único valor indicando que a posição deve corresponder, por exemplo:
[C1]corresponde atopics[2]ouDcorresponde atopics[3], e os registos não correspondentes são filtrados. - Se o elemento na estrutura de condição é uma matriz, isso significa que pelo menos um dos elementos da matriz deve corresponder, por exemplo
[A1, A2, ...An]corresponde atopics[0],[A1, A2, ...An]com qualquer um deles combinandotopics[0], então os registos não serão filtrados.
Ouvir transferências em USDT de bolsas
MonitorizaçãoUSDTTransações transferidas da e para a Binance Exchange:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function addEventListener(contractAddress, event, callBack) {
var self = {}
self.eventHash = "0x" + Encode("keccak256", "string", "hex", event)
self.contractAddress = contractAddress
self.latestBlockNumber = 0
self.fromBlockNumber = 0
self.firstBlockNumber = 0
self.filters = []
self.setFilter = function(filterCondition) {
if (filterCondition.length > 4) {
throw "filterCondition error"
}
self.filters.push(filterCondition)
Log("Set filter conditions:", filterCondition)
}
self.getTokenBalanceOfWallet = function(walletAddress, tokenAddress, tokenDecimals) {
var balance = exchange.IO("api", tokenAddress, "balanceOf", walletAddress)
if (balance) {
return toAmount(balance, tokenDecimals)
}
return null
}
self.getBlockNumber = function() {
var maxTry = 10
for (var i = 0; i < maxTry; i++) {
var ret = exchange.IO("api", "eth", "eth_blockNumber")
if (ret) {
return toAmount(ret, 0)
}
Sleep(5000)
}
throw "getBlockNumber failed"
}
self.run = function() {
var currBlockNumber = self.getBlockNumber()
var fromBlock = "0x" + self.fromBlockNumber.toString(16)
var toBlock = "0x" + currBlockNumber.toString(16)
var params = {
"fromBlock" : fromBlock,
"toBlock" : toBlock,
"address" : self.contractAddress,
"topics" : [self.eventHash]
}
var logs = exchange.IO("api", "eth", "eth_getLogs", params)
if (!logs) {
return
}
for (var i = 0; i < logs.length; i++) {
if (toAmount(logs[i].blockNumber, 0) > self.latestBlockNumber) {
// Check the filter condition, and execute the judgment if the filter condition is set
if (self.filters.length != 0) {
// Initial filter marker
var isFilter = true
// Traverse filter condition setting
for (var j = 0; j < self.filters.length; j++) {
// Take a filter setting, e.g: [[A1, A2, ...An], null, [C1], D]
var cond = self.filters[j]
// Traverse the filter setting
var final = true
for (var topicsIndex = 0; topicsIndex < cond.length; topicsIndex++) {
// Take one of the conditions in the filter setting, if it is the first condition: i.e. the data to be compared with topics[0]
var condValue = cond[topicsIndex]
// Data in the logs
if (topicsIndex > logs[i].topics.length - 1) {
continue
}
var topicsEleValue = logs[i].topics[topicsIndex]
// If it's a Transfer event, you need to handle the from and to
if (logs[i].topics[0] == "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") {
if (topicsIndex == 1 || topicsIndex == 2) {
topicsEleValue = "0x" + exchange.IO("encodePacked", "address", topicsEleValue)
}
}
// If the condValue type is an array, it means that there are multiple comparison conditions in this position, and the multiple condition comparison is a logical or relationship
if (Array.isArray(condValue) && condValue.length > 1) {
// Determine condValue[0] == topicsEleValue || condValue[1] == topicsEleValue
final = final && condValue.some(element => element === topicsEleValue)
}else if (condValue === null) {
final = final && true
} else {
final = final && (condValue === topicsEleValue)
}
}
if (final) {
isFilter = false
}
}
if (isFilter) {
continue
}
}
callBack(logs[i])
}
}
self.latestBlockNumber = currBlockNumber
self.fromBlockNumber = self.latestBlockNumber - 1
}
self.latestBlockNumber = self.getBlockNumber()
self.fromBlockNumber = self.latestBlockNumber - 1
return self
}
var listener = null
function main() {
// Initial clean-up log
LogReset(1)
LogProfitReset()
var event = "Transfer(address,address,uint256)" // Listening to events
var contractAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7" // USDT contract address
var decimals = exchange.IO("api", contractAddress, "decimals") // Get the precision information of USDT token
var accountBinanceAddress = "0x28C6c06298d514Db089934071355E5743bf21d60" // Binance hot wallet address
accountBinanceAddress = accountBinanceAddress.toLowerCase() // Addresses are handled in lowercase
Log(exchange.IO("api", contractAddress, "name"), " decimals:", decimals)
// Creating a listener object
listener = addEventListener(contractAddress, event, function(log) {
var fromAddress = "0x" + exchange.IO("encodePacked", "address", log.topics[1])
var toAddress = "0x" + exchange.IO("encodePacked", "address", log.topics[2])
if (fromAddress == accountBinanceAddress) {
Log("Binance transfer out - ", " Transfer:", fromAddress, "->", toAddress, ", value:", toAmount(log.data, decimals), ", blockNumber:", toAmount(log.blockNumber, 0), "#CD32CD")
} else if (toAddress == accountBinanceAddress) {
Log("Binance transfer in - ", " Transfer:", fromAddress, "->", toAddress, ", value:", toAmount(log.data, decimals), ", blockNumber:", toAmount(log.blockNumber, 0), "#FF0000")
}
})
// Set up event filtering
listener.setFilter([null, accountBinanceAddress, null]) // Binance -> USDT
listener.setFilter([null, null, accountBinanceAddress]) // USDT -> Binance
var preBalance = 0
while (true) {
listener.run()
var balance = listener.getTokenBalanceOfWallet(accountBinanceAddress, contractAddress, decimals)
if (balance) {
var direction = ""
if (preBalance != 0 && preBalance > balance) {
direction = " ↓ " + (preBalance - balance) + "#CD32CD"
} else if (preBalance != 0 && preBalance < balance) {
direction = " ↑ " + (balance - preBalance) + "#FF0000"
}
Log("Binance wallet address:", accountBinanceAddress, " balance:", balance, direction)
LogProfit(balance, "&") // Drawing only, no log printing
preBalance = balance
}
LogStatus(_D(), "Binance wallet address:", accountBinanceAddress, ", balance:", balance)
Sleep(5000 * 3)
}
}
O código acima executado na negociação em tempo real:
Nesta lição, nós apresentamos como projetar um filtro de eventos.USDTVocê pode modificar e estender este programa de amostra para ouvir qualquer evento que você está interessado, para ver quais novas transaçõessmart moneyO que é que a Comissão tem feito?NFTOs magnates correram, etc.
Conversões de unidades
Muitos dos cálculos relacionados ao Ethereum têm valores que excedem o número inteiro seguro máximo doJavaScriptPor isso, alguns métodos são necessários na plataforma de negociação de quantidade FMZ para lidar com grandes valores, que usamos especificamente em cursos anteriores e não cobrimos em detalhe.
Imprimir o inteiro máximo seguro definido noJavaScriptLíngua:
function main() {
Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER)
}
Resultados de execução:
Número.MAX_SAFE_INTEGER: 9007199254740991
BigInt
A menor unidade definida no Ethereum é1wei, e a definição1Gweié igual a1000000000 wei. 1Gweinão é realmente um número muito grande em cálculos relacionados com Ethereum, e alguns dados são muito maiores do que ele.Number.MAX_SAFE_INTEGER: 9007199254740991.
Na FMZ Quant Trading Platform, usamos as plataformasBigIntObjeto para representar estes dados inteiros muito grandes.BigInt()para construir oBigIntVocê pode construirBigIntobjetos que usam cadeias numéricas hexadecimais como parâmetros.toString()método deBigIntObjeto para produzir os dados representados pelo objeto como uma cadeia.
As operações apoiadas peloBigIntObjeto são:
- Adição:
+ - Subtração:
- - Multiplicação:
* - Divisão:
/ - Operações de módulo:
% - Operações de potência:
*
Ver os seguintes exemplos de códigos:
function main() {
// Decimal representation of 1Gwei
var oneGwei = 1000000000
// Decimal to hexadecimal conversion of 1Gwei
var oneGweiForHex = "0x" + oneGwei.toString(16)
Log("oneGwei : ", oneGwei)
Log("oneGweiForHex : ", oneGweiForHex)
// Constructing BigInt objects
Log("1Gwei / 1Gwei : ", (BigInt(oneGwei) / BigInt(oneGweiForHex)).toString(10))
Log("1Gwei * 1Gwei : ", (BigInt(oneGwei) * BigInt(oneGweiForHex)).toString(10))
Log("1Gwei - 1Gwei : ", (BigInt(oneGwei) - BigInt(oneGweiForHex)).toString(10))
Log("1Gwei + 1Gwei : ", (BigInt(oneGwei) + BigInt(oneGweiForHex)).toString(10))
Log("(1Gwei + 1) % 1Gwei : ", (BigInt(oneGwei + 1) % BigInt(oneGweiForHex)).toString(10))
Log("1Gwei ** 2 : ", (BigInt(oneGwei) ** BigInt(2)).toString(10))
Log("The square root of 100 : ", (BigInt(100) ** BigFloat(0.5)).toString(10))
Log("Number.MAX_SAFE_INTEGER : ", BigInt(Number.MAX_SAFE_INTEGER).toString(10))
Log("Number.MAX_SAFE_INTEGER * 2 : ", (BigInt(Number.MAX_SAFE_INTEGER) * BigInt("2")).toString(10))
}
Teste da ferramenta de depuração:
2023-06-08 11:39:50 Info Number.MAX_SAFE_INTEGER * 2 : 18014398509481982
2023-06-08 11:39:50 Info Number.MAX_SAFE_INTEGER : 9007199254740991
2023-06-08 11:39:50 Info The square root of 100 : 10
2023-06-08 11:39:50 Info 1Gwei ** 2 : 1000000000000000000
2023-06-08 11:39:50 Info (1Gwei + 1) % 1Gwei : 1
2023-06-08 11:39:50 Info 1Gwei + 1Gwei : 2000000000
2023-06-08 11:39:50 Info 1Gwei - 1Gwei : 0
2023-06-08 11:39:50 Info 1Gwei * 1Gwei : 1000000000000000000
2023-06-08 11:39:50 Info 1Gwei / 1Gwei : 1
2023-06-08 11:39:50 Info oneGweiForHex : 0x3b9aca00
2023-06-08 11:39:50 Info oneGwei : 1000000000
BigFloat
OBigFloatObjeto é usado de forma semelhante aoBigIntObjeto para representar números de vírgula flutuante com valores maiores, e também suporta adição, subtração, multiplicação e divisão.
OBigFloatO objeto suporta otoFixed() method.
Referir-se-á ao seguinte exemplo de código:
function main() {
var pi = 3.14
var oneGwei = "1000000000"
var oneGweiForHex = "0x3b9aca00"
Log("pi + oneGwei : ", (BigFloat(pi) + BigFloat(oneGwei)).toFixed(2))
Log("pi - oneGweiForHex : ", (BigFloat(pi) - BigFloat(oneGweiForHex)).toFixed(2))
Log("pi * 2.0 : ", (BigFloat(pi) * BigFloat(2.0)).toFixed(2))
Log("pi / 2.0 : ", (BigFloat(pi) / BigFloat(2.0)).toFixed(2))
}
Teste da ferramenta de depuração:
2023-06-08 13:56:44 Info pi / 2.0 : 1.57
2023-06-08 13:56:44 Info pi * 2.0 : 6.28
2023-06-08 13:56:44 Info pi - oneGweiForHex : -999999996.86
2023-06-08 13:56:44 Info pi + oneGwei : 1000000003.14
BigDecimal
OBigDecimalObjeto é compatível com valores inteiros e valores de ponto flutuante e suporta inicialização com oBigIntObjeto eBigFloate também suporta adição, subtração, multiplicação e divisão.
Referir-se-á ao seguinte exemplo de código:
function main() {
var pi = 3.1415
var oneGwei = 1000000000
var oneGweiForHex = "0x3b9aca00"
Log("pi : ", BigDecimal(pi).toFixed(2))
Log("oneGwei : ", BigDecimal(oneGwei).toString())
Log("oneGweiForHex : ", BigDecimal(BigInt(oneGweiForHex)).toString())
Log("BigInt(oneGwei) : ", BigDecimal(BigInt(oneGwei)).toString())
Log("BigFloat(pi) : ", BigDecimal(BigFloat(pi)).toFixed(4))
Log("oneGwei + pi : ", (BigDecimal(oneGwei) + BigDecimal(pi)).toString())
Log("oneGwei - pi : ", (BigDecimal(oneGwei) - BigDecimal(pi)).toString())
Log("2.0 * pi : ", (BigDecimal(2.0) * BigDecimal(pi)).toString())
Log("pi / pi : ", (BigDecimal(pi) / BigDecimal(pi)).toString())
}
Execução na ferramenta de depuração:
2023-06-08 14:52:53 Info pi / pi : 1
2023-06-08 14:52:53 Info 2.0 * pi : 6.283
2023-06-08 14:52:53 Info oneGwei - pi : 999999996.8585
2023-06-08 14:52:53 Info oneGwei + pi : 1000000003.1415
2023-06-08 14:52:53 Info BigFloat(pi) : 3.1415
2023-06-08 14:52:53 Info BigInt(oneGwei) : 1e+9
2023-06-08 14:52:53 Info oneGweiForHex : 1e+9
2023-06-08 14:52:53 Info oneGwei : 1e+9
2023-06-08 14:52:53 Info pi : 3.14
Conversões de unidades
As seguintes duas funções:toAmount(), toInnerAmount()Nós usamos muitas vezes em cursos anteriores, estas duas funções são usadas principalmente para a conversão de precisão de dados.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
OtoAmount()função converte (reduz) uma variávelsDe acordo com o parâmetro de precisãodecimalsNo desenvolvimento prático da web3, é frequentemente necessário lidar com alguns dados hexadecimais encadeados.
O que se passa com a formação profissional é que a formação profissional não é apenas uma questão de tempo, mas também de tempo.datadados de campo noTransfer(address,address,uint256)caso de um contrato inteligente:
{
"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000",
"topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x0000000000000000000000006b75d8af000000e20b7a7ddf000ba900b4009a80", "0x000000000000000000000000bcb095c1f9c3dc02e834976706c87dee5d0f1fb6"],
"transactionHash": "0x27f9bf5abe3148169b4b85a83e1de32bd50eb81ecc52e5af006157d93353e4c4",
"transactionIndex": "0x0",
"removed": false,
"address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"blockHash": "0x847be24a7b159c292bda030a011dfec89487b70e71eed486969b032d6ef04bad",
"blockNumber": "0x109b1cc",
"logIndex": "0x0"
}
Ao processar dados"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000", usamos otoAmount()Este processamento é projetado para fazer um bom trabalho de conversão de dados de campo de dados para valores legíveis.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var data = "0x00000000000000000000000000000000000000000000000001c1a55000000000"
Log(toAmount(data, 18)) // Print out 0.12656402755905127
}
1 token ETH, como sabemos, é1e18 wei, se conseguirmos dados126564027559051260emwei, como convertê-lo em tokens ETH?
Utilizando otoAmount(, 18)A função é um método de conversão muito simples.toInnerAmount()A função é a operação inversa dotoAmount()A função de convergência de dados é a função de convergência de dados (dependendo da precisão, zoom em), e é fácil converter os dados usando estas duas funções.
É importante notar o intervalo de segurança de valor inteiro na linguagem JavaScript,Number.MAX_SAFE_INTEGER, e o exemplo a seguir ilustra um problema oculto na conversão de dados:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var amount = 0.01
var innerAmount = Number(toInnerAmount(amount, 18))
Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER) // 9007199254740991
Log("innerAmount:", innerAmount) // 10000000000000000
Log("typeof(innerAmount):", typeof(innerAmount), ", innerAmount:", innerAmount)
// Decimal value 10000000000000000 -> Hexadecimal value 0x2386f26fc10000
Log("Convert", innerAmount, "to hexadecimal:", innerAmount.toString(16))
Log("Convert", BigInt(10000000000000000).toString(10), "to hexadecimal:", BigInt(10000000000000000).toString(16))
Log("0x" + BigInt(10000000000000000).toString(16), "Convert to decimal:", toAmount("0x" + BigInt(10000000000000000).toString(16), 0))
}
É possível executar na ferramenta de depuração:
2023-06-15 16:21:40 Info Convert 0x2386f26fc10000 to decimal: 10000000000000000
2023-06-15 16:21:40 Info Convert 10000000000000000 to hexadecimal: 2386f26fc10000
2023-06-15 16:21:40 Info Convert 10000000000000000 to hexadecimal: 10000000000000000
2023-06-15 16:21:40 Info typeof(innerAmount): number , innerAmount: 10000000000000000
2023-06-15 16:21:40 Info innerAmount: 10000000000000000
2023-06-15 16:21:40 Info Number.MAX_SAFE_INTEGER: 9007199254740991
Através da observação, descobrimos que:
Log("Convert", innerAmount, "to hexadecimal:", innerAmount.toString(16))
Esta linha de código corresponde à saída de log:Converting 10000000000000000 to hex: 10000000000000000A razão é, naturalmente, que 10000000000000000 é alémNumber.MAX_SAFE_INTEGER.
Mas quando o valor decimal está dentro do intervalo seguro, ou seja, menor queNumber.MAX_SAFE_INTEGER, otoString(16)função converte-o novamente corretamente, por exemplo:
function main() {
var value = 1000
Log("Convert value to hexadecimal:", "0x" + value.toString(16)) // 0x3e8
Log("Convert 0x3e8 to decimal:", Number("0x3e8")) // 1000
}
No blockchain, até0.01ETH convertidos para um valor de10000000000000000emweiexcederáNumber.MAX_SAFE_INTEGER``, so a safer conversion for such cases is:BigInt ((10000000000000000).toString ((16) ``.
Chamadas de simulação
Execução de transacções e chamada deWriteO método de contratos inteligentes no Ethereum custa uma certa quantidade de gás e às vezes falha. É importante saber quais transações provavelmente falharão antes de enviá-las e chamá-las.
eth_call
Método RPC do Ethereumeth_call: pode simular uma transação e retornar o resultado de uma possível transação, mas não executa realmente a transação no blockchain.
Oeth_callO método tem 2 parâmetros, o primeiro é uma estrutura de dicionário,transactionObject:
// transactionObject
{
"from" : ..., // The address from which the transaction is sent
"to" : ..., // The address to which the transaction is addressed
"gas" : ..., // The integer of gas provided for the transaction execution
"gasPrice" : ..., // The integer of gasPrice used for each paid gas encoded as hexadecimal
"value" : ..., // The integer of value sent with this transaction encoded as hexadecimal
"data" : ..., // The hash of the method signature and encoded parameters. For more information, see the Contract ABI description in the Solidity documentation
}
O segundo parâmetroblockNumberPode passar o rótulolatest/pending/earliest, etc.:
/* blockNumber
The block number in hexadecimal format or the string latest, earliest, pending, safe or
finalized (safe and finalized tags are only supported on Ethereum, Gnosis, Arbitrum,
Arbitrum Nova and Avalanche C-chain), see the default block parameter description in
the official Ethereum documentation
*/
Em seguida, tomamos o método de contrato inteligenteapproveetransferchamadas do tokenDAIcomo exemplo para chamadas de simulação, e o seguinte ambiente de teste é a principal rede Ethereum.
Simulação de chamada aprovada
Todos nós conhecemos oapproveA simulação de um contrato inteligente não é necessária para que o contrato inteligente seja chamado pela simulação, já que o contrato ERC20 já está integrado na plataforma ABI da FMZ.
function main() {
var contractAddressUniswapV3SwapRouterV2 = "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")
// encode approve
var data = exchange.IO("encode", contractAddress_DAI, "approve(address,uint256)",
contractAddressUniswapV3SwapRouterV2, "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
Log("ERC20 token DAI approve encode, data:", data)
var transactionObject = {
"from" : wallet,
"to" : contractAddress_DAI,
// "gasPrice" : "0x" + parseInt("21270894680").toString(16),
// "gas" : "0x" + parseInt("21000").toString(16),
"data" : "0x" + data,
}
var blockNumber = "latest"
var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
Log("ret:", ret)
}
O código no exemplo codifica primeiro oapprove(address,uint256)método e parâmetros, bem como o valor do parâmetro0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdoapproveA autorização é dada ao contrato inteligente no endereço0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45Ou seja, o contrato de roteador paraUniswap V3Finalmente o método Ethereum RPCeth_callA simulação é chamada de simulação.gasPriceegasOs campos notransactionObjectOs parâmetros podem ser omitidos.
A ferramenta de depuração é executada e a simulação chama o método de aprovação para autorizar com sucesso (não autoriza realmente):
2023-06-09 11:58:39 Info ret: 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 11:58:39 Info ERC20 token DAI approve encode, data: 095ea7b300000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
É também possível simular alguns cenários de falha, quando ajustamos ogasPriceegasParâmetros, se o ETH na carteira não for suficiente para pagar a taxa de gás, um erro será relatado::
fundos insuficientes
Quando o custo do gás for demasiado baixo, será notificado um erro:
Gás intrínseco muito baixo: 21000, quero 21944 (gás fornecido 21000)
Transferência de chamadas de simulação
Estamos familiarizados com ERC20transfermétodo, que permite transferir tokens ERC20 para um determinado endereço de carteira, então vamos tentar simular uma transferência de 1000 DAI para Vitalik Buterin.
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var walletVitalik = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")
// transfer to Vitalik Buterin
var decimals_DAI = exchange.IO("api", contractAddress_DAI, "decimals")
var transferAmount = toInnerAmount(1000, decimals_DAI)
Log("Transfer amount:", 1000, "DAI, use toInnerAmount convert to:", transferAmount)
// encode transfer
var data = exchange.IO("encode", contractAddress_DAI, "transfer(address,uint256)",
walletVitalik, transferAmount)
var transactionObject = {
"from" : wallet,
"to" : contractAddress_DAI,
"data" : "0x" + data,
}
var blockNumber = "latest"
var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
return ret
}
Uma vez que eu não tenho DAI tokens nesta carteira de teste, executando-o na ferramenta de depuração relatou o seguinte erro inesperadamente:
Execução revertida: Dai/saldo insuficiente
Verifica o endereço da carteira do Vitalik Buterin:0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045Então vamos ajustar a direção de transferência da chamada de simulação e simular a transferência de 1000 DAI de Vitalik Buterin para nós.
Modificar o código, onde as alterações que eu fiz comentários:
function toInnerAmount(n, decimals) {
return (BigDecimal(n) * BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
var walletVitalik = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
var contractAddress_DAI = "0x6b175474e89094c44da98b954eedeac495271d0f"
var wallet = exchange.IO("address")
var decimals_DAI = exchange.IO("api", contractAddress_DAI, "decimals")
var transferAmount = toInnerAmount(1000, decimals_DAI)
Log("Transfer amount:", 1000, "DAI, use toInnerAmount convert to:", transferAmount)
// encode transfer
var data = exchange.IO("encode", contractAddress_DAI, "transfer(address,uint256)",
wallet, transferAmount) // Use the wallet variable as a parameter and change the transfer recipient's address to my own
var transactionObject = {
"from" : walletVitalik, // Use the walletVitalik variable as the value of the from field to simulate that the call was made from the Vitalik Buterin's wallet address
"to" : contractAddress_DAI,
"data" : "0x" + data,
}
var blockNumber = "latest"
var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
Log(ret)
}
Teste de ferramenta de depuração:
2023-06-09 13:34:31 Info 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 13:34:31 Info Transfer amount: 1000 DAI, use toInnerAmount convert to: 1000000000000000000000
Usando a Plataforma de Negociação Quant FMZ, é fácil simular os resultados das transações e evitar a perda desnecessária de taxas de gás do envio de transações potencialmente falhadas.eth_callUse a sua imaginação, o que você usaria oeth_call- O método para quê?
Identificar os contratos ERC721
Sabemos que tokens como ETH e BTC são tokens homogeneizados, e o token em sua carteira não é diferente do token na minha carteira. Mas há muitas coisas no mundo que não são homogêneas, como imóveis, antiguidades, obras de arte virtuais, etc. Estes não podem ser representados por tokens homogêneos em abstração. Portanto, há o padrão ERC721 para abstrair objetos não homogêneos, e há NFT e conceitos relacionados. Então, entre os muitos contratos inteligentes implantados no Ethereum, como podemos identificar quais contratos inteligentes são contratos inteligentes padrão ERC721?
Para identificar o ERC721, é importante conhecer primeiro a norma ERC165.
ERC165
Com o padrão ERC165, um contrato inteligente pode declarar as interfaces que suporta para outros contratos verificarem.supportsInterface(bytes4 interfaceId), o parâmetrointerfaceIdSe o contrato implementar o interfaceId retornará um valor verdadeiro booleano, caso contrário, retornará um valor falso.
Aqui vamos falar sobre como issointerfaceIdé calculado e codificado especificamente.
Norma ERC165mostra um exemplo:
pragma solidity ^0.4.20;
interface Solidity101 {
function hello() external pure;
function world(int) external pure;
}
contract Selector {
function calculateSelector() public pure returns (bytes4) {
Solidity101 i;
return i.hello.selector ^ i.world.selector;
}
}
Para a assinatura de função da interface (composta por um nome de função e uma lista de tipos de parâmetros) para executar uma operação de dissimilaridade, para um contrato de interface ERC165 em que o contrato tem apenas uma função:
pragma solidity ^0.4.20;
interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
O identificador de interface para esta interface é 0x01ffc9a7. Você pode calcular isso executando bytes4 ((keccak256(
supportsInterface(bytes4) )); ou usando o contrato Selector acima.
Calcule a assinatura da função diretamente e tome seus primeiros 4 bytes para chegar ainterfaceId.
function main() {
var ret = Encode("keccak256", "string", "hex", "supportsInterface(bytes4)")
Log("supportsInterface(bytes4) interfaceId:", "0x" + ret.slice(0, 8))
}
Os testes podem ser executados na ferramenta de depuração em:
2023-06-13 14:53:35 Info supportsInterface(bytes4) interfaceId: 0x01ffc9a7
Pode-se observar que os resultados calculados são consistentes com a descrição noNorma ERC165 document.
ERC721
Em seguida, vejamos a definição de interface da norma ERC721:
interface ERC721 /* is ERC165 */ {
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
Se quisermos determinar se um contrato inteligente é um contrato ERC721, primeiro precisamos saber ointerfaceIdO que é que a Comissão está a fazer neste momento?supportsInterface(bytes4 interfaceId)Os cursos anteriores familiarizaram-nos com alguns conceitos do padrão ERC165 e com o algoritmo para o cálculo dointerfaceId, e escrevemos código para calcular diretamente:
function calcSelector(arrSelector) {
var ret = null
if (Array.isArray(arrSelector)) {
if (arrSelector.length == 1) {
ret = Encode("keccak256", "string", "hex", arrSelector[0])
} else if (arrSelector.length == 0) {
throw "Error: the number of elements in the array is 0"
} else {
var viewEncodeData = null
for (var i = 0; i < arrSelector.length; i++) {
if (i == 0) {
ret = new Uint8Array(Encode("keccak256", "string", "raw", arrSelector[i]))
} else {
viewData = new Uint8Array(Encode("keccak256", "string", "raw", arrSelector[i]))
if (viewData.length != ret.length) {
throw "Error: TypeArray view length is different"
}
for (var index = 0; index < ret.length; index++) {
ret[index] ^= viewData[index]
}
}
}
ret = Encode("raw", "raw", "hex", ret.buffer)
}
} else {
throw "Error: The parameter requires an array type."
}
return "0x" + ret.slice(0, 8)
}
function main() {
// supportsInterface(bytes4): 0x01ffc9a7
// var ret = calcSelector(["supportsInterface(bytes4)"])
// ERC721Metadata: 0x5b5e139f
/*
var arrSelector = [
"name()",
"symbol()",
"tokenURI(uint256)"
]
var ret = calcSelector(arrSelector)
*/
// ERC721: 0x80ac58cd
// /*
var arrSelector = [
"balanceOf(address)",
"ownerOf(uint256)",
"safeTransferFrom(address,address,uint256,bytes)",
"safeTransferFrom(address,address,uint256)",
"transferFrom(address,address,uint256)",
"approve(address,uint256)",
"setApprovalForAll(address,bool)",
"getApproved(uint256)",
"isApprovedForAll(address,address)",
]
var ret = calcSelector(arrSelector)
// */
Log(ret)
}
O código utiliza oEncode()função para o cálculo da assinatura da função (akeccak256Algoritmo), e para o cálculo no exemplo de código acima, especificando o parâmetro de saída doEncode()função como"raw", a função retorna oArrayBufferTipo deJavaScriptlinguagem.
Para realizar um^(iso-ou) operação em doisArrayBufferObjetos, você precisa criar umTypedArrayA opinião baseada noArrayBufferObjeto, então itere através dos dados nele e executar a operação iso-ou um por um.
Execute na ferramenta de depuração:
2023-06-13 15:04:09 Info 0x80ac58cd
Os resultados calculados são consistentes com os descritos na secçãoeip-721.
pragma solidity ^0.4.20;
/// @title ERC-721 Non-Fungible Token Standard/// @dev See https://eips.ethereum.org/EIPS/eip-721/// Note: the ERC-165 identifier for this interface is 0x80ac58cd.interface ERC721 /* is ERC165 */ {
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
...
Com a ID de interface ERC721, podemos determinar se um contrato é um contrato padrão ERC721 ou não.BAYCPara fazer o teste, que é um contrato que segue ERC721. Primeiro precisamos registrar o ABI, e como nós apenas chamamos os três métodos a seguir, podemos registrar esses três métodos:
- Suporte Interface ((interfaceId)
- símbolo ((()
- Nome (s)
Os códigos específicos são os seguintes:
function main() {
// Contract address for ERC721, BAYC is used here
var testContractAddress = "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d"
var testABI = `[{
"inputs": [{
"internalType": "bytes4",
"name": "interfaceId",
"type": "bytes4"
}],
"name": "supportsInterface",
"outputs": [{
"internalType": "bool",
"name": "",
"type": "bool"
}],
"stateMutability": "view",
"type": "function"
}, {
"inputs": [],
"name": "symbol",
"outputs": [{
"internalType": "string",
"name": "",
"type": "string"
}],
"stateMutability": "view",
"type": "function"
}, {
"inputs": [],
"name": "name",
"outputs": [{
"internalType": "string",
"name": "",
"type": "string"
}],
"stateMutability": "view",
"type": "function"
}]`
// ERC721 Interface Id, calculated in the previous course
var interfaceId = "0x80ac58cd"
// Register ABI
exchange.IO("abi", testContractAddress, testABI)
// Call the supportsInterface method
var isErc721 = exchange.IO("api", testContractAddress, "supportsInterface", interfaceId)
// Output Information
Log("Contract address:", testContractAddress)
Log("Contract name:", exchange.IO("api", testContractAddress, "name"))
Log("Contract code:", exchange.IO("api", testContractAddress, "symbol"))
Log("Whether the contract is ERC721 standard:", isErc721)
}
Os testes podem ser executados na ferramenta de depuração:
2023-06-13 16:32:57 Info Whether the contract is ERC721 standard: true
2023-06-13 16:32:57 Info Contract code: BAYC
2023-06-13 16:32:57 Info- Novo recurso do FMZ Quant: Use a função _Serve para criar serviços HTTP facilmente
- Inventores quantificam novas funcionalidades: criar serviços HTTP facilmente com a função _Serve
- FMZ Quant Trading Platform Guia de acesso ao protocolo personalizado
- Estratégia de aquisição e acompanhamento da taxa de financiamento da FMZ
- Estratégias de captação e monitoramento de taxas de financiamento da FMZ
- Um modelo de estratégia permite que você use o WebSocket Market sem problemas
- Um modelo de estratégia para usar o WebSocket sem problemas
- Guia de acesso ao Protocolo Geral para Inventores de Plataformas de Negociação Quantificadas
- Como construir uma estratégia de negociação multi-moeda universal rapidamente após a atualização da FMZ
- Como construir rapidamente uma estratégia de negociação multicurrency geral após a atualização do FMZ
- Negociação de DCA: Uma estratégia quantitativa amplamente utilizada
- Ensinar a projetar biblioteca de classe modelo para obter dados de linha K de comprimento especificado
- Aprenda a projetar uma biblioteca de modelos para obter dados de linha especificados de K-longitude.
- Explore as novas funções do editor de estratégia FMZ: Como o ChatGPT melhora significativamente a sua produtividade quantitativa