def test_invalid_ss58_format_range_exceptions(self): with self.assertRaises(ValueError) as cm: ss58_encode(self.alice_keypair.public_key, ss58_format=-1) self.assertEqual('Invalid value for ss58_format', str(cm.exception)) with self.assertRaises(ValueError) as cm: ss58_encode(self.alice_keypair.public_key, ss58_format=16384) self.assertEqual('Invalid value for ss58_format', str(cm.exception))
def test_invalid_reserved_ss58_format(self): with self.assertRaises(ValueError) as cm: ss58_encode(self.alice_keypair.public_key, ss58_format=46) self.assertEqual('Invalid value for ss58_format', str(cm.exception)) with self.assertRaises(ValueError) as cm: ss58_encode(self.alice_keypair.public_key, ss58_format=47) self.assertEqual('Invalid value for ss58_format', str(cm.exception))
def test_encode_with_2_byte_prefix(self): public_key = ss58_decode('5GoKvZWG5ZPYL1WUovuHW3zJBWBP5eT8CbqjdRY4Q6iMaQua') self.assertEqual( 'yGHU8YKprxHbHdEv7oUK4rzMZXtsdhcXVG2CAMyC9WhzhjH2k', ss58_encode(public_key, ss58_format=255) )
def test_contract_event_decoding(self): contract_event_data = '0x0001d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d018eaf04151687' + \ '736326c9fea17e25fc5287613693c912909cb226aa4794f26a480000a7dcf75015000000000000000000' contract_event_obj = ContractEvent( data=ScaleBytes(contract_event_data), runtime_config=self.substrate.runtime_config, contract_metadata=self.contract_metadata) contract_event_obj.decode() self.assertEqual('5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY', ss58_encode(contract_event_obj.args[0]['value'], 42)) self.assertEqual('5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty', ss58_encode(contract_event_obj.args[1]['value'], 42)) self.assertEqual(6000000000000000, contract_event_obj.args[2]['value'])
def show_extrinsics_of_block(substrate, bh=None): # Set block_hash to None for chaintip """ variation of https://github.com/polkascan/py-substrate-interface/blob/master/README.md#get-extrinsics-for-a-certain-block """ # Retrieve extrinsics in block result = substrate.get_runtime_block(block_hash=bh) for extrinsic in result['block']['extrinsics']: if 'account_id' in extrinsic: signed_by_address = ss58_encode(address=extrinsic['account_id'], address_type=2) else: signed_by_address = None print('\n{}.{} Signer={}'.format(extrinsic['call_module'], extrinsic['call_function'], signed_by_address), end=". ") # Loop through params numParams = len(extrinsic['params']) if numParams: print("Param/s: ", end="") for i, param in enumerate(extrinsic['params']): if param['type'] == 'Address': param['value'] = ss58_encode(address=param['value'], address_type=2) if param['type'] == 'Compact<Balance>': param['value'] = '{} DOT'.format(param['value'] / 10**12) print("{}={}".format(param['name'], param['value']), end="") if i + 1 < numParams: print(", ") print()
def get_escrow_address(addresses: list, *, threshold: int = 2): _addresses = [] for addr in addresses: _addr = ss58_decode(addr) _addr = bytes.fromhex(_addr) _addresses.append(_addr) _addresses = sorted(_addresses) print(_addresses) escrow_addr = multisig.multi_account_id(_addresses, threshold) escrow_addr = binascii.hexlify(bytearray(escrow_addr)).decode("ascii") return ss58_encode(escrow_addr, 2)
def setUp(self): self.buyer_address = ss58_encode(buyer_keypair[0], 2) self.seller_address = ss58_encode(seller_keypair[0], 2) self.admin_address = ss58_encode(admin_keypair[0], 2) self.seller_priv = seller_keypair[1].hex() self.seller_pub = ss58_decode(self.seller_address) self.admin_priv = admin_keypair[1].hex() self.admin_pub = ss58_decode(self.admin_address) substrate.init_runtime(block_hash=None) # Prepare the inner call as we will reuse it, lets not write code twice self.inner_call = ScaleDecoder.get_decoder_class( "Call", metadata=substrate.metadata_decoder) self.inner_call.encode({ "call_module": "Balances", "call_function": "transfer", "call_args": { "dest": self.buyer_address, "value": settings.trade_value, }, })
def check_transfer_config( config: 'bittensor.Config'): if config.subtensor.network == bittensor.defaults.subtensor.network and not config.no_prompt: config.subtensor.network = Prompt.ask("Enter subtensor network", choices=bittensor.__networks__, default = bittensor.defaults.subtensor.network) if config.wallet.name == bittensor.defaults.wallet.name and not config.no_prompt: wallet_name = Prompt.ask("Enter wallet name", default = bittensor.defaults.wallet.name) config.wallet.name = str(wallet_name) # Get destination. if not config.dest: dest = Prompt.ask("Enter destination public key: (ss58 or ed2519)") if len(dest) == 48: try: ss58_decode(dest) config.dest = str(dest) except ValueError: console.print(":cross_mark:[red] Invalid public key format[/red] [bold white]{}[/bold white]".format(dest)) sys.exit() elif len(dest) == 66 or len(dest) == 64: try: ss58_encode(dest) config.dest = str(dest) except ValueError: console.print(":cross_mark:[red] Invalid ss58 address format[/red] [bold white]{}[/bold white]".format(dest)) sys.exit() else: console.print(":cross_mark:[red] Invalid address format[/red] [bold white]{}[/bold white]".format(dest)) sys.exit() # Get amount. if not config.amount: amount = Prompt.ask("Enter Tao amount to transfer") try: config.amount = float(amount) except ValueError: console.print(":cross_mark:[red] Invalid Tao amount[/red] [bold white]{}[/bold white]".format(amount)) sys.exit()
def get_nominators(): prefix = substrate.generate_storage_hash("Staking", "Nominators") pairs = substrate.rpc_request(method="state_getPairs", params=[prefix, head])['result'] nominators = list( map( lambda p: ("0x" + p[0][-64:], substrate.decode_scale("Nominations<AccountId>", p[1])[ 'targets']), pairs)) nominators = list( map(lambda x: ( ss58_encode(x[0], substrate.address_type), x[1], ), nominators)) return list( map( lambda x: ( x[0], get_backing_stake_of(x[0]), [ss58_encode(acc, substrate.address_type) for acc in x[1]], ), nominators))
def deserialize_keypair_from_keyfile_data( keyfile_data: bytes) -> 'bittensor.Keypair': """ Deserializes Keypair object from passed keyfile data. Args: keyfile_data ( bytest, required ): Keyfile data as bytes to be loaded. Returns: keypair (bittensor.Keypair): Keypair loaded from bytes. Raises: KeyFileError: Raised if the passed bytest cannot construct a keypair object. """ # Decode from json. keyfile_data = keyfile_data.decode() try: keyfile_dict = dict(json.loads(keyfile_data)) except: string_value = str(keyfile_data) if string_value[:2] == "0x": string_value = ss58_encode(string_value) keyfile_dict = { 'accountId': None, 'publicKey': None, 'secretPhrase': None, 'secretSeed': None, 'ss58Address': string_value } else: raise KeyFileError( 'Keypair could not be created from keyfile data: {}'.format( string_value)) if "secretSeed" in keyfile_dict and keyfile_dict['secretSeed'] != None: return Keypair.create_from_seed(keyfile_dict['secretSeed']) if "secretPhrase" in keyfile_dict and keyfile_dict['secretPhrase'] != None: return Keypair.create_from_mnemonic( mnemonic=keyfile_dict['secretPhrase']) if "ss58Address" in keyfile_dict and keyfile_dict['ss58Address'] != None: return Keypair(ss58_address=keyfile_dict['ss58Address']) else: raise KeyFileError( 'Keypair could not be created from keyfile data: {}'.format( keyfile_dict))
def get_backing_stake_of(who): ctrl = substrate.get_runtime_state( module="Staking", storage_function="Bonded", params=[who], block_hash=head, )['result'] ctrl = ss58_encode(ctrl, substrate.address_type) ledger = substrate.get_runtime_state( module="Staking", storage_function="Ledger", params=[ctrl], block_hash=head, )['result'] return ledger['active']
def test_create_escrow_address(self): buyer_addr = "CdVuGwX71W4oRbXHsLuLQxNPns23rnSSiZwZPN4etWf6XYo" seller_addr = "J9aQobenjZjwWtU2MsnYdGomvcYbgauCnBeb8xGrcqznvJc" admin_addr = "HvqnQxDQbi3LL2URh7WQfcmi8b2ZWfBhu7TEDmyyn5VK8e2" def kusama_addr_to_account_id(address): decoded_addr = ss58_decode(address) decoded_addr_bytes = bytes.fromhex(decoded_addr) return decoded_addr_bytes buyer_id = kusama_addr_to_account_id(buyer_addr) seller_id = kusama_addr_to_account_id(seller_addr) admin_id = kusama_addr_to_account_id(admin_addr) trade_addresses = sorted([buyer_id, seller_id, admin_id]) escrow_addr = multisig.multi_account_id(trade_addresses, 2) escrow_addr = binascii.hexlify(bytearray(escrow_addr)).decode("ascii") # This address was manually generated from the Polkadot UI app expected_address = "HFXXfXavDuKhLLBhFQTat2aaRQ5CMMw9mwswHzWi76m6iLt" self.assertEqual(ss58_encode(escrow_addr, 2), expected_address)
def test_chrome_extension_mnemonic(self): mnemonic = ("prefer fashion insect dizzy energy marble" " forget artefact aspect short surface leave") seed_array = bip39.bip39_to_mini_secret(mnemonic, "") seed = binascii.hexlify(bytearray(seed_array)).decode("ascii") seed_from_mnemonic = ( "3f686928bda5b57a0992c999aea74d65f844be234686871a2ddc6b003d586786") self.assertEqual(seed, seed_from_mnemonic) expected_publickey = ( "8852f77f2aea5d2d5808cefa7cd49a3ed0ce1f1aa8ff2564c3cb96cb2510337d") keypair = sr25519.pair_from_seed(bytes.fromhex(seed_from_mnemonic)) public_key = keypair[0].hex() self.assertEqual(public_key, expected_publickey) expected_address = "Ff4gBd7WcHgsNVhr5HGPQXQx4PzPHGtHdNVaCRK5d5KeMHh" address = ss58_encode(keypair[0], 2) self.assertEqual(address, expected_address)
def test_encode_2_bytes_account_index(self): self.assertEqual('3xygo', ss58_encode_account_index(256, ss58_format=2)) self.assertEqual('3xygo', ss58_encode('0x0001', ss58_format=2))
def test_encode_1_byte_account_index_with_format(self): self.assertEqual('g4b', ss58_encode_account_index(1, ss58_format=2)) self.assertEqual('g4b', ss58_encode('0x01', ss58_format=2))
def test_invalid_public_key(self): with self.assertRaises(ValueError) as cm: ss58_encode(self.alice_keypair.public_key[:30]) self.assertEqual('Invalid length for address', str(cm.exception))
import binascii from substrateinterface.utils.ss58 import ss58_decode from substrateinterface.utils.ss58 import ss58_encode from bindings import multisig buyer_addr = "FQ2W1LrE9u6hrgv9bZzy3zq7e3JARRZm3d3UvnMREmAZCBb" seller_addr = "DUorqgcRkXhpQvfhsXfjSZVNWRJWE5qGo7md53Cpix8BRnb" admin_addr = "D3JaNpndKAG8PMZnsvsNE7UemYpVs44PB6kCHxW4wNSkxZh" def kusama_addr_to_account_id(address): decoded_addr = ss58_decode(address) decoded_addr_bytes = bytes.fromhex(decoded_addr) return decoded_addr_bytes buyer_id = kusama_addr_to_account_id(buyer_addr) seller_id = kusama_addr_to_account_id(seller_addr) admin_id = kusama_addr_to_account_id(admin_addr) trade_addresses = sorted([buyer_id, seller_id, admin_id]) escrow_addr = multisig.multi_account_id(trade_addresses, 2) escrow_addr = binascii.hexlify(bytearray(escrow_addr)).decode("ascii") escrow_addr = ss58_encode(escrow_addr, 2) print(escrow_addr)
def format_address(self, item): item['orig_value'] = item['value'].replace('0x', '') item['value'] = ss58_encode(item['value'].replace('0x', ''), SUBSTRATE_ADDRESS_TYPE) return item
def test_invalid_ss58_format_range_exceptions(self): with self.assertRaises(ValueError): ss58_encode(self.alice_keypair.public_key, ss58_format=-1) ss58_encode(self.alice_keypair.public_key, ss58_format=16384)
def test_encode_33_byte_address(self): self.assertEqual( 'KWCv1L3QX9LDPwY4VzvLmarEmXjVJidUzZcinvVnmxAJJCBou', ss58_encode('0x03b9dc646dd71118e5f7fda681ad9eca36eb3ee96f344f582fbe7b5bcdebb13077') )
def decompose_seed(seed): keypair = sr25519.pair_from_seed(bytes.fromhex(seed)) public_key = keypair[0].hex() private_key = keypair[1].hex() address = ss58_encode(keypair[0], 2) return address, public_key, private_key
def get_candidates(): prefix = substrate.generate_storage_hash("Staking", "Validators") pairs = substrate.rpc_request(method="state_getPairs", params=[prefix, head])['result'] last_32_bytes = list(map(lambda p: "0x" + p[0][-64:], pairs)) return list(map(lambda k: ss58_encode(k), last_32_bytes))
def test_invalid_public_key(self): with self.assertRaises(ValueError): ss58_encode(self.alice_keypair.public_key[:30])
def test_invalid_reserved_ss58_format(self): with self.assertRaises(ValueError): ss58_encode(self.alice_keypair.public_key, ss58_format=46) ss58_encode(self.alice_keypair.public_key, ss58_format=47)
def test_encode_4_bytes_account_index(self): self.assertEqual('zswfoZa', ss58_encode_account_index(67305985, ss58_format=2)) self.assertEqual('zswfoZa', ss58_encode('0x01020304', ss58_format=2))
def example_calls(substrate, account, block_hash=None): """ Set block_hash to None for chaintip """ # version information via node request rv=substrate.rpc_request(method="chain_getRuntimeVersion", params=[])["result"] v= substrate.get_version() print("implName=%s, transactionVersion=%s, versiontag=%s" %(rv['implName'], rv['transactionVersion'], v) ) # Retrieve extrinsics in block result = substrate.get_runtime_block(block_hash=block_hash) for extrinsic in result['block']['extrinsics']: if 'account_id' in extrinsic: signed_by_address = ss58_encode(address=extrinsic['account_id'], address_type=2) else: signed_by_address = None print('\nModule: {}\nCall: {}\nSigned by: {}'.format( extrinsic['call_module'], extrinsic['call_function'], signed_by_address )) for param in extrinsic['params']: if param['type'] == 'Address': param['value'] = ss58_encode(address=param['value'], address_type=2) if param['type'] == 'Compact<Balance>': param['value'] = '{} DOT'.format(param['value'] / 10**12) print("Param '{}': {}".format(param['name'], param['value'])) # Storage call examples print("\n\nCurrent Account info: {} DOT".format( substrate.get_runtime_state( module='System', storage_function='Account', params=[account] ).get('result') )) try: print("Balance @ {}: {} DOT".format( block_hash, substrate.get_runtime_state( module='Balances', storage_function='FreeBalance', params=[account], block_hash=block_hash ).get('result') )) except Exception as e: print ("ERROR: %s %s" %(type(e), e)) # Create, sign and submit extrinsic example mnemonic = Keypair.generate_mnemonic() keypair = Keypair.create_from_mnemonic(mnemonic, 2) print("Created address: {}".format(keypair.ss58_address)) call = substrate.compose_call( call_module='Balances', call_function='transfer', call_params={ 'dest': account, 'value': 2 * 10**3 } ) extrinsic = substrate.create_signed_extrinsic(call=call, keypair=keypair) try: # result = substrate.send_extrinsic(extrinsic) result = substrate.submit_extrinsic(extrinsic, wait_for_inclusion=True) print('Extrinsic "{}" included in block "{}"'.format( result['extrinsic_hash'], result.get('block_hash') )) except SubstrateRequestException as e: print("Failed to send: {}".format(e))
def test_encode_8_bytes_account_index(self): self.assertEqual('848Gh2GcGaZia', ss58_encode('0x2a2c0a0000000000', ss58_format=2))
def test_encode_subkey_generated_pairs(self): for subkey_pair in self.subkey_pairs: self.assertEqual( subkey_pair['address'], ss58_encode(address=subkey_pair['public_key'], ss58_format=subkey_pair['ss58_format']) )
def get_addr_from_seed(seed: str,): keypair = sr25519.pair_from_seed(bytes.fromhex(seed)) return ss58_encode(keypair[0], 2)
from substrateinterface.utils.ss58 import ss58_encode substrate = SubstrateInterface(url="wss://kusama-rpc.polkadot.io/", ss58_format=2, type_registry_preset='kusama') # Set block_hash to None for chaintip block_hash = "0x588930468212316d8a75ede0bec0bc949451c164e2cea07ccfc425f497b077b7" # Retrieve extrinsics in block result = substrate.get_runtime_block(block_hash=block_hash) for extrinsic in result['block']['extrinsics']: if 'account_id' in extrinsic: signed_by_address = ss58_encode(address=extrinsic['account_id'], ss58_format=2) else: signed_by_address = None print('\nModule: {}\nCall: {}\nSigned by: {}'.format( extrinsic['call_module'], extrinsic['call_function'], signed_by_address)) for param in extrinsic['params']: if param['type'] == 'Address': param['value'] = ss58_encode(address=param['value'], ss58_format=2) if param['type'] == 'Compact<Balance>': param['value'] = '{} DOT'.format(param['value'] / 10**12)