Introducción fácil con FMZ al desarrollo web3 basado en Ethereum
El autor:Los inventores cuantifican - sueños pequeños, Creado: 2023-03-28 13:32:48, Actualizado: 2024-11-11 22:28:24 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 escucha = cero
Función principal
Vario evento =
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: prueba Var arrLog = [] La función onexit ((() { Log (la barra de finalización de la ejecución, la barra de registro de verificación) var firstBlockNumber = escuchador.firstBlockNumber var endBlockNumber = listener.latestBlockNumber El número de bloque de var final es el número de bloque más reciente.
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("长度不等！")
return
}
for (var i = 0; i < arrLog.length; i++) {
Log("判断blockNumber：", logs[i].blockNumber == arrLog[i].blockNumber, "，判断from：", logs[i].topics[1] == arrLog[i].topics[1],
"判断to：", logs[i].topics[2] == arrLog[i].topics[2])
}
} */
实盘运行：
对于执行结果，代码中也编写了验证部分（TODO: test）。经过简单验证可以看到持续监控USDT合约的```Transfer```事件并且记录数据，用这个数据和一次性获取的事件数据对比可以观察出数据一致：
### 事件过滤
在上一节课程「监听合约事件」的基础上，我们拓展一下，在监听的过程中增加过滤器，监听指定地址的转入转出。当智能合约创建日志时（即释放事件），日志数据中```topics```最多包含4条信息。所以我们设计一个过滤规则，以```[[A1, A2, ...An], null, [C1], D]```为例子。
1、```[A1, A2, ...An]```对应```topics[0]```位置的数据。
2、```null```对应```topics[1]```位置的数据。
3、```[C1]```对应```topics[2]```位置的数据。
4、```D```对应```topics[3]```位置的数据。
- 如果条件结构中的元素设置```null```表示不被过滤，例如```null```对应```topics[1]```，任何值都匹配。
- 如果条件结构中的元素设置单个值表示该位置必须匹配，例如```[C1]```对应```topics[2]```或者```D```对应```topics[3]```，不匹配的日志被过滤。
- 如果条件结构中的元素是一个数组，表示数组中的元素至少有一个要匹配，例如```[A1, A2, ...An]```对应```topics[0]```，```[A1, A2, ...An]```中有任意一个和```topics[0]```匹配，则日志不会被过滤。
**监听交易所的USDT转账**
监控从币安交易所转出、转入币安交易所```USDT```的交易：
```javascript
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("设置过滤条件：", 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) {
// 检查过滤条件，设置了过滤条件则执行判断
if (self.filters.length != 0) {
// 初始过滤标记
var isFilter = true
// 遍历过滤条件设置
for (var j = 0; j < self.filters.length; j++) {
// 取一个过滤设置，例如：[[A1, A2, ...An], null, [C1], D]
var cond = self.filters[j]
// 遍历这个过滤设置
var final = true
for (var topicsIndex = 0; topicsIndex < cond.length; topicsIndex++) {
// 拿到这个过滤设置中的某一个条件，如果是第一个条件：即要和topics[0]对比的数据
var condValue = cond[topicsIndex]
// 日志中的数据
if (topicsIndex > logs[i].topics.length - 1) {
continue
}
var topicsEleValue = logs[i].topics[topicsIndex]
// 如果是Transfer事件，需要处理from和to
if (logs[i].topics[0] == "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") {
if (topicsIndex == 1 || topicsIndex == 2) {
topicsEleValue = "0x" + exchange.IO("encodePacked", "address", topicsEleValue)
}
}
// 如果condValue类型是数组，表示该位置的对比条件有多个，多个条件对比是逻辑或关系
if (Array.isArray(condValue) && condValue.length > 1) {
// 判断 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() {
// 初始清理日志
LogReset(1)
LogProfitReset()
var event = "Transfer(address,address,uint256)" // 监听事件
var contractAddress = "0xdac17f958d2ee523a2206206994597c13d831ec7" // USDT合约地址
var decimals = exchange.IO("api", contractAddress, "decimals") // 获取USDT token的精度信息
var accountBinanceAddress = "0x28C6c06298d514Db089934071355E5743bf21d60" // Binance 热钱包地址
accountBinanceAddress = accountBinanceAddress.toLowerCase() // 地址处理为小写
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])
if (fromAddress == accountBinanceAddress) {
Log("币安转出 - ", " Transfer:", fromAddress, "->", toAddress, ", value:", toAmount(log.data, decimals), ", blockNumber:", toAmount(log.blockNumber, 0), "#CD32CD")
} else if (toAddress == accountBinanceAddress) {
Log("转入币安 - ", " Transfer:", fromAddress, "->", toAddress, ", value:", toAmount(log.data, decimals), ", blockNumber:", toAmount(log.blockNumber, 0), "#FF0000")
}
})
// 设置事件过滤
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("币安钱包地址：", accountBinanceAddress, " 余额：", balance, direction)
LogProfit(balance, "&") // 只画图，不打印日志
preBalance = balance
}
LogStatus(_D(), "币安钱包地址：", accountBinanceAddress, ", 余额：", balance)
Sleep(5000 * 3)
}
}
El código anterior se ejecuta en disco real:
En esta sección, mostramos cómo diseñar un filtro de eventos.USDTTransacción. Puedes modificar y ampliar este programa de ejemplo para escuchar cualquier evento que te interese y ver si es posible.smart money¿Cuáles son los nuevos acuerdos?NFT¿Qué proyectos nuevos ha hecho el edificio?
Unidad de conversión
En muchos cálculos relacionados con Ethereum, el valor es superior al valor de la moneda.JavaScriptLos números enteros más seguros del lenguaje. Por lo tanto, en las plataformas de negociación cuantitativa de inventores se necesitan algunos métodos para manejar los grandes números, que también hemos utilizado específicamente en cursos anteriores, sin explicar en detalle.
ImpresiónJavaScriptEl máximo número entero seguro definido en el lenguaje:
function main() {
Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER)
}
Los resultados:
No.MAX_SAFE_INTEGER: 9007199254740991 El número de la unidad es el siguiente:
¿ Qué pasa?
La unidad más pequeña definida en Ethereum es1wei, definido1Gweies igual a1000000000 wei。1GweiEn el cálculo relacionado con Ethereum, en realidad no es un gran número, algunos datos son mucho más grandes que él.Number.MAX_SAFE_INTEGER: 9007199254740991。
En el inventor de la plataforma de intercambio cuantitativo, usamos la plataforma para crear una plataforma de intercambio cuantificada.BigIntLos objetos representan estos datos de números enteros muy grandes.BigInt()Para construirBigIntObjetos. Puede utilizar un valor numérico, una cadena de valores numéricos de 16 dígitos como construcción de parámetros.BigIntObjetos y usos.BigIntObjetotoString()Métodos para exportar los datos representados por los objetos en forma de strings.
BigIntOperaciones apoyadas por objetos:
- El cálculo de la multiplicidad:
+ - La ley de deducción:
- - La multiplicación es:
* - Se calcula:
/ - Se trata de un proyecto de investigación.
% - El cálculo de las aceleraciones:
**
Para ver el ejemplo de código:
function main() {
// 1Gwei的十进制表示
var oneGwei = 1000000000
// 1Gwei的十进制转换为十六进制表示
var oneGweiForHex = "0x" + oneGwei.toString(16)
Log("oneGwei : ", oneGwei)
Log("oneGweiForHex : ", oneGweiForHex)
// 构造BigInt对象
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("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))
}
La prueba de herramientas de desactivación:
2023-06-08 11:39:50 信息 Number.MAX_SAFE_INTEGER * 2 : 18014398509481982
2023-06-08 11:39:50 信息 Number.MAX_SAFE_INTEGER : 9007199254740991
2023-06-08 11:39:50 信息 100 的平方根 : 10
2023-06-08 11:39:50 信息 1Gwei ** 2 : 1000000000000000000
2023-06-08 11:39:50 信息 (1Gwei + 1) % 1Gwei : 1
2023-06-08 11:39:50 信息 1Gwei + 1Gwei : 2000000000
2023-06-08 11:39:50 信息 1Gwei - 1Gwei : 0
2023-06-08 11:39:50 信息 1Gwei * 1Gwei : 1000000000000000000
2023-06-08 11:39:50 信息 1Gwei / 1Gwei : 1
2023-06-08 11:39:50 信息 oneGweiForHex : 0x3b9aca00
2023-06-08 11:39:50 信息 oneGwei : 1000000000
El BigFloat
BigFloatObjetos yBigIntEl uso de objetos es similar, se utiliza para representar números flotantes de mayor valor numérico y también admite operaciones de multiplicación adicionales y subtractivas.BigFloatApoyo de objetostoFixed()¿Cómo hacerlo?
Para ver el ejemplo 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))
}
La prueba de herramientas de desactivación:
2023-06-08 13:56:44 信息 pi / 2.0 : 1.57
2023-06-08 13:56:44 信息 pi * 2.0 : 6.28
2023-06-08 13:56:44 信息 pi - oneGweiForHex : -999999996.86
2023-06-08 13:56:44 信息 pi + oneGwei : 1000000003.14
- ¿ Qué pasa?
BigDecimalLos objetos son compatibles con valores enteros, valores flotantes y soportan el usoBigIntLos objetos.BigFloatInicialización de objetos y soporte para operaciones de multiplicación y suma y subtracción.
Para ver el ejemplo 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())
}
La herramienta de depuración funciona en:
2023-06-08 14:52:53 信息 pi / pi : 1
2023-06-08 14:52:53 信息 2.0 * pi : 6.283
2023-06-08 14:52:53 信息 oneGwei - pi : 999999996.8585
2023-06-08 14:52:53 信息 oneGwei + pi : 1000000003.1415
2023-06-08 14:52:53 信息 BigFloat(pi) : 3.1415
2023-06-08 14:52:53 信息 BigInt(oneGwei) : 1e+9
2023-06-08 14:52:53 信息 oneGweiForHex : 1e+9
2023-06-08 14:52:53 信息 oneGwei : 1e+9
2023-06-08 14:52:53 信息 pi : 3.14
Unidad de conversión
Las siguientes dos funciones:toAmount()、toInnerAmount()Estas dos funciones, que hemos usado varias veces en cursos anteriores, se utilizan principalmente para la conversión de precisión de datos.
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)
}
toAmount()Una función puede cambiar una variable.sEn el caso de los parámetros de precisióndecimalsRealizar una conversión de reducción. En el desarrollo real de la web3, a menudo se requiere procesar datos decimosextos en algunas cadenas.
Y esto es lo que hemos visto a menudo en cursos anteriores, como los contratos inteligentes.Transfer(address,address,uint256)En el casodataDatos de campo:
{
"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000",
"topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x0000000000000000000000006b75d8af000000e20b7a7ddf000ba900b4009a80", "0x000000000000000000000000bcb095c1f9c3dc02e834976706c87dee5d0f1fb6"],
"transactionHash": "0x27f9bf5abe3148169b4b85a83e1de32bd50eb81ecc52e5af006157d93353e4c4",
"transactionIndex": "0x0",
"removed": false,
"address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"blockHash": "0x847be24a7b159c292bda030a011dfec89487b70e71eed486969b032d6ef04bad",
"blockNumber": "0x109b1cc",
"logIndex": "0x0"
}
Procesamiento de datos"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000"En este momento se usatoAmount()Funciones. Este tipo de diseño de procesamiento puede ser muy útil.dataLos datos del campo se convierten en valores legibles.
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
var data = "0x00000000000000000000000000000000000000000000000001c1a55000000000"
Log(toAmount(data, 18)) // 打印出 0.12656402755905127
}
Un token de ETH es lo que sabemos que es1e18 weiSi tenemos unaweiDatos en unidades126564027559051260¿Cómo se puede convertir en ETH?
UsotoAmount(, 18)La función puede ser convertida muy fácilmente.toInnerAmount()La función estoAmount()La operación inversa de la función (de acuerdo con la precisión, la amplificación) es muy conveniente para convertir datos con estas dos funciones.
Lo que hay que tener en cuenta es el rango de seguridad integer en el lenguaje JavaScript, es decir,Number.MAX_SAFE_INTEGEREl siguiente ejemplo muestra un problema más oculto en la conversión de datos:
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)
// 十进制数值 10000000000000000 -> 十六进制数值 0x2386f26fc10000
Log("转换", innerAmount, "为十六进制：", innerAmount.toString(16))
Log("转换", BigInt(10000000000000000).toString(10), "为十六进制：", BigInt(10000000000000000).toString(16))
Log("0x" + BigInt(10000000000000000).toString(16), "转换为10进制：", toAmount("0x" + BigInt(10000000000000000).toString(16), 0))
}
Se puede ejecutar en la herramienta de depuración:
2023-06-15 16:21:40 信息 0x2386f26fc10000 转换为10进制： 10000000000000000
2023-06-15 16:21:40 信息 转换 10000000000000000 为十六进制： 2386f26fc10000
2023-06-15 16:21:40 信息 转换 10000000000000000 为十六进制： 10000000000000000
2023-06-15 16:21:40 信息 typeof(innerAmount): number , innerAmount: 10000000000000000
2023-06-15 16:21:40 信息 innerAmount: 10000000000000000
2023-06-15 16:21:40 信息 Number.MAX_SAFE_INTEGER: 9007199254740991
En el video, se puede ver a la gente hablando de sus propias vidas.
Log("转换", innerAmount, "为十六进制：", innerAmount.toString(16))
La línea de código correspondiente a la salida del registro es:转换 10000000000000000 为十六进制： 10000000000000000La razón natural es que 10000000000000000 está más allá.Number.MAX_SAFE_INTEGER。
Pero cuando el valor decimal está dentro del límite de seguridad, es decir, es menor queNumber.MAX_SAFE_INTEGER¿Qué es lo que está pasando?toString(16)La conversión de funciones es normal, por ejemplo:
function main() {
var value = 1000
Log("把value转换为十六进制：", "0x" + value.toString(16)) // 0x3e8
Log("把0x3e8转换为十进制：", Number("0x3e8")) // 1000
}
En el campo de la blockchain, incluso0.01El cambio de ETH es:weiUnidad numérica10000000000000000Pero también se superan.Number.MAX_SAFE_INTEGEREn este caso, la conversión más segura es:BigInt(10000000000000000).toString(16)。
Llamadas simuladas
En este caso, el proceso de negociación de Ethereum es el mismo que el de los contratos inteligentes.WriteLos métodos requieren consumir ciertos gastos de gas y a veces existen riesgos de fracaso. Es muy importante saber qué transacciones pueden fallar antes de enviar transacciones o llamar.
- ¿ Qué pasa?
El método RPC de Ethereumeth_callSe puede simular una transacción y devolver los posibles resultados de la misma, pero no se ejecuta realmente en la cadena de bloques.
eth_callEl método tiene dos parámetros, el primero es una estructura de diccionario, y el segundo es una estructura de texto.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
}
El segundo parámetro esblockNumberSe puede enviar etiquetas:latest/pending/earliestY así sucesivamente:
/* 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
*/
El siguiente paso es usar un token.DAIEl método de contrato inteligenteapprove、transferLa llamada es un ejemplo de una llamada analógica, el siguiente entorno de prueba es la red Ethereum.
Aprobar las llamadas de simulación
Para los contratos ERC20approveEl método es muy familiar para todos nosotros, y lo hemos practicado en cursos anteriores. Como los contratos ERC20 ya están integrados en el ABI de la plataforma FMZ, no se necesita registrar el ABI del contrato inteligente que se quiere simular.
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)
}
El código en el ejemplo primero seráapprove(address,uint256)Los métodos, los parámetros son codificados.approveEl valor de los parámetros del método0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffIndica el número máximo de autorizaciones. Autorizar a un contrato inteligente, dirección0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45Es decir,Uniswap V3El contrato de enrutamiento. El último llamado al método Ethereum RPCeth_callEn la imagen de abajo se puede ver:transactionObjectEn los parámetrosgasPrice、gasLos campos pueden ser omitidos.
La herramienta de depuración se ejecuta, la autorización del método de aprobación de la llamada simulada es exitosa (no realmente autorizada):
2023-06-09 11:58:39 信息 ret: 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 11:58:39 信息 ERC20 token DAI approve encode, data: 095ea7b300000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
También podemos simular algunos escenarios de fracaso, cuando ajustamos la velocidad de la señal.gasPriceygasEn el parámetro, si el ETH en el monedero no es suficiente para pagar el gas, se produce un error:
fondos insuficientes
Cuando el precio del gas es demasiado bajo, se produce un error:
Gas intrínseco demasiado bajo: tiene 21000, quiere 21944 (gas suministrado 21000)
Se llama transfer analogía
Para el ERC20transferEl método que no conocemos es el de transferir tokens ERC20 a una dirección de monedero. Intentamos simular la transferencia de 1000 DAI a V.
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")
// 转账给V神
var decimals_DAI = exchange.IO("api", contractAddress_DAI, "decimals")
var transferAmount = toInnerAmount(1000, decimals_DAI)
Log("转账金额：", 1000, "DAI, 使用 toInnerAmount 转换为：", 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
}
Como mi monedero de prueba no tiene el token DAI, los resultados esperados en la herramienta de depuración fueron incorrectos:
ejecución revertida: Dai/saldo insuficiente
En la página web de V-Gods.com, se puede ver la dirección de este monedero:0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045Por supuesto, esta billetera tiene un token DAI. Entonces vamos a ajustar la dirección de transferencia de la llamada analógica, simulando que V Dios nos transfiere 1000 DAI.
En la parte de abajo de la imagen, el usuario puede ver el código modificado, y en el lugar de la modificación, escribo:
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("转账金额：", 1000, "DAI, 使用 toInnerAmount 转换为：", transferAmount)
// encode transfer
var data = exchange.IO("encode", contractAddress_DAI, "transfer(address,uint256)",
wallet, transferAmount) // 使用wallet变量作为参数，转账接收方地址改为我自己
var transactionObject = {
"from" : walletVitalik, // 使用walletVitalik变量作为from字段的值，模拟这个调用是由V神钱包地址发出
"to" : contractAddress_DAI,
"data" : "0x" + data,
}
var blockNumber = "latest"
var ret = exchange.IO("api", "eth", "eth_call", transactionObject, blockNumber)
Log(ret)
}
La prueba de herramientas de desactivación:
2023-06-09 13:34:31 信息 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 13:34:31 信息 转账金额： 1000 DAI, 使用 toInnerAmount 转换为： 1000000000000000000000
Utilizando la plataforma de transacciones cuantificadas de los inventores, se puede simular fácilmente el resultado de las transacciones y evitar la pérdida de gas innecesaria al enviar transacciones que podrían fallar. Utilizamos el código de ejemplo en el curso de este capítulo para simular la transferencia a la billetera de V, la llamada de la billetera de V a nosotros.eth_callHay muchas maneras más útiles.eth_call¿Dónde se usa el método?
Identificación de los contratos ERC721
Sabemos que los tokens como ETH, BTC y otros pertenecen a los tokens homogéneos, y los tokens que tienes en tu mano no son diferentes de los que tengo en mi mano. Pero hay muchas cosas en el mundo que son heterogéneas, por ejemplo, bienes raíces, antigüedades, obras de arte virtuales, etc., que no pueden ser representadas en forma abstracta con tokens homogéneos. Entonces, ¿cómo podemos identificar cuáles de los muchos contratos inteligentes que se están implementando en Ethereum son los contratos inteligentes del estándar ERC721?
Para reconocer ERC721, primero hay que entender el estándar ERC165.
El valor de las pérdidas
A través del estándar ERC165, los contratos inteligentes pueden declarar las interfaces que apoyan para que otros contratos sean examinados.supportsInterface(bytes4 interfaceId), el parámetrointerfaceIdEl ID de la interfaz a consultar. Si el contrato realiza el ID de la interfaz, el valor de Boole es verdadero, y si no, el valor de Boole es falso.
A continuación vamos a hablar de esto.interfaceIdEn la actualidad, la mayoría de los usuarios de Twitter están utilizando el código de código de Google para crear sus propios mensajes.
Estándar ERC165En este caso, el tema es el de las mujeres.
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 la firma de funciones de la interfaz (compuesta por una lista de nombres de funciones y tipos de parámetros), se realiza una diferenciación o cálculo, para un contrato de interfaz ERC165 con una sola función:
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);
}
El identificador de interfaz para esta interfaz es 0x01ffc9a7. Puede calcularlo ejecutando bytes4 ((keccak256 ((
supportsInterface ((bytes4) )); o utilizando el contrato Selector anterior.
Si se calcula directamente la firma de una función, se obtienen los primeros 4 bytes.interfaceId。
function main() {
var ret = Encode("keccak256", "string", "hex", "supportsInterface(bytes4)")
Log("supportsInterface(bytes4) interfaceId:", "0x" + ret.slice(0, 8))
}
En la herramienta de depuración se pueden ejecutar pruebas:
2023-06-13 14:53:35 信息 supportsInterface(bytes4) interfaceId: 0x01ffc9a7
Se puede ver el resultado calculado yEstándar ERC165La descripción de los documentos coincide.
Se trata de la siguiente:
A continuación, vamos a ver las definiciones de interfaces de la 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);
}
Si queremos saber si un contrato inteligente es un contrato ERC721, primero tenemos que saber cuál es el contrato ERC721.interfaceIdY luego puedes intentar usarlo.supportsInterface(bytes4 interfaceId)El método, en las clases anteriores ya nos hemos familiarizado con algunos de los conceptos y cálculos del estándar ERC165.interfaceIdEl algoritmo, que escribimos directamente en el código, calcula:
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 "错误：数组中元素个数为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 "错误：TypeArray view长度不同"
}
for (var index = 0; index < ret.length; index++) {
ret[index] ^= viewData[index]
}
}
}
ret = Encode("raw", "raw", "hex", ret.buffer)
}
} else {
throw "错误：参数需要数组类型。"
}
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)
}
Usado en el códigoEncode()Función para calcular la firma de la funciónkeccak256Para el cálculo del ejemplo de código anterior, especifiqueEncode()El parámetro de salida de la función es"raw"La función regresaJavaScriptEl lenguajeArrayBuffer¿Qué tipo de persona eres?
Si se trata de dos.ArrayBufferObjeto realizado^(o) operaciones, que se deben basar enArrayBufferCreación de objetosTypedArrayLa vista, y luego recorrer los datos en ella, para hacer una diferenciación o cálculo uno por uno.
La herramienta de depuración funciona en:
2023-06-13 15:04:09 信息 0x80ac58cd
Se puede ver el resultado del cálculo yEIP-721El resultado de la búsqueda de la identidad de los ciudadanos.
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);
...
Con el ID de interfaz de ERC721, podemos juzgar si un contrato es o no un contrato de la norma ERC721.BAYCPara hacer la prueba, este es un contrato que sigue ERC721, primero necesitamos registrar ABI, y como solo llamamos a los tres métodos siguientes, solo podemos registrar estos tres métodos:
- soporta Interfaz ((ID de interfaz)
- el símbolo (())
- nombre ())
Los códigos específicos son los siguientes:
function main() {
// ERC721的合约地址，这里用的BAYC
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接口Id，在之前的课程中计算得出
var interfaceId = "0x80ac58cd"
// 注册ABI
exchange.IO("abi", testContractAddress, testABI)
// 调用supportsInterface方法
var isErc721 = exchange.IO("api", testContractAddress, "supportsInterface", interfaceId)
// 输出信息
Log("合约地址：", testContractAddress)
Log("合约名称：", exchange.IO("api", testContractAddress, "name"))
Log("合约代号：", exchange.IO("api", testContractAddress, "symbol"))
Log("合约是否为ERC721标准：", isErc721)
}
En la herramienta de depuración se pueden ejecutar pruebas:
2023-06-13 16:32:57 信息 合约是否为ERC721标准： true
2023-06-13 16:32:57 信息 合约代号： BAYC
2023-06-13 16:32:57 信息 合约名称： BoredApeYachtClub
2023-06-13 16:32:57 信息 合约地址： 0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d
Determinación de la dirección0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13dEl contrato es el estándar ERC721.
En este artículo, hemos presentado cómo evaluar un contrato ERC721, si un contrato ERC20 que no es compatible con el estándar ERC165 se identifica de otra manera. ¿Sabes cómo verificar si un contrato es compatible con el estándar ERC20?
Codificación de datos de llamadas
¿Qué es esto?calldata¿Cómo entiende el autor que la descripción más simple y popular es:
"Calldata" es el código de una llamada a una función o parámetro en Ethereum, "calldata" está codificado según la especificación ABI (Application Binary Interface) del contrato.
Por ejemplo, podemos usar el contrato ERC20 que hemos aprendido en el curso anterior.balanceOf、transferEl método de llamada, junto con los parámetros de llamada, se codifican como uncalldataEn algunos escenarios de aplicación:Interacción entre contratosEn este caso, la situación es muy complicada.calldataPor supuesto, hay muchos otros escenarios de aplicación y aquí los enumeramos.
¿Cómo codificar una llamada a una función de contrato inteligente para obtenercalldata？
La plataforma de intercambio cuantificado de los inventores puede ser utilizadaexchange.IO("encode", ...)El código para las llamadas a las funciones de contratos inteligentes es muy simple de usar.exchange.IO("encode", ...)El primer parámetro de la función es una cadena fija."encode"; el segundo parámetro es la dirección del contrato inteligente; el tercer parámetro es el nombre del método del contrato inteligente a codificar; el resto de parámetros se transmiten al valor de parámetros específicos del método del contrato inteligente a codificar.
Transmisión de código
Cuando codificamos una llamada a un método de contrato inteligente y generamos el correspondientecalldataCuando se trata de datos, si este método de contrato inteligente es un método de escritura (es decir, escribir operaciones), necesitamos generar una serie de métodos de escritura.calldataDatos como campos de datos para transacciones y luego usar el método RPC de Ethereumeth_sendRawTransactionEnviar una solicitud de datos primarios que contienen la transacción a la red Ethereum.
eth_sendRawTransactionEl método tiene sólo un parámetro.data：
datos: La transacción firmada (normalmente firmada con una biblioteca, utilizando su clave privada)
Esto esdataUn parámetro es un dato de transacción calculado después de la firma. La estructura de datos de transacción de Ethereum tiene principalmente los siguientes campos:
{
"nonce": "0x1", // 交易发送方的账户交易次数
"gasPrice": "0x12a05f200", // 交易的Gas价格
"gasLimit": "0x5208", // 交易的Gas限制
"to": "0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2", // 目标合约地址或接收方地址
"value": "0x4563918244F40000", // 转账的以太币数量
"data": "0x0123456789ABCDEF", // 要发送给合约的数据
}
¿Cómo firmar una transacción de Ethereum?
En el inventor de la plataforma de intercambio cuantitativo que usamosEncode()Una función para calcular firmas, un ejemplo concreto que escribimos en el siguiente curso "Executar el método de escritura calldata".
Ejecutar el método de lectura calldata
Para el método ReadcalldataEn la actualidad, la mayoría de las aplicaciones de RPC se ejecutan utilizando métodos de RPC que hemos aprendido anteriormente:eth_callPara ejecutarlo, lo explicamos antes.eth_callEste método de RPC de Ethereum sólo hace contratos inteligentes.WriteUna demostración del método que se utiliza en este capítulocalldataEn este caso, el método de WETH se utiliza para hacer una demostración de cómo se puede ejecutar un llamado al método Read de un contrato inteligente.balanceOfMétodo para leer el saldo de los tokens WETH en la billetera actual.
En la web de Ethereum, utilizamos herramientas de depuración para probar:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function main() {
// WETH合约的ABI
var abiWETH = `[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"dst","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Withdrawal","type":"event"}]`
// WETH合约地址
var wethAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
// 注册WETH合约的ABI
exchange.IO("abi", wethAddress, abiWETH)
// 当前配置的交易所对象的钱包地址
var walletAddress = exchange.IO("address")
// 编码WETH合约的deposit方法调用
var calldataForDeposit = exchange.IO("encode", wethAddress, "balanceOf(address)", walletAddress)
Log("calldataForDeposit:", "0x" + calldataForDeposit)
// 构造transaction，作为eth_call的第一个参数
var transaction = {
"from" : walletAddress,
"to" : wethAddress,
"data" : "0x" + calldataForDeposit,
}
// eth_call的第二个参数
var blockNumber = "latest"
// 使用eth_call调用
var ret = exchange.IO("api", "eth", "eth_call", transaction, blockNumber)
var wethBalance = exchange.IO("decode", "uint256", ret) // 可以使用exchange.IO("decode", ...) 函数解码
Log("wethBalance:", toAmount(wethBalance, 18)) // 从以wei为单位，换算成WETH个数为单位
}
La herramienta de depuración funciona en:
2023-06-15 11:51:31 信息 wethBalance: 0.015
2023-06-15 11:51:31 信息 calldataForDeposit: 0x70a082310000000000000000000000006b3f11d807809b0b1e5e3243df04a280d9f94bf4
Si el método de un contrato inteligente tiene un valor de retorno, se puede usar.exchange.IO("decode", ...)Descifrar funciones.calldataEn la actualidad, la mayoría de los contratos inteligentes están diseñados para ser usados por empresas de todo el mundo.balanceOfEl método es el mismo, tengo un saldo de WETH de 0.015 WETH en mi bolso de prueba.
Ejecutar el método de escritura calldata
Para ejecutar calldata del método Write, se requiere usar el método RPC:eth_sendRawTransaction¿Qué es esto?
En la web de Ethereum, utilizamos herramientas de depuración para probar:
function toAmount(s, decimals) {
return Number((BigDecimal(BigInt(s)) / BigDecimal(Math.pow(10, decimals))).toString())
}
function toInnerAmount(s, decimals) {
return (BigDecimal(s)*BigDecimal(Math.pow(10, decimals))).toFixed(0)
}
function main() {
// WETH合约的ABI
var abiWETH = `[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"guy","type":"address"},{"name":"wad","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"src","type":"address"},{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"wad","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"dst","type":"address"},{"name":"wad","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deposit","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed":true,"name":"guy","type":"address"},{"indexed":false,"name":"wad","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"src","type":"address"},{"indexed- Explore las nuevas funciones del editor de estrategias FMZ: Cómo ChatGPT mejora significativamente su productividad cuantitativa
- Descubra las nuevas características del editor de estrategias de FMZ: cómo ChatGPT mejora significativamente su productividad cuantitativa
- Estrategia de alta frecuencia de la moneda digital Introducción detallada
- Introducción a las estrategias detalladas de negociación de alta frecuencia para las criptomonedas