存款代码

"""
pip install web3==5.29.1
"""
import web3
import math
import time
import requests

headers = {
    'content-type': 'application/json',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, api='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.api = api
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_current_block(self):
        """获取最新区块"""
        data = {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_block_detail(self, number):
        """获取区块hash"""
        if isinstance(number, int):
            number = hex(number)
        data = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[number,True],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gasprice"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_max_gas_price(self):
        """(base*2 + Priority) * gasLimit"""
        res = self.get_fee_history()
        base = int(res['result']['baseFeePerGas'][-1], 16)
        res = self.get_max_PriorityFeePerGas()
        priority = int(res['result'], 16)
        return base * 2 + priority

    def get_fee_history(self):
        """获取历史gasfee"""
        data = {"jsonrpc":"2.0","method":"eth_feeHistory","params":["0x1", "latest", []],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_max_PriorityFeePerGas(self):
        """获取Priority"""
        data = {"jsonrpc":"2.0","method":"eth_maxPriorityFeePerGas","params":[],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_limit(self, from_, to, data):
        """call计算gaslimit"""
        data = {"jsonrpc":"2.0","method":"eth_estimateGas","params":[{"from": from_, "to": to, "data": data}],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def call(self, to, data):
        data = {"jsonrpc":"2.0","method":"eth_call","params":[{"to": to, "data": data}, "latest"],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.api, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()#(int(res.json()['result'], 16)) / math.pow(10,18)

    def transfer(self, account, to, amount, gaslimit, **kw):
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
    def transfer_eip1559(self, account, to, amount, gaslimit=21000, priority_fee=None, max_gas_fee=None, **kw):
        """eip 1559发送tx, 更节省gas"""
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        if not priority_fee:
            priority_fee = self.get_max_PriorityFeePerGas()['result']
        priority_fee = int(priority_fee, 16) if not isinstance(priority_fee, int) else priority_fee
        if not max_gas_fee:
            basefee = int(self.get_fee_history()['result']['baseFeePerGas'][-1], 16)
            max_gas_fee = 2 * basefee + priority_fee
        max_gas_fee = int(max_gas_fee, 16) if not isinstance(max_gas_fee, int) else max_gas_fee
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'maxPriorityFeePerGas': priority_fee, 'maxFeePerGas': max_gas_fee, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())

if __name__ == '__main__':
    privkey = 'xxxxxx' # 这里替换成自己的私钥
    account = web3.Account.from_key(privkey)
    COIN_DECIMALS = math.pow(10, 18) # 主币精度
    rpc = Rpc()
    value = 0.01 # 要存款的数量
    method = '0xdeace8f5' # 存款方法hash值
    uint_0 = '000000000000000000000000000000000000000000000000000000000000e704' # chainid
    addr_1 = account.address[2:].rjust(64, '0') # recipient
    amount = int(value * COIN_DECIMALS)
    uint_2 = hex(amount)[2:].rjust(64, '0') # amount
    uint_3 = '0000000000000000000000000000000000000000000000000000000000000000' # amountOutMin
    time_4 = hex(int(time.time() + 7 * 86400))[2:].rjust(64, '0') # deadline
    addr_5 = '00000000000000000000000081682250d4566b2986a2b33e23e7c52d401b7ab7' # relayer
    uint_6 = '0000000000000000000000000000000000000000000000000000000000000000' # relayerFee
    data = method + uint_0 + addr_1 +uint_2 + uint_3 + time_4 + addr_5 + uint_6
    amount += (0.01 * COIN_DECIMALS)
    data = data.lower()
    gaslimit = 130000
    to = '0xe85b69930fc6d59da385c7cc9e8ff03f8f0469ba' # linea存款的合约地址
    to = web3.Web3.toChecksumAddress(to)
    res = rpc.transfer_eip1559(account, to, amount, gaslimit, data=data)
    print(res)

存款成功

代码已上传

simple-airdrop-demo/linea at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

2层上Uniswap的交互可以参考 Scroll 的代码， 改下rpc地址就行

往期代码交互教程

• arb-claim教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

import web3
import requests

headers = {
    'content-type': 'application/json',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, api='https://arb1.arbitrum.io/rpc', chainid=42161, proxies=None, timeout=30):
        self.api = api
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_current_block(self):
        """获取最新区块"""
        data = {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_block_detail(self, number):
        """获取区块hash"""
        if isinstance(number, int):
            number = hex(number)
        data = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[number,True],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gasprice"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_limit(self, to, data):
        """call计算gas"""
        data = {"jsonrpc":"2.0","method":"eth_estimateGas","params":[{"to": to, "data": data}],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def call(self, to, data):
        data = {"jsonrpc":"2.0","method":"eth_call","params":[{"to": to, "data": data}, "latest"],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.api, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.api, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()#(int(res.json()['result'], 16)) / math.pow(10,18)

    def transfer(self, account, to, amount, gaslimit, **kw):
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())

def claim(privkey):
    # 领取
    rpc = Rpc()
    # https://arbiscan.io/address/0x67a24CE4321aB3aF51c2D0a4801c3E111D88C9d9
    token = '0x67a24CE4321aB3aF51c2D0a4801c3E111D88C9d9' # 领取合约地址
    data = '0x4e71d92d'
    account = web3.Account.from_key(privkey)
    to = web3.Web3.toChecksumAddress(token)
    res = rpc.transfer(account, to, 0, gaslimit=455210, data=data)
    return res

def collection(privkey, address):
    # 归集
    # https://arbiscan.io/token/0x912ce59144191c1204e64559fe8253a0e49e6548#balances
    rpc = Rpc()
    account = web3.Account.from_key(privkey)
    token = '0x912ce59144191c1204e64559fe8253a0e49e6548' # arb 代币地址
    # 1.查询地址余额
    call_data = '0x70a08231' + '000000000000000000000000' + account.address[2:]
    res = rpc.call(token, call_data)
    value = res['result']
    # 2.转账
    addr_1 = address.lower()[2:].rjust(64,'0')
    unit_2 = value[2:].rjust(64,'0')
    data = '0xa9059cbb' + addr_1 + unit_2
    to = web3.Web3.toChecksumAddress(token)
    res = rpc.transfer(account, to, 0, gaslimit=455210, data=data)
    return res

if __name__ == '__main__':
    pk = 'xxxxxxx' # 你的私钥
    # 领取
    res = claim(pk)
    print(res)
    # 归集
    address = '' # 你的交易所钱包Arb地址
    res = collection(pk, address)
    print(res)

代码已上传

simple-airdrop-demo/arb-claim at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

原理分析教程

• lifeform 的 free mint 代码交互排查思路

• 如何通过 rpc协议来交互 Base的存款

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/etJQ20zi8b3pK1m0GfvnH8cnxoc9ErVhGKLk3YtKTIg

给大家分享下交互源码，注意代码中的参数

• 设置自己的私钥

• 设置邀请人的地址 +500分这个

代码已上传

simple-airdrop-demo/life at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

原理分析教程

• lifeform 的 free mint 代码交互排查思路

• 如何通过 rpc协议来交互 Base的存款

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

给大家分享下之前很火的 lifeform 的 free mint 代码交互思路，如何签名，如何找到数据，如何排查的；现在还能 mint 的

抓包分析

请跟我一样，浏览器打开 mint 网址后，打开你的F12，简单的抓个包；看我的设置，去除杂七杂八的请求

钱包签名

我们先用小狐狸跑一遍流程，连接钱包，提示签名。复制下签名信息，注意签名信息的内容，长这样的 'address=你的钱包地址,chain_id=56' 这里你要学会用 web3库 Account 来签名消息

import web3
from eth_account.messages import encode_defunct

privkey='xxxx' # 你的私钥
account = web3.Account.from_key(privkey)
msg = 'address=%s,chain_id=56' % account.address
signature = account.sign_message(encode_defunct(text=msg)).hex()

查找登陆接口

拿到签名的数据后，我们需要找到请求的登陆接口，大致长这样。注意你的标头信息看到 请求网址 和 请求方法，并且打开旁边的载荷，载荷就是要传输的数据，有3个字段 address: 你的钱包地址 chain_id: bsc chainid sign: 刚才你用 web3 Account签名的消息

获取 access_token

通过预览，我们看到了请求返回的数据，我们就是需要返回的 access_token，这个数据需要加到后续请求的header里

header 添加 authorization = access_token

页面点击 mint 我们可以看看发生了哪些请求，找不一致，发现这个接口。看到接口里的header authorization 字段的值就是刚才通过登录接口拿到的access_token

查看再次签名的字段

再次查看载荷，发现有3个字段 address: 你的钱包地址 affAddress: 邀请地址 它+500分 gender: female 固定参数

查看签名后返回的数据并与tx hash InputData对比

再次查看预览，看到了这些数据，不着急，数据字段有点多，先把数据复制好。小狐狸确认 mint ，广播 tx 后，拿到 tx 的inputdata，我们再来对比，确认需要的参数

通过对比，我们发现之前的接口里的

signCode = InputData [10]

wlSignature = InputData [13] [14]

dataSignature.signature = InputData [17] [18]

这样我们就拿到了 free mint 所需要的参数，InputData 其他的字段数据大家可自行分析下，通过与其 他 tx 对比；拼接成完整的数据后，再通过合约交互，就能实现代码的成功 mint 了；

总结

• 熟练钱包签名

• 善用抓包工具

• 细心排查数据

原理分析教程

• 如何通过 rpc协议来交互 Base的存款

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

import requests
import web3
import math
headers = {
    'content-type': 'application/json',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_current_block(self):
        """获取最新区块"""
        data = {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_block_detail(self, number):
        """获取区块hash"""
        if isinstance(number, int):
            number = hex(number)
        data = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[number,True],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_limit(self, to, data):
        """计算gas"""
        data = {"jsonrpc":"2.0","method":"eth_estimateGas","params":[{"to": to, "data": data}],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def call(self, to, data):
        data = {"jsonrpc":"2.0","method":"eth_call","params":[{"to": to, "data": data}, "latest"],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()#(int(res.json()['result'], 16)) / math.pow(10,18)

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())

if __name__ == '__main__':
    privkey = 'xxxxxxx' # 这里替换成自己的私钥
    account = web3.Account.from_key(privkey)
    rpc = Rpc()
    value = 0.01 # 要存款的数量
    gaslimit = 600000 # gaslimit
    token = '0x1908e2bf4a88f91e4ef0dc72f02b8ea36bea2319' # zksync存款的合约地址
    method = '0xeb672419' # 存款方法hash值
    addr_0 = account.address[2:].rjust(64,'0') # 地址格式处理
    amount = int(value * math.pow(10, 18)) # eth的主币精度是18位
    value = hex(amount) # value hex格式处理
    unit_1 = value[2:].rjust(64,'0')
    bytes_2 = '00000000000000000000000000000000000000000000000000000000000000e0'
    unit_3 = '0000000000000000000000000000000000000000000000000000000000989680'
    unit_4 = '0000000000000000000000000000000000000000000000000000000000000320'
    bytes_5 = '0000000000000000000000000000000000000000000000000000000000000100'
    addr_6 = addr_0
    unit_7 = '0000000000000000000000000000000000000000000000000000000000000000'
    unit_8 = '0000000000000000000000000000000000000000000000000000000000000000'
    data = method + addr_0 + unit_1 + bytes_2 + unit_3 + unit_4 + bytes_5 + addr_6 + unit_7 + unit_8  # 拼接数据
    res = rpc.transfer(account, to=token, amount=amount, gaslimit=gaslimit, data=data) # 发送交易
    print(res)

执行脚本后打印交易hash, 去浏览器查询状态

https://goerli.etherscan.io/

代码样例已上传:

https://github.com/junjie9021/simple-demo/tree/main/zksync

原理分析教程

• 如何通过 rpc协议来交互 Base的存款

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

讲真，先开始我也不知道，用小狐狸手动走了一遍流程发，马上我就写了代码模拟来测试下，去查 tx hash 发送状态有问题，Fail with error 'Insufficient msg.value' 报这个错误。我不信邪，又执行了几遍，还是这个错误。这会就要停下了，好好看下成功的交易并做对比。

通过这两个对比成功的tx hash 和代码执行失败的tx hash 那就是在 value 这个字段有区别，可以看到成功的 value 0**.01000004 和 失败的 value 0.015 它们之间存在这个值的0.**00000004的差别。

不要着急，再去看下合约地址，看看其他人的交易是不是也是这样。仔细看下图，发现没有，是不是有个相同点，目前这个key=0.0000008。那么在存款时就可以得到实际发送的

amount += key

马上再测试，发现新的tx 状态ok的，可以成功存款了。

Input Data还需要在分析下吗？还想听。好吧 分析下吧，很简单，第一参数是amount，不加key的哈。第二个是固定参数（其他成功tx都是这个参数，直接上）

课外题： 如果这个key又变了怎么办呢？有知道的吗？我批量交互不能总上浏览器看吧，看了再来改，感觉有点low。

总结

• 细心找失败tx和成功tx之间的不同

原理分析教程

• 如何通过 rpc协议来交互 Base的存款

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

首先，我们先用跨链桥手动完整的跑一下交互流程。现在我要存0.01个eth。

确认我们的存款，拿到返回的hash，打开浏览器。

交易已经打包上链，注意 这里点开Click to show more， 我们要找到Input Data字段

重要: 大家做好笔记，做好理解，我们会对data 进行解读

MethodId - 函数做KECCAK256hash计算，然后取计算结果的前四个字节，也就是hash值的前八位，然后拼接0x，就是这个方法的ID.

"""
Function: depositTransaction(address _to,uint256 _value,uint64 _gasLimit,bool _isCreation,bytes _data)

"""
import sha3

def keccak256_hash(text):
    k = sha3.keccak_256()
    k.update(text.encode('utf-8'))
    return k.hexdigest()

func = "depositTransaction(address,uint256,uint64,bool,bytes)"
print('0x' + keccak256_hash(func)[:8])

[0]: 000000000000000000000000b0a25771c5f7aa7772d9f6ea048ba80124c12d89

其实是自己的钱包地址

address = "0xa25771c5f7aa7772d9f6ea048ba80124c12d89"
print(address[2:].rjust(64, '0'))

[1]: 000000000000000000000000000000000000000000000000002386f26fc10000 存款的数量0.01 eth

import math

value = 0.01
amount = int(value * math.pow(10, 18)) # 注意 eth 主币的精度是18位
print(hex(amount)[2:].rjust(64, '0'))

[2]: 00000000000000000000000000000000000000000000000000000000000186a0 gaslimit, 在打包上链时候传入的gaslimit。一般可以通过小狐狸拿下或者看其他人的交易。或者通过 rpc method eth_estimateGas来查询(有的合约不支持)

import math

gaslimit = 100000
print(hex(gaslimit)[2:].rjust(64, '0'))

[3]: 0000000000000000000000000000000000000000000000000000000000000000 [4]: 00000000000000000000000000000000000000000000000000000000000000a0 [5]: 0000000000000000000000000000000000000000000000000000000000000000

这些可以理解为固定参数, 暂时不需要强行理解它们。

通过这6个数据分析，我们发现这个方法主要要于前3个数据的变量传入，地址 address, 数量 amount, gas gaslimit，剩下的参数都是固定值。组装好这些数据，我们就可以直接跟合约交互，要修改状态的这种交互，统一用 transfer 来交互，如果不只是查询代币余额这些不改变状态的可以用 eth_call 方法来交互。

以下为完整脚本

https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/IeEw0Qp3MYbwFZx111fi1J25Dm8JLcm6avEHv_72R-0

总结

• 用好浏览器工具，浏览器已经扫好了块，并解析好了tx

• 多测多看，看看合约相同methodId的inputdata数据，找不同点

• 理解 rpc 协议的交互

像浏览器一样的打印inputdata数据

data = "0xe9e05c42000000000000000000000000b0a25771c5f7aa7772d9f6ea048ba80124c12d89000000000000000000000000000000000000000000000000002386f26fc1000000000000000000000000000000000000000000000000000000000000000186a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000" # 这里放入inputdata值, 推文限制长度了，所以自己改下
start = 10
print('MethodId:' + data[:10])
for i in range(int(len(data[10:])/64)):
    msg = '[%d]: %s' % (i, data[start:start+64])
    print(msg)
    start += 64

往期代码交互教程

• scroll alpha test bridge代码交互

• aave gho稳定币项目代码交互教程

• base 存款代码交互教程

• sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

直接上代码样例。

import web3
import math
import requests

headers = {
    'content-type': 'application/json',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_current_block(self):
        """获取最新区块"""
        data = {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_block_detail(self, number):
        """获取区块hash"""
        if isinstance(number, int):
            number = hex(number)
        data = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[number,True],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def call(self, to, data):
        data = {"jsonrpc":"2.0","method":"eth_call","params":[{"to": to, "data": data}, "latest"],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()#(int(res.json()['result'], 16)) / math.pow(10,18)

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
if __name__ == '__main__':
    privkey = 'xxxxxxx' # 这里替换成自己的私钥
    value = 0.015 # 要存款的数量
    account = web3.Account.from_key(privkey)
    BALANCE_PRECISION = math.pow(10, 18) # 主币精度，18位
    rpc = Rpc('https://alpha-rpc.scroll.io/l2', chainid=534353)
    value = int(value * BALANCE_PRECISION)
    gaslimit = 45004 # gaslimit
    to = '0x5300000000000000000000000000000000000004' # 交互的合约地址
    method = '0xd0e30db0' # swap方法hash值
    data = method
    res = rpc.transfer(account, to=to, amount=value, gaslimit=gaslimit, data=data) # 发送交易
    print(res)

完成后在浏览器上查下hash

Scroll (ETH) Blockchain Explorer

Scrollscan allows you to explore and search the blockchain for transactions, addresses, tokens, prices and other activities taking place on Scroll Network

https://scrollscan.com

往期代码交互教程

• scroll alpha test bridge代码交互

• Aave Gho稳定币项目代码交互教程

• Coinbase L2 Base 存款代码交互教程

• Sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

• 查询

• 存款

• 取款

• mint nft

认准唯一下载链接:

https://github.com/junjie9021/simple-demo/releases/tag/base-v0.0.1

目前暂时提供win系统的版本

为安全考虑，建议大家不要用本地电脑来运行，大家也应该要有这样的意识，防止软件钓鱼，病毒。在这里，建议大家可以上腾讯云购买个香港竞价实例的机器，机器的配置价格在0.13¥/H

竞价室例→中国香港→标准型S5 2C2G→Windows→64位 Windows 2022数据中心 中文版

按流量计费，带宽拉满100M

输入密码

通过电脑自带的远程服务器或者通过腾讯云的登录来上机器

通过Edge 浏览器下载工具，记得还要下载解压工具，推荐用.7z

https://github.com/junjie9021/simple-demo/releases/tag/base-v0.0.1

解压工具

进入目录找到app.exe, 双击运行。

查询功能

输入地址，获得L1与L2 余额，日志可以通过鼠标点击再Ctrl+C来复制内容。

存款功能

需要输入私钥，建议用小号或新生成的地址私钥来测试，注意存款额度 是在最大-最小之间随机取值

设置

建议用默认值，主要设置L1 rpc与L2 rpc。如果你觉得网络不稳定可以在chainlist.org上查询最优rpc链接。gaslimit不要动

其他事项

提款功能暂时实现了L2上的发起，L1上还需要2次确认才能完全提款。你可以通过官方桥看到提款的状态

Bridges - Base Documentation

Documentation for bridging assets to Base. This page covers how to bridge ETH and ERC-20s between Ethereum (L1) and Base along with essential information.

https://docs.base.org

mint nft功能暂时实现了 mint cat功能，燃烧nft还未添加，可通过查询

再次提醒各位为安全考虑，切勿本地使用。

往期代码交互教程

• scroll alpha test bridge代码交互[

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/O04bGQYMc6H7fhYiCBdbpOAJl_ygG50ehW6LQRsRsvg

  ]

• Aave Gho稳定币项目代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/tdjYv4dEnsQry_U44kj0sbDa5htuRBYHpUf45w8v-qc

• Coinbase L2 Base 存款代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/IeEw0Qp3MYbwFZx111fi1J25Dm8JLcm6avEHv_72R-0

• Sui mint nft 代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/XHRTueAW7jk13TOHVdPchzkM38PnDxidsJqY2TCnqTQ

我的 推特 Lens Link3 Github

python3 代码样例

安装依赖

注意

• privkey 改成要交互的私钥

• 发送后去浏览器上查下tx状态，半天没返回的，就要换下rpc节点，可在 chainlist查看

• 有个key值暂时不要动， 要是tx 状态失败的，还得去合约上查下最新的

import web3
import math
import requests

headers = {
    'content-type': 'application/json',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_current_block(self):
        """获取最新区块"""
        data = {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_block_detail(self, number):
        """获取区块hash"""
        if isinstance(number, int):
            number = hex(number)
        data = {"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":[number,True],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def call(self, to, data):
        data = {"jsonrpc":"2.0","method":"eth_call","params":[{"to": to, "data": data}, "latest"],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()#(int(res.json()['result'], 16)) / math.pow(10,18)

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
if __name__ == '__main__':
    privkey = 'xxxxxxxxxxxx' # 这里替换成自己的私钥
    value = 0.1 # 要存款的数量
    account = web3.Account.from_key(privkey)
    BALANCE_PRECISION = math.pow(10, 18) # 主币精度，18位
    rpc = Rpc('https://goerli.infura.io/v3/9aa3d95b3bc440fa88ea12eaa4456161')
    value = int(value * BALANCE_PRECISION)
    gaslimit = 280000 # gaslimit
    to = '0xe5e30e7c24e4dfcb281a682562e53154c15d3332' # 交互的合约地址
    method = '0x9f8420b3' # 存款方法hash值
    key = 0.0000000625 # key值有可能经常改，昨晚还是0.00000004的
    amount = value + key * BALANCE_PRECISION # 计算要发送的amount
    data = '0x9f8420b3' + hex(value)[2:].rjust(64,'0') + '0000000000000000000000000000000000000000000000000000000000009c40' # 拼接数据
    res = rpc.transfer(account, to=to, amount=amount, gaslimit=gaslimit, data=data) # 发送交易
    print(res)

执行脚本后打印交易hash, 去浏览器查询状态

https://goerli.etherscan.io/

代码样例已上传:

https://github.com/junjie9021/simple-demo

往期代码交互教程

• Aave Gho稳定币项目代码交互教程

• Coinbase L2 Base 存款代码交互教程

• Sui mint nft 代码交互教程

我的 推特 Lens Link3 Github

https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/XU7k1qJrJR23R-NCoYp2qy20ttqzJQKXPHZKOQq6DK8

python3 代码样例

# 记得先安装依赖
pip install bip_utils

"""
pip install bip_utils
"""

import nacl
import base64
import hashlib
import requests
import bip_utils
from rpc import Rpc

headers = {
    'content-type': 'application/json',
    }

class Account:
    def __init__(self,  mnemonic: str, derivation_path="m/44'/784'/0'/0'/0'"):
        self.mnemonic = mnemonic
        self.derivation_path = derivation_path
        self.bip39_seed = bip_utils.Bip39SeedGenerator(self.mnemonic).Generate()  # or = bip39.phrase_to_seed(mnemonic)
        self.bip32_ctx = bip_utils.Bip32Slip10Ed25519.FromSeed(self.bip39_seed)
        self.bip32_der_ctx = self.bip32_ctx.DerivePath(derivation_path)
        self.private_key: bytes = self.bip32_der_ctx.PrivateKey().Raw().ToBytes()
        self.public_key: bytes = self.bip32_der_ctx.PublicKey().RawCompressed().ToBytes()
        self.full_private_key = self.private_key[:32] + self.public_key[1:]
        self.address = self.get_address()

    @staticmethod
    def generate():
        return Account(mnemonic=bip_utils.Bip39MnemonicGenerator().FromWordsNumber(bip_utils.Bip39WordsNum.WORDS_NUM_12).ToStr())

    def get_address(self) -> str:
        return "0x" + hashlib.sha3_256(self.bip32_der_ctx.PublicKey().RawCompressed().ToBytes()).digest().hex()[:40]

    def sign_data(self, data: bytes) -> bytes:
        return nacl.signing.SigningKey(self.private_key).sign(data)[:64]  # Todo: support secp256k1 key and signature

    def get_public_key_as_b64_string(self) -> str:
        return base64.b64encode(self.public_key[1:]).decode()
    
if __name__ == '__main__':
    rpc = Rpc('https://fullnode.devnet.sui.io')
    account = Account.generate() # 生成一个地址
    account = Account('pilot fish popular tuna energy zoo initial vivid gym win gain author')
    print(account.mnemonic, account.address) # 打印私钥和地址
    faucet_url = 'https://faucet.devnet.sui.io/gas'
    data = {"FixedAmountRequest":{"recipient": account.address}}
    res = requests.post(faucet_url, json=data,  headers=headers, verify=False) # 领水
    print(res.json()) # 打印输出
    # mint nft
    args = ["Example NFT", "An NFT created by Sui Wallet", "ipfs://QmZPWWy5Si54R3d26toaqRiqvCH7HkGdXkxwUgCm2oKKM2?filename=img-sq-01.png"] # mint nft的参数
    res = rpc.move_call(account.address, '0x2', 'devnet_nft', 'mint', args, gas_budget=2000) # 与合约交互获取返回的txBytes
    tx = res['result']['txBytes']
    res = rpc.sendtx(tx, account) # 广播交易
    print(res) # 打印交易hash
    

通过浏览器看到，地址已经领水并成功 mint nft

Sui Explorer

Explore transactions, objects, etc. of Sui network

https://suiexplorer.com

开发网络和测试网络 mint nft 的代码都一样的

代码已上传:

https://github.com/junjie9021/simple-demo/tree/main/Sui

往期代码交互教程

• Aave Gho稳定币项目代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/tdjYv4dEnsQry_U44kj0sbDa5htuRBYHpUf45w8v-qc

• Coinbase L2 Base 存款代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/HhnUs4fDOFgfzjC6batf4QPqQH2xlYcHJlJ89toGhlc

• Coinbase L2 Base 主网纪念nft mint 代码交互教程

  https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/HhnUs4fDOFgfzjC6batf4QPqQH2xlYcHJlJ89toGhlc

我的 推特 Lens Link3 Github

import uuid
import json
import base64
import urllib3
import requests
from typing import List
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

headers = {
    'content-type': 'application/json',
    'accept-encoding': 'gzip, deflate, br',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

SUI_COIN_TYPE = "0x2::coin::Coin<0x2::sui::SUI>"


class Rpc:
    def __init__(self, api='https://fullnode.testnet.sui.io/', proxies=None):
        self.api = api
        self.proxies = proxies

    def get_objects(self, address):
        """获取地址拥有的objs
        """
        data = {"method": "sui_getObjectsOwnedByAddress","jsonrpc": "2.0","params": [address],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()
        
    def get_object(self, obj_id):
        """返回指定对象的对象信息;
        """
        data = {"method": "sui_getObject","jsonrpc": "2.0","params": [obj_id],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def get_transaction(self, tx):
        """获取交易详情
        """
        data = {"method": "sui_getTransaction","jsonrpc": "2.0","params": [tx],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def transfer_sui(self, from_, object_id, to, amount, gas=1000,):
        """创建一个未签名的交易以将 SUI 硬币对象发送到 Sui 地址。 SUI 对象也用作气体对象。
        """
        data = {"method": "sui_transferSui","jsonrpc": "2.0","params": [from_, object_id, gas, to, int(amount)],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def pay_sui(self, from_, objs, to, amount, gas=300):
        """创建一个未签名的交易以将 SUI 硬币对象发送到 Sui 地址。 SUI 对象也用作气体对象。
        """
        data = {"method": "sui_paySui","jsonrpc": "2.0","params": [from_, objs, [to], amount, gas],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def pay_all_sui(self, from_, objs, to, gas=1000):
        """创建一个未签名的交易以将 SUI 硬币对象发送到 Sui 地址。 SUI 对象也用作气体对象。
        """
        data = {"method": "sui_payAllSui","jsonrpc": "2.0","params": [from_, objs, to, gas],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def transfer(self, from_, to, amount):
        objs = self.get_objects(from_)
        amount = int(amount)
        sui_objs = [i['objectId'] for i in objs['result'] if i['type'] == SUI_COIN_TYPE]
        balance = 0
        pay_objs = []
        for i in sui_objs:
            obj = self.get_object(i)
            if int(obj['result']['details']['data']['fields']['balance']) > amount:
                res = self.pay_sui(from_, [i], to, [amount])
                return res
            balance += int(obj['result']['details']['data']['fields']['balance'])
            pay_objs.append(i)
            if balance >= amount:
                res = self.pay_sui(from_, pay_objs, to, [amount])
                return res

    def merge_coin(self, address, primary_obj_id, merge_obj_id, gas=1000, gas_object_id=None):
        """合并硬币;
        """
        gas_object_id = primary_obj_id
        data = {"method": "sui_mergeCoins","jsonrpc": "2.0","params": [address, primary_obj_id, merge_obj_id, gas_object_id, gas],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def execute_transaction(self, tx_bytes, signature_bytes, pub_key, request_type="WaitForLocalExecution"):
        """广播交易
        """
        flag = {
            "ed25519": 0x00,
            "secp256k1": 0x01,
        }
        sign_b64 = base64.b64encode(signature_bytes).decode()
        serialized_sig = [flag["ed25519"]] + \
                         list(base64.b64decode(sign_b64)) + \
                         list(base64.b64decode(pub_key))
        signature = base64.b64encode(bytes(serialized_sig)).decode()
        data = {"method": "sui_executeTransactionSerializedSig","jsonrpc": "2.0","params": [tx_bytes, signature, request_type],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def transfer_object(self, from_, object_id, to, gas=1000, gas_object_id=None):
        """创建一个未签名的交易以将 SUI 硬币对象发送到 Sui 地址。 SUI 对象也用作气体对象。
        """
        data = {"method": "sui_transferObject","jsonrpc": "2.0","params": [from_, object_id, gas_object_id, gas, to],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers)
        return res.json()

    def move_call(self, address, package_object_id, module, function, arguments, gas_budget=10000, type_arguments=[], gas=None):
        """合约交互"""
        data = {"method": "sui_moveCall","jsonrpc": "2.0","params": [address, package_object_id, module, function, type_arguments, arguments, gas, gas_budget],"id": str(uuid.uuid1())}
        res = requests.post(self.api, data=json.dumps(data), headers=headers, proxies=self.proxies)
        return res.json()

    def sendtx(self, tx, account):
        """广播交易"""
        # 1.对tx进行base64编码
        tx_b64 = base64.b64decode(tx)
        # 2. 签名 [0, 0, 0] + tx; 参考 https://github.com/MystenLabs/sui/pull/6445
        data = bytes([0, 0, 0] + list(map(int, tx_b64)))
        signature_bytes = account.sign_data(data)
        pub_key = account.get_public_key_as_b64_string()
        res = self.execute_transaction(tx, signature_bytes, pub_key)
        return res

wave3出来后，会再给大家提供个最基本的如何Mint nft的代码样例。

代码已上传：

simple-airdrop-demo/sui at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

Aave - Open Source Liquidity Protocol

Aave is an Open Source Protocol to create Non-Custodial Liquidity Markets to earn interest on supplying and borrowing assets with a variable or stable interest rate. The protocol is designed for easy integration into your products and services.

https://gho.aave.com

我们用代码的方式来交互下存款，python3代码样例，可执行代码:

注意: 执行前记得替换自己的私钥，默认存款0.01个

"""
pip3 install web3
"""

import web3
import math
import requests

headers = {
    'content-type': 'application/json',
    'accept-encoding': 'gzip, deflate, br',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        """获取地址nonce"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
if __name__ == '__main__':
    privkey = 'xxxxxxx' # 这里替换成自己的私钥
    account = web3.Account.from_key(privkey)
    rpc = Rpc()
    value = 0.01 # 要存款的数量
    gaslimit = 299906 # gaslimit
    to = '0x9c402e3b0d123323f0fced781b8184ec7e02dd31' # base存款的合约地址
    method = '0x474cf53d' # 存款方法hash值
    amount = int(value * math.pow(10, 18)) # eth的主币精度是18位
    unit_0 = '000000000000000000000000617cf26407193e32a771264fb5e9b8f09715cdfb'
    addr_1 = account.address[2:].rjust(64,'0') # 地址格式处理
    unit_2 = '0000000000000000000000000000000000000000000000000000000000000000'
    data = method + unit_0 + addr_1 + unit_2 # 拼接数据
    res = rpc.transfer(account, to=to, amount=amount, gaslimit=gaslimit, data=data) # 发送交易
    print(res)

执行后打印交易hash, 去浏览器查询状态

https://goerli.etherscan.io/

回到gho dashbord，看到我们已经地址已经有存款了

Aave - Open Source Liquidity Protocol

Aave is an Open Source Protocol to create Non-Custodial Liquidity Markets to earn interest on supplying and borrowing assets with a variable or stable interest rate. The protocol is designed for easy integration into your products and services.

https://gho.aave.com

代码样例已上传:

simple-airdrop-demo/aave at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

https://mirror.xyz/0x7b52FD04cC45B26F5bdea1CD7c8c56A00A3F859B/IeEw0Qp3MYbwFZx111fi1J25Dm8JLcm6avEHv_72R-0

这是mint网址， mint需要花0.000777 哥ETH，大概1.28u

https://zora.co/collections/0xd4307e0acd12cf46fd6cf93bc264f5d5d1598792

以下为python3代码样例:

"""
pip3 install web3
"""
import web3
import math
import requests

headers = {
    'content-type': 'application/json',
    'accept-encoding': 'gzip, deflate, br',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        """获取地址nonce"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
if __name__ == '__main__':
    privkey = 'xxxxxxx' # 这里替换成自己的私钥
    account = web3.Account.from_key(privkey)
    rpc = Rpc(rpc='https://rpc.ankr.com/eth', chainid=1)
    amount = 0.000777 # 要存款的数量
    gaslimit = 116900 # gaslimit
    mint_nft_token = '0xd4307e0acd12cf46fd6cf93bc264f5d5d1598792' # base存款的合约地址
    method = '0xefef39a1' # mint nft 方法hash值
    uint_1 = '0000000000000000000000000000000000000000000000000000000000000001'
    data = method + uint_1 # 拼接数据
    amount = hex(int(amount * math.pow(10, 18))) # 处理amount值
    res = rpc.transfer(account, to=mint_nft_token, amount=amount, gaslimit=gaslimit, data=data) # 发送交易
    print(res)

通过交易hash在eth 浏览器查看状态

现在mint nft gas费有点高，花了6u，肉疼。建议大家在低gas费时参与mint

代码样例已上传:

simple-airdrop-demo/base at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com

默认你已经具备以下知识:

• python3

存款示例, 以下是Python3的代码示例:

"""
安装依赖
pip3 install web3
"""
import web3
import math
import requests

headers = {
    'content-type': 'application/json',
    'accept-encoding': 'gzip, deflate, br',
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
    }

class Rpc:
    """
    eth rpc方法
    """
    def __init__(self, rpc='https://rpc.ankr.com/eth_goerli', chainid=5, proxies=None, timeout=30):
        self.rpc = rpc
        self.chainid = chainid
        self.proxies = proxies
        self.timeout = timeout

    def get_transaction(self, txhash):
        """获取的交易详情"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionByHash","params":[txhash],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_gas_price(self):
        """获取gas"""
        data = {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_balance(self, address):
        """获取余额"""
        data = {"jsonrpc":"2.0","method":"eth_getBalance","params":[address, 'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def get_transaction_count_by_address(self, address):
        """获取地址nonce"""
        data = {"jsonrpc":"2.0","method":"eth_getTransactionCount","params":[address,'latest'],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers, proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def send_raw_transaction(self, hex):
        """广播交易"""
        data = {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":[hex],"id":1}
        res = requests.post(self.rpc, json=data, headers=headers,  proxies=self.proxies, timeout=self.timeout)
        return res.json()

    def transfer(self, account, to, amount, gaslimit, **kw):
        """离线交易
        account
        to: 收款地址
        gaslimit: 由当前区块的gaslimit获取
        gasprice: get_gas_price获取
        nonce: 交易总数 get_transaction_count_by_address获取
        chainId: 链id
        """
        amount = int(amount, 16) if isinstance(amount, str) else int(amount)
        gaslimit = int(gaslimit, 16) if not isinstance(gaslimit, int) else gaslimit
        gasprice = int(self.get_gas_price()['result'], 16)
        nonce = int(self.get_transaction_count_by_address(account.address)['result'], 16)
        tx = {'from': account.address, 'value': amount,'to': to, 'gas': gaslimit, 'gasPrice': gasprice, 'nonce': nonce, 'chainId': self.chainid}
        if kw:
            tx.update(**kw)
        signed = account.signTransaction(tx)
        return self.send_raw_transaction(signed.rawTransaction.hex())
    
if __name__ == '__main__':
    privkey = 'xxxxxxxx' # 这里替换成自己的私钥
    account = web3.Account.from_key(privkey)
    rpc = Rpc()
    value = 0.01 # 要存款的数量
    gaslimit = 100000 # gaslimit
    base_token = '0xe93c8cd0d409341205a592f8c4ac1a5fe5585cfa' # base存款的合约地址
    method = '0xe9e05c42' # 存款方法hash值
    addr_0 = account.address[2:].rjust(64,'0') # 地址格式处理
    amount = int(value * math.pow(10, 18)) # eth的主币精度是18位
    value = hex(amount) # value hex格式处理
    unit_1 = value[2:].rjust(64,'0')
    unit_2 = hex(int(gaslimit))[2:].rjust(64,'0')
    bool_3 = '0000000000000000000000000000000000000000000000000000000000000000'
    unit_4 = '00000000000000000000000000000000000000000000000000000000000000a0'
    unit_5 = '0000000000000000000000000000000000000000000000000000000000000000'
    data = method + addr_0 + unit_1 + unit_2 + bool_3 + unit_4 + unit_5 # 拼接数据
    res = rpc.transfer(account, to=base_token, amount=amount, gaslimit=gaslimit, data=data) # 发送交易
    print(res) # 打印交易hash

通过交易hash在Goerli 浏览器查看状态，状态成功后

https://goerli.etherscan.io/

再在L2 Base 浏览器查看地址余额数量，检查是否存款

Base Göerli blockchain explorer - View Base Göerli stats | Blockscout

Open-source block explorer by Blockscout. Search transactions, verify smart contracts, analyze addresses, and track network activity. Complete blockchain data and APIs for the Base Göerli (Goerli) Explorer network.

https://base-goerli.blockscout.com

代码样例已上传:

simple-airdrop-demo/base at main · junjie9021/simple-airdrop-demo

Contribute to junjie9021/simple-airdrop-demo development by creating an account on GitHub.

https://github.com