def call(self, to_address, contract_abi, fn_name, args=None):
cmd = "call"
if self.client_account == None:
self.load_default_account()
functiondata = encode_transaction_data(fn_name, contract_abi, None,
args)
callmap = dict()
callmap["data"] = functiondata
callmap["from"] = self.client_account.address
callmap["to"] = to_address
callmap["value"] = 0
params = [1, callmap]
# 发送
response = self.common_request(cmd, params)
outputdata = response["output"]
#取得方法的abi，签名，参数 和返回类型，进行call返回值的解析
fn_abi, fn_selector, fn_arguments = get_function_info(
fn_name,
contract_abi,
None,
args,
None,
)
#print("fn_selector",fn_selector)
#print("fn_arguments",fn_arguments)
fn_output_types = get_fn_abi_types_single(fn_abi, "outputs")
#print("output types str:", fn_output_types)
decoderesult = decode_single(fn_output_types, decode_hex(outputdata))
return decoderesult
def call(self, to_address, contract_abi, fn_name, args=None):
cmd = "call"
if to_address != "":
common.check_and_format_address(to_address)
if self.client_account is None:
self.load_default_account()
functiondata = encode_transaction_data(fn_name, contract_abi, None,
args)
callmap = dict()
callmap["data"] = functiondata
callmap["from"] = self.client_account.address
callmap["to"] = to_address
callmap["value"] = 0
# send transaction to the given group
params = [client_config.groupid, callmap]
# 发送
response = self.common_request(cmd, params)
if "output" in response.keys():
outputdata = response["output"]
# 取得方法的abi，签名，参数 和返回类型，进行call返回值的解析
fn_abi, fn_selector, fn_arguments = get_function_info(
fn_name,
contract_abi,
None,
args,
None,
)
# print("fn_selector",fn_selector)
# print("fn_arguments",fn_arguments)
fn_output_types = get_fn_abi_types_single(fn_abi, "outputs")
# print("output types str:", fn_output_types)
decoderesult = decode_single(fn_output_types,
decode_hex(outputdata))
return decoderesult
return response
def sendRawTransaction(self,
to_address,
contract_abi,
fn_name,
args=None,
bin_data=None,
gasPrice=30000000,
packet_type=ChannelPack.TYPE_RPC):
cmd = "sendRawTransaction"
if to_address != "":
common.check_and_format_address(to_address)
# 第三个参数是方法的abi，可以传入None，encode_transaction_data做了修改，支持通过方法+参数在整个abi里找到对应的方法abi来编码
if bin_data is None:
functiondata = encode_transaction_data(fn_name, contract_abi, None,
args)
# the args is None
elif args is None:
functiondata = bin_data
# deploy with params
else:
fn_data = get_aligned_function_data(contract_abi, None, args)
functiondata = bin_data + fn_data[2:]
if to_address is not None and len(to_address) > 0:
from eth_utils import to_checksum_address
to_address = to_checksum_address(to_address)
# load default account if not set .notice: account only use for
# sign transaction for sendRawTransa# if self.client_account is None:
self.load_default_account()
# 填写一个bcos transaction 的 mapping
import random
txmap = dict()
txmap["randomid"] = random.randint(0, 1000000000) # 测试用 todo:改为随机数
txmap["gasPrice"] = gasPrice
txmap["gasLimit"] = gasPrice
txmap["blockLimit"] = self.getBlockLimit() # 501 # 测试用，todo：从链上查一下
txmap["to"] = to_address
txmap["value"] = 0
txmap["data"] = functiondata
txmap["fiscoChainId"] = self.fiscoChainId
txmap["groupId"] = self.groupid
txmap["extraData"] = ""
#print("\n>>>>functiondata ",functiondata)
sign = SignTx()
sign.crypto_type = client_config.crypto_type
# 关键流程：对交易签名，重构后全部统一到 SignTx 类(client/signtransaction.py)完成
sign.gm_account = self.gm_account
sign.ecdsa_account = self.ecdsa_account
signed_result = sign.sign_transaction(txmap)
#print("@@@@@rawTransaction : ",encode_hex(signedTxResult.rawTransaction))
# signedTxResult.rawTransaction是二进制的，要放到rpc接口里要encode下
params = [self.groupid, encode_hex(signed_result.rawTransaction)]
result = self.common_request(cmd, params, packet_type)
return result
def sendRawTransaction(self, to_address, contract_abi, fn_name, args=None,
bin_data=None, gasPrice=30000000,
packet_type=ChannelPack.TYPE_RPC):
cmd = "sendRawTransaction"
if to_address != "":
common.check_and_format_address(to_address)
# 第三个参数是方法的abi，可以传入None，encode_transaction_data做了修改，支持通过方法+参数在整个abi里找到对应的方法abi来编码
if bin_data is None:
functiondata = encode_transaction_data(fn_name, contract_abi, None, args)
# the args is None
elif args is None:
functiondata = bin_data
# deploy with params
else:
fn_data = get_aligned_function_data(contract_abi, None, args)
functiondata = bin_data + fn_data[2:]
if to_address is not None and len(to_address) > 0:
from eth_utils import to_checksum_address
to_address = to_checksum_address(to_address)
# load default account if not set .notice: account only use for
# sign transaction for sendRawTransaction
if self.client_account is None:
self.load_default_account()
# 填写一个bcos transaction 的 mapping
import random
txmap = dict()
txmap["randomid"] = random.randint(0, 1000000000) # 测试用 todo:改为随机数
txmap["gasPrice"] = gasPrice
txmap["gasLimit"] = gasPrice
txmap["blockLimit"] = self.getBlockLimit() # 501 # 测试用，todo：从链上查一下
txmap["to"] = to_address
txmap["value"] = 0
txmap["data"] = functiondata
txmap["fiscoChainId"] = self.fiscoChainId
txmap["groupId"] = self.groupid
txmap["extraData"] = ""
'''
from datatypes.bcostransactions import (
serializable_unsigned_transaction_from_dict,
)
# 将mapping构建一个transaction对象,非必要，用来对照的
transaction = serializable_unsigned_transaction_from_dict(txmap)
# 感受下transaction encode的原始数据
print(encode_hex(rlp.encode(transaction)))
'''
# 实际上只需要用sign_transaction就可以获得rawTransaction的编码数据了,input :txmap,私钥
signedTxResult = Account.sign_transaction(txmap, self.client_account.privateKey)
# signedTxResult.rawTransaction是二进制的，要放到rpc接口里要encode下
params = [self.groupid, encode_hex(signedTxResult.rawTransaction)]
result = self.common_request(cmd, params, packet_type)
return result
def call(self, to_address, contract_abi, fn_name, args=None):
cmd = "call"
if to_address != "":
common.check_and_format_address(to_address)
self.load_default_account()
functiondata = encode_transaction_data(fn_name, contract_abi, None,
args)
callmap = dict()
callmap["data"] = functiondata
callmap["from"] = self.default_from_account_signer.get_keypair(
).address
callmap["to"] = to_address
callmap["value"] = 0
# send transaction to the given group
params = [client_config.groupid, callmap]
# 发送
response = self.common_request(cmd, params)
#print("response : ",response)
# check status
if "status" in response.keys():
status = int(response["status"], 16)
error_message = transaction_status_code.TransactionStatusCode.get_error_message(
status)
if error_message is not None:
raise BcosException(
"call error, error message: {}".format(error_message))
if "output" in response.keys():
outputdata = response["output"]
# 取得方法的abi，签名，参数 和返回类型，进行call返回值的解析
fn_abi, fn_selector, fn_arguments = get_function_info(
fn_name,
contract_abi,
None,
args,
None,
)
# print("fn_selector",fn_selector)
# print("fn_arguments",fn_arguments)
#fn_output_types = get_fn_abi_types_single(fn_abi, "outputs")
fn_output_types = get_abi_output_types(fn_abi)
try:
#decoderesult = decode_single(fn_output_types, decode_hex(outputdata))
#print("fn_output_types",fn_output_types)
decoderesult = decode_abi(fn_output_types,
decode_hex(outputdata))
return decoderesult
except BaseException as e:
return response
return response
print("privkey: ", encode_hex(ac2.key))
'''
#也可以从私钥文本得到一个可用来签名的帐户对象
ac3 = Account.from_key("255f01b066a90853a0aa18565653d7b944cd2048c03613a9ff31cb9df9e693e5")
print("test from key")
print("read from file: address", ac3.address)
print("pubkey: ", ac3.publickey)
print("privkey: ", encode_hex(ac3.key))
'''
# 从abi文件获得abi的文本定义
with open(r"sample/AddrTableWorker.abi", 'r') as load_f:
contract_abi = json.load(load_f)
# 将要调用的函数和参数编码
inputparams = ['abcefggg', 189, '0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1b']
# 第三个参数是方法的abi，可以传入None，encode_transaction_data做了修改，支持通过方法+参数在整个abi里找到对应的方法abi来编码
functiondata = encode_transaction_data("create", contract_abi, None,
inputparams)
print("encode_transaction_data:", functiondata)
# 填写一个bcos transaction 的 mapping
contractAddress = "0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1b"
txmap = dict()
txmap["randomid"] = random.randint(0, 1000000000) # 测试用 todo:改为随机数
txmap["gasPrice"] = 30000000
txmap["gasLimit"] = 30000000
txmap["blockLimit"] = 501 # 测试用，todo：从链上查一下
txmap["to"] = contractAddress
txmap["value"] = 0
txmap["data"] = functiondata
txmap["fiscoChainId"] = 1
txmap["groupId"] = 1
txmap["extraData"] = ""
# txmap["chainId"]=None #chainId没用了，fiscoChainId有用
print("hexdata", data.hex())
data = b'7551ab5643a1690f7b128d0d1790ca6b02a2b5a34653d4311673588d0fa42789'
keyfile = "bin/account1.json"
account = GM_Account()
account.load_from_file(keyfile)
print(account.getdetail())
signer = SignTx()
signer.KeyPair = account
# 从abi文件获得abi的文本定义
parser = DatatypeParser()
abi_file = "contracts/HelloWorld.abi"
parser.load_abi_file(abi_file)
inputparam = ['test123789111']
# print(parser.contract_abi)
functiondata = encode_transaction_data("set", parser.contract_abi, None,
inputparam)
result = parser.parse_transaction_input(functiondata)
print("parse tx input :", result)
print("functiondata ", functiondata)
sighash = keccak(b"set(string)")
print(sighash)
# 填写一个bcos transaction 的 mapping
contractAddress = to_checksum_address(
"0x565081461f6f0e1c5bf738013f11f1ca8a5b1537")
txmap = dict()
txmap["randomid"] = random.randint(0, 1000000000) # 测试用 todo:改为随机数
txmap["gasPrice"] = 30000000
txmap["gasLimit"] = 30000000
txmap["blockLimit"] = 300 # 测试用，todo：从链上查一下
txmap["to"] = contractAddress
import json
from eth_abi import decode_single
from eth_account.account import Account
from eth_utils import decode_hex, encode_hex, to_checksum_address
from utils.abi import get_fn_abi_types_single
from utils.contracts import encode_transaction_data, get_function_info
if (True):
parser = DatatypeParser()
parser.load_abi_file("contracts/HelloWorld.abi")
parser.parse_abi()
fn_name = "set"
contract_abi = parser.contract_abi
args = ["1234"]
set_tx_data = encode_transaction_data(fn_name, contract_abi, None, args)
print("set_tx_data:", set_tx_data)
contractAddress = to_checksum_address(
"0x882be29b2d5ac85d6c476fa3fd5f0cae4b4585cc")
txmap = dict()
txmap["randomid"] = 10003 # 测试用 todo:改为随机数
txmap["gasPrice"] = 30000000
txmap["gasLimit"] = 30000000
txmap["blockLimit"] = 501 # 测试用，todo：从链上查一下
txmap["to"] = contractAddress
txmap["value"] = 0
txmap["data"] = set_tx_data
txmap["fiscoChainId"] = 1
txmap["groupId"] = 1
txmap["extraData"] = ""
# 将mapping构建一个transaction对象,非必要，用来对照的
abitext = "(string,uint256,address)"
result = decode_single(abitext, bindata)
print("!!param decode result ", result)
# 将('abc', 1000, '0x7029c502b4f824d19bd7921e9cb74ef92392fb1b') 这样的数据encode一次，进行对比
# 大写：('abc', 1000, '0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1b')
inputparams = ('abc', 1000, '0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1b')
encoderesult = encode_single(abitext, inputparams)
print(encode_hex(encoderesult))
func_abi = func_abi_byname[0]
# encode_transaction_data 里对address的编码要大写
with open(r"sample\AddrTableWorker.abi", 'r') as load_f:
contract_abi = json.load(load_f)
inputparams = ('abc', 1000, '0x7029c502b4F824d19Bd7921E9cb74Ef92392FB1b')
result = encode_transaction_data("create", contract_abi, None, inputparams)
print("encode_transaction_data:", result)
if result == inputdata:
print("Success")
'''
def prepare_transaction(
address,
fn_identifier,
contract_abi=None,
fn_abi=None,
transaction=None,
fn_args=None,
fn_kwargs=None):'''
'''
parser = DatatypeParser("contracts/TestStruct.abi")
print(parser)
fn_name = "addUser"
abi = parser.get_function_abi(fn_name)
args = [("alice", 23)]
print(args)
#l = encode_abi(['bytes32', 'bytes32'], [b'a', b'b'])
#l = encode_abi([('string','uint256')],[args])
#print(encode_hex(l))
data = '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000190000000000000000000000000000000000000000000000000000000000000005616c696365000000000000000000000000000000000000000000000000000000'
#p = decode_abi(['string','uint256'],decode_hex(data))
#print(p)
functiondata = encode_transaction_data(fn_name, parser.contract_abi, None,
args)
print("functiondata", functiondata)
inputabi = ['(string,uint256)']
decodedata = decode_abi(inputabi, decode_hex(data))
print("decodedata", decodedata)
import re
matchpattern = r"\(.*?\)"
s = '("bob1",88),("carol",11)'
res = re.split(matchpattern, s)
#print(res)
#print(res[2])
s = '[abc,"12,34"]'
ss = s.split(",")
#print(ss)