def test_token_1(bank, registry, token_name):
alice = accounts.add(
'a8060afe2390bd0c00c7ef800f545d466b55cc84d4ad6d01e03220af03e97982')
bob = accounts.add(
'7b9009958a83807bbe38bf35f451ff0c4bf4d926cee63dd07658762db58ceba4')
# bank.deposit({'from': bob, 'value': '0.1 ether', 'gas_price':1000000000})
prevBNBBal = alice.balance()
bank.work(
0, registry[token_name]['goblin'], 10**17, 0,
eth_abi.encode_abi(['address', 'bytes'], [
registry[token_name]['two_side'].address,
eth_abi.encode_abi(['address', 'uint256', 'uint256'],
[registry[token_name]['token'], 0, 0])
]), {
'from': alice,
'value': '0.05 ether',
'gas_price': 1000000000
})
curBNBBal = alice.balance()
print('∆ ht alice', curBNBBal - prevBNBBal)
pos_id = bank.nextPositionID() - 1
print('alice pos', bank.positionInfo(pos_id))
def test_cake_2(bank, registry):
alice = accounts[1]
prevBNBBal = alice.balance()
bank.work(
0, registry['sashimi']['goblin'], 0, 0,
eth_abi.encode_abi(['address', 'bytes'], [
registry['sashimi']['two_side'].address,
eth_abi.encode_abi(['address', 'uint256', 'uint256'],
[sashimi_address, 0, 0])
]), {
'from': alice,
'value': '1 ether'
})
curBNBBal = alice.balance()
print('∆ ht alice', curBNBBal - prevBNBBal)
print('alice pos', bank.positionInfo(1))
assert almostEqual(curBNBBal - prevBNBBal,
-10**18), 'incorrect BNB input amount'
# test reinvest
chain.mine(10)
goblin = interface.IAny(registry['sashimi']['goblin'])
goblin.reinvest({'from': alice})
def encode_dom_sep(inst):
chain_id = brownie.network.chain.id
preimg = encode_abi(['bytes32', 'uint256', 'uint256', 'address'], [
bytes.fromhex(C.DOMAIN_SEPARATOR_TYPEHASH[2:]), chain_id,
inst.tx.block_number, inst.address
])
return web3.keccak(preimg).hex()
def encode_function_call(self, function_name, args):
if function_name not in self.function_data:
raise ValueError('Unkown function {}'.format(function_name))
description = self.function_data[function_name]
function_selector = zpad(encode_int(description['prefix']), 4)
arguments = encode_abi(description['encode_types'], args)
return function_selector + arguments
def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types),
)
)
try:
encoded_arguments = encode_abi(
argument_types,
force_obj_to_bytes(arguments),
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e))
)
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments)))
)
else:
return encode_hex(encoded_arguments)
def _encode_data(primaryType: str, data: any, types) -> str:
encodedTypes = ['bytes32']
encodedValues = [_type_hash(primaryType, types)]
for field in types[primaryType]:
value = data[field['name']]
if field['type'] == 'string':
hashValue = keccak(text=value)
encodedTypes.append('bytes32')
encodedValues.append(hashValue)
elif field['type'] == 'bytes':
hashValue = keccak(hexstr=value)
encodedTypes.append('bytes32')
encodedValues.append(hashValue)
elif field['type'] in types:
encodedTypes.append('bytes32')
hashValue = keccak(
_encode_data(field['type'], value, types).encode())
encodedValues.append(hashValue)
elif field['type'] == 'uint256':
encodedTypes.append('uint256')
encodedValues.append(int(value))
else:
encodedTypes.append(field['type'])
normalizedValue = _normalize_value(field['type'], value)
encodedValues.append(normalizedValue)
return encode_abi(encodedTypes, encodedValues)
def handle_offchain_lookup(
offchain_lookup_payload: Dict[str, Any],
transaction: TxParams,
) -> bytes:
formatted_sender = to_hex_if_bytes(
offchain_lookup_payload['sender']).lower()
formatted_data = to_hex_if_bytes(
offchain_lookup_payload['callData']).lower()
if formatted_sender != to_hex_if_bytes(transaction['to']).lower():
raise ValidationError(
'Cannot handle OffchainLookup raised inside nested call. Returned `sender` value does '
'not equal `to` address in transaction.')
for url in offchain_lookup_payload['urls']:
formatted_url = URI(
str(url).replace('{sender}', str(formatted_sender)).replace(
'{data}', str(formatted_data)))
try:
if '{data}' in url and '{sender}' in url:
response = get_response_from_get_request(formatted_url)
elif '{sender}' in url:
response = get_response_from_post_request(formatted_url,
data={
"data":
formatted_data,
"sender":
formatted_sender,
})
else:
raise ValidationError('url not formatted properly.')
except Exception:
continue # try next url if timeout or issues making the request
if 400 <= response.status_code <= 499: # if request returns 400 error, raise exception
response.raise_for_status()
if not 200 <= response.status_code <= 299: # if not 400 error, try next url
continue
result = response.json()
if 'data' not in result.keys():
raise ValidationError(
"Improperly formatted response for offchain lookup HTTP request - missing 'data' "
"field.")
encoded_data_with_function_selector = b''.join([
# 4-byte callback function selector
to_bytes_if_hex(offchain_lookup_payload['callbackFunction']),
# encode the `data` from the result and the `extraData` as bytes
encode_abi(['bytes', 'bytes'], [
to_bytes_if_hex(result['data']),
to_bytes_if_hex(offchain_lookup_payload['extraData']),
])
])
return encoded_data_with_function_selector
raise MultipleFailedRequests("Offchain lookup failed for supplied urls.")
def play(contract_address, data):
NONCE = web3.eth.getTransactionCount(RESOLVER_ADDRESS, "pending")
gas_price = requests.get("https://ethgasstation.info/json/ethgasAPI.json").json()[
"fast"
]
last_data = bytes.fromhex(data[2:])
func_sig = function_signature_to_4byte_selector("buy(uint64,bool,bytes)")
signed = web3.eth.account.signTransaction(
{
"to": contract_address,
"data": func_sig
+ encode_abi(
["uint64", "bool", "bytes"],
[int(time.time()) + 345, random.randint(0, 1) == 0, last_data],
),
"nonce": NONCE,
"gasPrice": web3.toWei(str(gas_price / 10 + 5), "gwei"),
"value": web3.toWei("0.104", "ether"),
"gas": 350000,
},
RESOLVER_PK,
)
txhash = web3.eth.sendRawTransaction(signed.rawTransaction).hex()
return txhash
def update_rewards(badger: BadgerSystem) -> str:
data = encode_abi(["address"], [GOVERNANCE_MULTISIG_ADDRESS])
delay = 2 * days(2)
eta = web3.eth.getBlock("latest")["timestamp"] + delay
return badger.governance_queue_transaction(CONTROLLER_ADDRESS,
FUNCTION_TO_CALL, data, eta)
def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types), ))
try:
encoded_arguments = encode_abi(
argument_types,
force_obj_to_bytes(arguments),
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e)))
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments))))
else:
return encode_hex(encoded_arguments)
def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types), ))
try:
normalizers = [
abi_bytes_to_hex, abi_string_to_hex, hexstrs_to_bytes
]
normalized_arguments = map_abi_data(
normalizers,
argument_types,
arguments,
)
encoded_arguments = encode_abi(
argument_types,
normalized_arguments,
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e)))
if data:
return to_hex(HexBytes(data) + encoded_arguments)
else:
return encode_hex(encoded_arguments)
def eth_abi_encode(func: dict, args: list) -> str:
"""
>> func = {"constant":True,"inputs":[{"name":"","type":"address"}],
"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":False,"stateMutability":"view","type":"function"}
>> eth_abi_encode(abi, ['9d3d4cc1986d81f9109f2b091b7732e7d9bcf63b'])
>> '70a082310000000000000000000000009d3d4cc1986d81f9109f2b091b7732e7d9bcf63b'
## address must be lower case
"""
if not func:
return "00"
types = list([inp['type'] for inp in func.get('inputs', [])])
if func.get('name'):
result = function_abi_to_4byte_selector(func) + encode_abi(types, args)
else:
result = encode_abi(types, args)
return result.hex()
def get_transaction_data_from_chromosome(self, chromosome_index):
data = ""
arguments = []
function = None
for j in range(len(self.chromosome[chromosome_index]["arguments"])):
if self.chromosome[chromosome_index]["arguments"][j] == "fallback":
function = "fallback"
data += random.choice(["", "00000000"])
elif self.chromosome[chromosome_index]["arguments"][j] == "constructor":
function = "constructor"
data += self.generator.bytecode
elif not type(self.chromosome[chromosome_index]["arguments"][j]) is bytearray and \
not type(self.chromosome[chromosome_index]["arguments"][j]) is list and \
self.chromosome[chromosome_index]["arguments"][j] in self.generator.interface:
function = self.chromosome[chromosome_index]["arguments"][j]
data += self.chromosome[chromosome_index]["arguments"][j]
else:
arguments.append(self.chromosome[chromosome_index]["arguments"][j])
try:
argument_types = [argument_type.replace(" storage", "").replace(" memory", "") for argument_type in self.generator.interface[function]]
data += encode_abi(argument_types, arguments).hex()
except Exception as e:
self.logger.error("%s", e)
self.logger.error("%s: %s -> %s", function, self.generator.interface[function], arguments)
sys.exit(-6)
return data
def signAndExecute(inst, helper, signers, action, opts={}):
nonce_slot = int(inst.address, 16) + 1
nonce = int(web3.eth.getStorageAt(inst.address, nonce_slot).hex(), 16)
# encode data for delegatecall to helper contract
forward_data = helper.call.encode_input(action.target, action.value,
action.data)
hash_data = web3.solidityKeccak(['bytes'], [forward_data])
struct_preimg = encode_abi(
['bytes32', 'uint256', 'address', 'uint256', 'bytes32'],
[
bytes.fromhex(YUL_TYPEHASH[2:]),
nonce,
helper.address, # delegatecall goes to the helper contract
action.gas,
hash_data
])
hash_struct = web3.keccak(struct_preimg)
digest = web3.solidityKeccak(
['bytes1', 'bytes1', 'bytes32', 'bytes32'],
['0x19', '0x01',
bytes.fromhex(YUL_DOMAIN_SEPARATOR[2:]), hash_struct])
sigs = allSignUnpacked(signers, digest)
return inst.execute(helper.address, action.gas, forward_data, sigs)
def create_callback(msg_hex, sig_hex):
msg_bytes = Web3.toBytes(hexstr=msg_hex)
sig_bytes = Web3.toBytes(hexstr=sig_hex)
ec_recover_args = (msg_bytes, sig_bytes)
encoded_abi = eth_abi.encode_abi(['bytes', 'bytes'], ec_recover_args)
return Web3.toHex(encoded_abi)
async def test_responder_receive_timeout(config):
if not ENABLE_THIS_TESTS:
return
(contract_minter, contract_address, contract_abi, url,
port) = setUp(config, 'left')
w3 = Web3(Web3.HTTPProvider(url + ":" + str(port)))
token_instance = w3.eth.contract(abi=contract_abi,
address=contract_address)
(tokenId, cost) = await create_token(contract_minter, token_instance, w3)
assert token_instance.functions.getStateOfToken(tokenId).call() == 0
### Test Ethereum Responder ###
resp = EthereumResponder(contract_minter,
contract_address,
contract_abi,
url,
port=port)
data = encode_abi(['uint256'], [tokenId])
nonce = "42"
resp.timeout = 0
result = await resp.send_data(nonce, data)
assert result["status"] == False
assert result["error_code"] == ErrorCode.TIMEOUT
def generate_data(dataset_address, key, price, timestamp):
V, R, S = [], [], []
for pk in PROVIDER_PKS.split(","):
v, r, s = sign_aggregate(
dataset_address, str.encode(key), price, timestamp, 1, pk
)
V.append(v)
R.append(r)
S.append(s)
return (
"0x"
+ (
function_signature_to_4byte_selector(
"report(bytes,uint256,uint64,uint8,uint8[],bytes32[],bytes32[])"
)
+ encode_abi(
[
"bytes",
"uint256",
"uint64",
"uint8",
"uint8[]",
"bytes32[]",
"bytes32[]",
],
[str.encode(key), price, timestamp, 1, V, R, S],
)
).hex()
)
def _verify_token_networks(chain_id: ChainID, apikey: str) -> None:
deployment_file_path = contracts_deployed_path(chain_id=chain_id)
with deployment_file_path.open() as f:
deployed_contracts_info = json.load(f)
token_networks = deployed_contracts_info.get("token_networks", [])
with open(contracts_precompiled_path()) as f:
contract_dict = json.load(f)["contracts"][CONTRACT_TOKEN_NETWORK]
metadata = json.loads(contract_dict["metadata"])
constructor = [
func for func in contract_dict["abi"] if func["type"] == "constructor"
][0]
arg_types = [arg["type"] for arg in constructor["inputs"]]
arg_names = [arg["name"] for arg in constructor["inputs"]]
for tn in token_networks:
args = [
tn["constructor_arguments"][arg_name] for arg_name in arg_names
]
etherscan_verify_contract(
chain_id=chain_id,
apikey=apikey,
address=tn["token_network_address"],
contract_name=CONTRACT_TOKEN_NETWORK,
metadata=metadata,
constructor_args=encode_abi(arg_types, args).hex(),
)
def get_constructor_arguments(contract: Contract,
args: Optional[list] = None,
kwargs: Optional[dict] = None):
"""Get constructor arguments for Etherscan verify.
https://etherscanio.freshdesk.com/support/solutions/articles/16000053599-contract-verification-constructor-arguments
"""
# return contract._encode_constructor_data(args=args, kwargs=kwargs)
constructor_abi = get_constructor_abi(contract.abi)
# constructor_abi can be none in case of libraries
if constructor_abi is None:
return to_hex(contract.bytecode)
if args is not None:
return contract.encodeABI(constructor_abi['name'], args)[2:] # No 0x
else:
constructor_abi = get_constructor_abi(contract.abi)
kwargs = kwargs or {}
arguments = merge_args_and_kwargs(constructor_abi, [], kwargs)
# deploy_data = add_0x_prefix(
# contract._encode_abi(constructor_abi, arguments)
# )
# TODO: Looks like recent Web3.py ABI change
deploy_data = encode_abi(contract.web3, constructor_abi, arguments)
return deploy_data
def queue_upgrade(self, proxyAddress, newLogicAddress,
delay=2 * days(2)) -> str:
target = self.devProxyAdmin.address
signature = "upgrade(address,address)"
data = encode_abi(["address", "address"],
[proxyAddress, newLogicAddress])
eta = web3.eth.getBlock("latest")["timestamp"] + delay
return self.governance_queue_transaction(target, signature, data, eta)
def generate_signature(symbol, timestamp, value, private_key):
message = encode_abi(
["string", "uint64", "string", "uint64"],
["prices",
int(timestamp), symbol,
int(float(value) * 1000000)],
)
# // This part prepares "version E" messages, using the EIP-191 standard
sign_message = messages.encode_defunct(keccak(message))
# // This part signs any EIP-191-valid message
signed_message = Account.sign_message(sign_message,
private_key=private_key)
return message, encode_abi(
["uint256", "uint256", "uint256"],
[signed_message.r, signed_message.s, signed_message.v],
)
def deriveAPK(ask):
# a_pk = sha256(a_sk || 0^256)
zeroes = "0000000000000000000000000000000000000000000000000000000000000000"
a_pk = hashlib.sha256(
encode_abi(
["bytes32", "bytes32"],
[bytes.fromhex(ask), bytes.fromhex(zeroes)])).hexdigest()
return a_pk
def test_contract_constructor_encoding_encoding(
WithConstructorArgumentsContract, bytes_arg):
deploy_data = WithConstructorArgumentsContract._encode_constructor_data(
[1234, bytes_arg])
encoded_args = '0x00000000000000000000000000000000000000000000000000000000000004d26162636400000000000000000000000000000000000000000000000000000000' # noqa: E501
expected_ending = encode_hex(
encode_abi(['uint256', 'bytes32'], [1234, b'abcd']))
assert expected_ending == encoded_args
assert deploy_data.endswith(remove_0x_prefix(expected_ending))
def _pack_data(self, func_name, input_types, input_values):
try:
data = self.func_hashes[func_name]
except:
raise Exception('Unknown method')
if input_types is not None:
data += self.encode_hex(encode_abi(input_types,
input_values))[0].decode()
return data
def test_encode_abi(type_str, python_value, abi_encoding, _):
abi_type = parse(type_str)
if abi_type.arrlist is not None:
pytest.skip('ABI coding functions do not support array types')
types = [str(t) for t in abi_type.components]
actual = encode_abi(types, python_value)
assert actual == abi_encoding
def encode_nodes(accounts):
encoded_accounts = []
for index in range(0, len(accounts)):
data = accounts[index]
encoded = encode_hex(
encode_abi(["uint256", "address", "uint256"],
(index, data["account"], data["score"])))
encoded_accounts.append(encoded)
return encoded_accounts
def onRequestBuy(event):
# print(event)
user = event.args["buyer"]
keys = masterfile_contract.functions.userKeys(user).call()
tokenId = event.args["tokenId"]
token = masterfile_contract.functions.tokenData(tokenId).call()
uri = token[1]
label = token[2]
print(user)
print(token)
global globalStorage
# Call token transfer
# using fake policy id
compiled_data = encode_abi(['bytes16', 'uint256', 'string', 'address[]'], [
Random.new().read(16), 432000, label,
[
"0x9920328f8D239613cDfFea4578e37d843772738F",
"0xf71C4fbb1D0a85ded90c58fF347a026E6b8146AC",
"0xC11F4fAa477b1634369153c8654eEF581425AD15"
]
])
masterfile_contract.functions.safeTransferFrom(
token[0], user, tokenId, 1,
compiled_data).transact({'from': w3.eth.accounts[0]})
# Revoke old policy
try:
if globalStorage[uri]["policy"]:
alice.revoke(globalStorage[uri]["policy"])
print("Policy Revoked")
except:
print("No Policy")
# Distribute kfrags
# try:
print(keys)
bob = Bob.from_public_keys(verifying_key=keys[0],
encrypting_key=keys[1],
federated_only=True)
policy = alice.grant(bob,
label=uri.encode(),
m=2,
n=3,
expiration=maya.now() + timedelta(days=5))
temp = globalStorage[uri]
temp["policy"] = policy
globalStorage[uri] = temp
# except:
# print("policy exsists")
policy.treasure_map_publisher.block_until_complete()
print("Policy {} was created".format(label))
def hash_integers(values):
k = bytes(32)
for i in range(0,len(values)):
k1 = int(values[i]).to_bytes(32, byteorder='big')
v = encode_abi(['bytes32','bytes32'],[k,k1])
k = hashlib.sha256(v).digest()
return bytes_to_int(k)
def encode_params(datatypes: list, values: list) -> str:
for idx, item in enumerate(datatypes):
if item == 'address':
if isinstance(values[idx], int):
values[idx] = bytecode_to_bytes(hex(values[idx]))
elif isinstance(values[idx], str):
values[idx] = bytecode_to_bytes(values[idx])
return encode_abi(datatypes, values).hex()
def test_multi_abi_reversibility(types_and_values):
"""
Tests round trip encoding and decoding for basic types and lists of basic
types.
"""
types, values = types_and_values
encoded_values = encode_abi(types, values)
decoded_values = decode_abi(types, encoded_values)
assert values == decoded_values
def test_multi_abi_reversibility(types_and_values):
"""
Tests round trip encoding and decoding for basic types and lists of basic
types.
"""
types, values = types_and_values
encoded_values = encode_abi(types, values)
decoded_values = decode_abi(types, encoded_values)
assert values == decoded_values
def impl(self, seq, *args):
if len(args) != len(func_abi["inputs"]):
raise Exception(
"Function with abi {} passed not matching {} args".format(
func_abi, list(args)))
encoded_input = func_id + eth_abi.encode_abi(
[inp["type"] for inp in func_abi["inputs"]], list(args))
msg_data = sized_byterange.frombytes(encoded_input)
return value.Tuple([msg_data, address, seq])
def _encodeABI(cls, abi, arguments, data=None):
arguent_types = get_abi_input_types(abi)
encoded_arguments = encode_abi(arguent_types, force_obj_to_bytes(arguments))
if data:
return add_0x_prefix(
force_bytes(remove_0x_prefix(data)) +
force_bytes(remove_0x_prefix(encode_hex(encoded_arguments)))
)
else:
return encode_hex(encoded_arguments)
def test_wrong_type_match_data():
data = ("hello", "goodbye")
match_data_and_abi = (
("string", (50505050,)),
("string", (50505050,)),
)
abi_types, match_data = zip(*match_data_and_abi)
encoded_data = encode_abi(abi_types, data)
with pytest.raises(ValueError):
match_fn(match_data_and_abi, encoded_data)
def test_always_positive_multi(_type, value):
"""
Tests round trip encoding and decoding for basic types and lists of basic
types.
"""
assert value >= 0
encoded_value = encode_abi([_type], [value])
decoded_value = decode_abi([_type], encoded_value)
assert decoded_value[0] >= 0
def _encode_abi(cls, abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types),
)
)
try:
normalizers = [
abi_ens_resolver(cls.web3),
abi_address_to_hex,
abi_bytes_to_hex,
abi_string_to_hex,
hexstrs_to_bytes,
]
normalized_arguments = map_abi_data(
normalizers,
argument_types,
arguments,
)
encoded_arguments = encode_abi(
argument_types,
normalized_arguments,
)
except EncodingError as e:
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type: {0}".format(str(e))
)
if data:
return to_hex(HexBytes(data) + encoded_arguments)
else:
return encode_hex(encoded_arguments)
def test_encode_multiple_arguments(types, value, expected):
actual = encode_abi(types, value)
assert actual == expected
def test_encode_array_types(types, value, expected):
actual = encode_abi(types, value)
assert actual == expected
def test_contract_constructor_encoding_encoding(WithConstructorArgumentsContract, bytes_arg):
deploy_data = WithConstructorArgumentsContract._encode_constructor_data([1234, bytes_arg])
encoded_args = '0x00000000000000000000000000000000000000000000000000000000000004d26162636400000000000000000000000000000000000000000000000000000000' # noqa: E501
expected_ending = encode_hex(encode_abi(['uint256', 'bytes32'], [1234, b'abcd']))
assert expected_ending == encoded_args
assert deploy_data.endswith(remove_0x_prefix(expected_ending))
def test_match_fn_with_various_data_types(data, expected, match_data_and_abi):
abi_types, match_data = zip(*match_data_and_abi)
encoded_data = encode_abi(abi_types, data)
assert match_fn(match_data_and_abi, encoded_data) == expected
