Introduction facile au développement web3 basé sur Ethereum avec FMZ
Auteur:L'inventeur de la quantification - un petit rêve, Créé: 2023-03-28 13:32:48, Mis à jour: 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 écoute = nul
fonction principale
• événement =
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)
}
}
/* Tout: test Var arrLog = [] fonction onexit (()) { Log (ouvre la fenêtre pour terminer l'exécution, vérifiez le journal) var firstBlockNumber = écoutant.firstBlockNumber var endBlockNumber = listener.latestBlockNumber est le dernier numéro de bloc
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)
}
}
Le code ci-dessus fonctionne sur le disque:
Dans ce cours, nous avons expliqué comment concevoir un filtre d'événement et comment l'utiliser pour écouter les messages liés aux portefeuilles chauds de l'échange.USDTVous pouvez modifier ou étendre ce programme de paradigme pour écouter n'importe quel événement qui vous intéresse.smart moneyJe ne sais pas quelles nouvelles transactions ont été faites.NFTLe projet de construction du barrage a été abandonné et le projet a été abandonné.
Unité de conversion
Le nombre de calculs liés à l'Ethereum est supérieur au nombre de calculs liés à l'EthereumJavaScriptLes nombres entiers les plus sûrs du langage. Nous avons donc besoin de méthodes pour traiter les nombres importants sur les plateformes de négociation quantitative des inventeurs, méthodes que nous avons utilisées spécifiquement dans les cours précédents et qui ne sont pas expliquées en détail.
L'impressionJavaScriptLe nombre d'entiers de sécurité maximum défini dans la langue:
function main() {
Log("Number.MAX_SAFE_INTEGER:", Number.MAX_SAFE_INTEGER)
}
Les résultats:
Numéro.MAX_SAFE_INTEGER: 9007199254740991
Je veux dire, BigInt.
La plus petite unité définie dans Ethereum est1wei, définition1Gweiest égal à1000000000 wei。1GweiDans les calculs liés à l'Ethereum, ce n'est pas vraiment un grand nombre, certaines données sont beaucoup plus grandes que cela.Number.MAX_SAFE_INTEGER: 9007199254740991。
Les inventeurs de plates-formes d'échange quantitatives utilisent des plateformes qui sont des outils de communication.BigIntLes objets représentent ces données entières massives; ils utilisent des fonctions de construction.BigInt()Pour construireBigIntObjets. Vous pouvez construire des paramètres avec des valeurs numériques, des chaînes numériques à seize chiffres.BigIntObjets et utilisations.BigIntl'objettoString()La méthode exécute les données représentées par l'objet sous forme de chaîne.
BigIntOpérations prises en charge par les objets:
- L'opération de multiplication:
+ - Le calcul de la déduction:
- - Les multiples sont:
* - Il y a aussi des gens qui ont été tués.
/ - Les opérations de demande de moule:
% - Les chiffres:
**
Voici quelques exemples de code:
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))
}
Les tests de débogage:
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
BigFloat
BigFloatObjets etBigIntLes objets utilisés sont similaires, ils sont utilisés pour représenter des nombres à virgule flottante de plus grande valeur numérique et prennent également en charge les opérations de multiplication par addition et diminution.BigFloatPrise en charge des objetstoFixed()Comment faire?
Voici quelques exemples de code:
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))
}
Les tests de débogage:
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
Le BigDecimal
BigDecimalLes objets sont compatibles avec les entiers, les nombres à virgule flottante, et prennent en charge l'utilisationBigIntLes objets.BigFloatL'initialisation d'objets, qui prend également en charge les opérations d'addition, de diminution et de multiplication.
Voici quelques exemples de code:
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())
}
Les outils de débogage fonctionnent:
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
Unité de conversion
Les deux fonctions suivantes:toAmount()、toInnerAmount()Nous avons utilisé ces deux fonctions plusieurs fois dans des cours précédents, principalement pour la conversion de données de précision.
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()La fonction est une variable.sLes paramètres de précisiondecimalsPour effectuer des conversions. Dans le développement réel du web3, il est souvent nécessaire de traiter des données à 16 chiffres sur certaines chaînes.
C'est un problème que nous avons souvent rencontré dans nos cours précédents, comme les contrats intelligents.Transfer(address,address,uint256)Dans l'incidentdataLes données du champ:
{
"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000",
"topics": ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", "0x0000000000000000000000006b75d8af000000e20b7a7ddf000ba900b4009a80", "0x000000000000000000000000bcb095c1f9c3dc02e834976706c87dee5d0f1fb6"],
"transactionHash": "0x27f9bf5abe3148169b4b85a83e1de32bd50eb81ecc52e5af006157d93353e4c4",
"transactionIndex": "0x0",
"removed": false,
"address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
"blockHash": "0x847be24a7b159c292bda030a011dfec89487b70e71eed486969b032d6ef04bad",
"blockNumber": "0x109b1cc",
"logIndex": "0x0"
}
Traitement des données"data": "0x00000000000000000000000000000000000000000000000001c1a55000000000"Nous avons besoin d'aide.toAmount()Les fonctions. Une telle conception peut être très utile.dataLes données des champs sont converties en valeurs lisibles.
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 jeton d'ETH, nous savons que c'est1e18 weiSi nous obtenons unweiDonnées par unité126564027559051260Comment convertir le nombre de jetons en ETH?
UtilisationtoAmount(, 18)Les fonctions peuvent être converties très facilement.toInnerAmount()La fonction esttoAmount()L'opération inverse de la fonction (en fonction de la précision, de l'amplification) permet de convertir les données facilement à l'aide de ces deux fonctions.
Il est important de noter que la gamme de sécurité des entiers numériques dans le langage JavaScript est la suivante:Number.MAX_SAFE_INTEGERL'exemple suivant illustre un problème qui est plus caché lors de la conversion de données:
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))
}
Il peut être utilisé dans les outils de débogage suivants:
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
Nous avons observé et découvert:
Log("转换", innerAmount, "为十六进制：", innerAmount.toString(16))
La ligne de code correspondant à la sortie du journal est:转换 10000000000000000 为十六进制： 10000000000000000La raison naturelle en est que 100000000000000000000 est au-delà de 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000Number.MAX_SAFE_INTEGER。
Mais quand un nombre décimal est dans la plage de sécurité, c'est-à-dire inférieur àNumber.MAX_SAFE_INTEGERJe ne sais pas.toString(16)La conversion des fonctions est normale, par exemple:
function main() {
var value = 1000
Log("把value转换为十六进制：", "0x" + value.toString(16)) // 0x3e8
Log("把0x3e8转换为十进制：", Number("0x3e8")) // 1000
}
Dans le domaine de la blockchain, même0.01L'ETH est échangé contreweiUnité numérique10000000000000000Il va même au-delà.Number.MAX_SAFE_INTEGERLe plus sûr pour ce type de situation est donc:BigInt(10000000000000000).toString(16)。
Appels simulés
Il existe de nombreuses façons d'exécuter des transactions et d'appeler des contrats intelligents sur EthereumWriteLes méthodes nécessitent une certaine consommation de gaz et sont parfois à risque d'échec. Il est très important de savoir quelles transactions sont susceptibles d'échouer avant d'envoyer des transactions ou des appels. Il existe des méthodes d'appels analogiques sur Ethereum pour les tests.
et_call
Les méthodes de RPC pour Ethereumeth_callLes transactions peuvent être simulées et renvoyer des résultats possibles, mais ne sont pas réellement exécutées sur la blockchain.
eth_callLa méthode a deux paramètres, le premier paramètre est une structure de dictionnaire, et le deuxième paramètre est une structure de dictionnaire.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
}
Le deuxième paramètre est:blockNumberLes étiquettes peuvent être envoyéeslatest/pending/earliestIl y a aussi:
/* 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
*/
Nous allons utiliser des jetons.DAILes contrats intelligentsapprove、transferL'exemple de l'appel d'analogie est l'environnement de test suivant pour l'Ethereum.
Approuver les appels analogiques
Pour les contrats ERC20approveLa méthode nous est déjà familière, et nous l'avons pratiquée dans des cours précédents. Puisque les contrats ERC20 sont intégrés à l'ABI de la plateforme FMZ, il n'est pas nécessaire d'enregistrer l'ABI que vous souhaitez simuler.
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)
}
Le code dans l'exemple va commencer parapprove(address,uint256)Les méthodes, les paramètres sont codés.approveLa valeur des paramètres de la méthode0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffIndique le nombre maximal d'autorisations.0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45Je veux dire,Uniswap V3Le contrat de routage.eth_callLa simulation est faite.transactionObjectDans les paramètresgasPrice、gasLes champs peuvent être omis.
Les outils de débogage sont en cours d'exécution, l'autorisation de la méthode approuver de l'appel simulé a été réussie (et n'est pas réellement autorisée):
2023-06-09 11:58:39 信息 ret: 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 11:58:39 信息 ERC20 token DAI approve encode, data: 095ea7b300000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
Nous pouvons aussi simuler des scénarios de défaillance lorsque nous ajustons les données.gasPriceetgasLes paramètres donnent une erreur si l'ETH dans le portefeuille n'est pas suffisant pour payer le gaz:
insuffisance des fonds
Le prix de l'essence est trop bas, et il y a des erreurs:
gaz intrinsèque trop faible: avoir 21000, vouloir 21944 (gaz fourni 21000)
Appel analogue au transfert
Pour ERC20,transferLa méthode que nous ne connaissons pas est celle qui permet de transférer des jetons ERC20 vers une adresse de portefeuille, et nous avons essayé de simuler le transfert de 1000 DAI vers 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
}
Comme mon portefeuille de test n'a pas de jeton DAI, les résultats attendus lors de l'exécution de l'outil de débogage sont erronés:
l'exécution est inversée: Dai/solde insuffisant
Voir l'adresse de ce portefeuille de V:0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045Il est donc possible que ce portefeuille soit doté de jetons DAI.
J'ai modifié le code et j'ai écrit une note à la place:
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)
}
Les tests de débogage:
2023-06-09 13:34:31 信息 0x0000000000000000000000000000000000000000000000000000000000000001
2023-06-09 13:34:31 信息 转账金额： 1000 DAI, 使用 toInnerAmount 转换为： 1000000000000000000000
L'utilisation d'une plate-forme de négociation quantifiée par l'inventeur permet de simuler facilement les résultats des transactions et d'éviter que l'envoi d'une transaction qui pourrait échouer entraîne une perte inutile de coûts de gaz. Nous avons utilisé le code d'exemple dans le cours de ce chapitre pour simuler un virement vers le portefeuille de V, un appel vers le virement vers nous.eth_callIl y a d'autres méthodes qui sont utiles.eth_callOù est-ce que cette méthode est utilisée?
Identifier les contrats ERC721
Nous savons que les jetons comme ETH et BTC sont des jetons homogènes, et que le jeton que vous avez en main n'est pas différent du jeton que j'ai en main. Mais il y a beaucoup de choses dans le monde qui sont de qualité différente, par exemple: l'immobilier, les antiquités, les objets d'art virtuels, etc., qui ne peuvent pas être représentés abstraitement avec des jetons homogènes. Alors, parmi les nombreux contrats intelligents déployés sur Ethereum, comment pouvons-nous identifier quels sont les contrats intelligents de la norme ERC721?
Pour identifier l'ERC721, vous devez d'abord comprendre la norme ERC165.
Résultats de l'enquête
Grâce à la norme ERC165, les contrats intelligents peuvent déclarer les interfaces qu'ils supportent pour vérifier les autres contrats.supportsInterface(bytes4 interfaceId)ParamètresinterfaceIdL'ID de l'interface à interroger. Si le contrat implémente l'ID de l'interface, il renvoie une valeur de Boole vraie, sinon une valeur fausse.
Nous allons parler de cela ci-dessous.interfaceIdIl y a aussi une autre façon de calculer et de coder.
Norme ERC165Voici un exemple:
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;
}
}
Pour les signatures de fonctions d'interfaces (composées d'une liste de noms de fonctions et de types de paramètres), une différence est effectuée ou calculée, pour les contrats d'interfaces ERC165 avec une seule fonction:
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);
}
L'identifiant d'interface pour cette interface est 0x01ffc9a7. Vous pouvez le calculer en exécutant bytes4 ((keccak256 ((
supportsInterface ((bytes4) )); ou en utilisant le contrat Sélecteur ci-dessus.
Si vous comptez directement la signature d'une fonction, en prenant ses 4 premiers octets, vous obtenezinterfaceId。
function main() {
var ret = Encode("keccak256", "string", "hex", "supportsInterface(bytes4)")
Log("supportsInterface(bytes4) interfaceId:", "0x" + ret.slice(0, 8))
}
Les tests peuvent être effectués dans les outils de débogage:
2023-06-13 14:53:35 信息 supportsInterface(bytes4) interfaceId: 0x01ffc9a7
Vous pouvez voir les résultats calculés etNorme ERC165La description est cohérente dans la documentation.
Résultats de l'enquête
La définition de l'interface de la norme ERC721 est la suivante:
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 nous voulons déterminer si un contrat intelligent est un contrat ERC721, nous devons d'abord savoir ce que le contrat ERC721 signifie.interfaceIdJe vais essayer de les utiliser.supportsInterface(bytes4 interfaceId)La méthodologie, les cours précédents nous ont familiarisé avec certains concepts et calculs de la norme ERC165interfaceIdL'algorithme que nous écrivons directement dans le code est calculé:
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)
}
Utilisé dans le codeEncode()Fonction pour le calcul de la signature de la fonctionkeccak256Pour les calculs dans l'exemple ci-dessus, spécifiezEncode()Le paramètre de sortie de la fonction est"raw"Cette fonction renvoieJavaScriptLe langageArrayBufferJe suis un homme de parole.
Si vous voulez faire deuxArrayBufferObjet effectué^L'opération doit être basée surArrayBufferCréation d'objetsTypedArrayLes données sont ensuite parcourues et calculées une par une.
Les outils de débogage fonctionnent:
2023-06-13 15:04:09 信息 0x80ac58cd
Vous pouvez voir les résultats etEIP-721Les résultats de cette enquête ont été publiés dans le journal The New York Times.
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);
...
Avec l'ID d'interface ERC721, nous pouvons déterminer si un contrat est conforme à la norme ERC721.BAYCPour faire le test, c'est un contrat qui suit ERC721, et nous devons d'abord enregistrer ABI, et comme nous n'appelons que trois méthodes, nous ne pouvons enregistrer que ces trois méthodes:
- Prise en charge de l'interface (ID de l'interface)
- le symbole
- Nom (s)
Le code spécifique est le suivant:
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)
}
Les tests peuvent être effectués dans les outils de débogage:
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
Déterminez l'adresse0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13dLe contrat est basé sur la norme ERC721.
Dans cette discussion, nous avons expliqué comment juger un contrat ERC721, alors un contrat ERC20 qui ne supporte pas la norme ERC165 doit être identifié par une autre méthode.
Coder les données d'appel
C'est quoi?calldataDans le cas de l'auteur, la description simple et courante est la suivante:
"Calldata" est l'encodage d'appels ou de paramètres d'une fonction dans Ethereum, "calldata" est codé selon les spécifications de l'API (Application Binary Interface) du contrat.
Par exemple, nous pouvons utiliser les contrats ERC20 que nous avons appris dans les cours précédents.balanceOf、transferL'appel de méthode, ainsi que les paramètres à appeler, sont codés comme uncalldataDans certains scénarios d'application, par exemple:Interaction entre les contratsIl y a des gens qui ne sont pas d'accord avec ça.calldataBien sûr, il y a beaucoup d'autres scénarios d'utilisation, et je vais les énumérer ici.
Comment coder un appel à une fonction de contrat intelligent pour obtenircalldata？
La plateforme d'échange quantitative peut être utilisée par les inventeursexchange.IO("encode", ...)Le code pour les appels aux fonctions de contrats intelligents est très simple à utiliser.exchange.IO("encode", ...)Le premier paramètre de la fonction est une chaîne fixe."encode"; le deuxième paramètre est l'adresse du contrat intelligent; le troisième paramètre est le nom de la méthode de contrat intelligent à coder; le reste des paramètres est transmis à la valeur spécifique de la méthode de contrat intelligent à coder.
Transfert de fichier
Lorsque nous avons codé un appel à une méthode de contrat intelligent et généré le correspondantcalldataDans les données, si cette méthode de contrat intelligent est une méthode de écriture (c'est-à-dire: écrire des opérations), nous avons besoin de générercalldataLes données en tant que champs de données pour la transaction, puis utiliser la méthode RPC d'Ethereumeth_sendRawTransactionEnvoyer une demande de données brutes contenant cette transaction au réseau Ethereum.
eth_sendRawTransactionIl n'y a qu'un seul paramètre de la méthode.data：
données: la transaction signée (généralement signée avec une bibliothèque, en utilisant votre clé privée)
Celle-ci estdataLes paramètres sont les données de transaction calculées après la signature. La structure de données de transaction d'Ethereum se compose principalement des champs suivants:
{
"nonce": "0x1", // 交易发送方的账户交易次数
"gasPrice": "0x12a05f200", // 交易的Gas价格
"gasLimit": "0x5208", // 交易的Gas限制
"to": "0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2", // 目标合约地址或接收方地址
"value": "0x4563918244F40000", // 转账的以太币数量
"data": "0x0123456789ABCDEF", // 要发送给合约的数据
}
Comment signer une transaction sur Ethereum?
Nous utilisons une plateforme de trading quantifié par les inventeursEncode()Les fonctions utilisées pour calculer la signature, comme nous l'avons écrit dans le cours suivant "Exécuter une méthode d'écriture pour appeler les données".
Exécuter la méthode de lecture appeldata
Pour la méthode ReadcalldataNous avons appris à utiliser les méthodes RPC précédemment utilisées:eth_callNous avons déjà parlé de cela.eth_callCette approche RPC d'Ethereum ne fait que des contrats intelligents.WriteUne démonstration des méthodes utilisées dans ce chapitrecalldataNous allons utiliser le contrat WETH pour décrire la façon dont les contrats intelligents peuvent être utilisés pour exécuter des appels.balanceOfComment lire le solde des jetons WETH dans le portefeuille actuel.
Nous avons utilisé des outils de débogage pour tester sur Ethereum:
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个数为单位
}
Les outils de débogage fonctionnent:
2023-06-15 11:51:31 信息 wethBalance: 0.015
2023-06-15 11:51:31 信息 calldataForDeposit: 0x70a082310000000000000000000000006b3f11d807809b0b1e5e3243df04a280d9f94bf4
Si les méthodes de contrats intelligents ont une valeur de retour, elles peuvent être utilisées.exchange.IO("decode", ...)Décodage des fonctions.calldataIl y a une différence entre les méthodes utilisées pour créer des contrats intelligents et les méthodes utilisées pour les appeler directement.balanceOfLa méthode est la même, j'ai obtenu un solde de WETH de 0.015 WETH sur mon portefeuille de test.
Exécuter la méthode de rédaction calldata
Pour exécuter les calldata de la méthode Write, vous devez utiliser la méthode RPC:eth_sendRawTransactionJe suis désolé.
Nous avons utilisé des outils de débogage pour tester sur Ethereum:
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- Découvrez les nouvelles fonctions de l'éditeur de stratégie FMZ: comment ChatGPT améliore considérablement votre productivité quantitative
- Découvrez les nouvelles fonctionnalités de l'éditeur de stratégie FMZ: comment le ChatGPT améliore considérablement votre productivité quantitative
- Stratégie de haute fréquence de la monnaie numérique Introduction détaillée
- Introduction aux stratégies détaillées de négociation à haute fréquence pour les crypto-monnaies