def test_verify_challenge_tx_contains_infinite_timebounds(self):
server_kp = Keypair.random()
client_kp = Keypair.random()
timeout = 600
network = 'TESTNET'
archor_name = 'sdf'
challenge = Builder(server_kp.seed().decode(),
network=network,
sequence=-1,
fee=100)
now = int(time.time())
challenge.add_time_bounds({'minTime': now, 'maxTime': 0})
nonce = os.urandom(64)
challenge.append_manage_data_op(
data_name='{} auth'.format(archor_name),
data_value=nonce,
source=client_kp.address().decode())
challenge.sign()
challenge_tx_server_signed = challenge.gen_xdr()
transaction = Builder(client_kp.seed().decode(),
network='TESTNET',
sequence=0,
fee=100)
transaction.import_from_xdr(challenge_tx_server_signed)
transaction.sign()
challenge_tx = transaction.gen_xdr()
with pytest.raises(
InvalidSep10ChallengeError,
match="Transaction requires non-infinite timebounds."):
Builder.verify_challenge_tx(challenge_tx,
server_kp.address().decode(),
'TESTNET')
def data( systemdb, Account, name, message): q = Query() a_sk = systemdb.search(q.name == Account)[0]['sk'] b = Builder(secret = a_sk, network='TESTNET') b.append_manage_data_op(name, message) b.sign() print b.submit()
def make_data_entry( systemdb, source_name, key, value): q = Query() a_sk = systemdb.search(q.name == source_name)[0]['sk'] b = Builder(secret = a_sk, network='TESTNET') b.append_manage_data_op(name, message) b.sign() response = b.submit() print response
def create_token_and_lock_account(self, code, owner_address, metadata):
# Setup the base transaction
builder = Builder(
secret=self.issuer_secret,
network=self.network
)
# Append relevant payment ops
ipfs_hash = self.create_ipfs_hash(metadata)
builder.append_manage_data_op('token_ipfs_hash', ipfs_hash)
builder.append_payment_op(
owner_address,
'0.0000001',
code,
self.issuer_keypair.address().decode()
)
builder.append_set_options_op(master_weight=0)
builder.sign()
return builder.submit()
def test_verify_challenge_tx_operation_value_is_not_a_64_bytes_base64_string(
self):
server_kp = Keypair.random()
client_kp = Keypair.random()
timeout = 600
network = 'TESTNET'
archor_name = 'sdf'
challenge = Builder(server_kp.seed().decode(),
network=network,
sequence=-1,
fee=100)
now = int(time.time())
challenge.add_time_bounds({'minTime': now, 'maxTime': now + timeout})
nonce = os.urandom(32)
challenge.append_manage_data_op(
data_name='{} auth'.format(archor_name),
data_value=nonce,
source=client_kp.address().decode())
challenge.sign()
challenge_tx_server_signed = challenge.gen_xdr()
transaction = Builder(client_kp.seed().decode(),
network='TESTNET',
sequence=0,
fee=100)
transaction.import_from_xdr(challenge_tx_server_signed)
transaction.sign()
challenge_tx = transaction.gen_xdr()
with pytest.raises(
InvalidSep10ChallengeError,
match=
"Operation value should be a 64 bytes base64 random string."):
Builder.verify_challenge_tx(challenge_tx,
server_kp.address().decode(),
'TESTNET')
async def build_generate_escrow_wallet_transaction(
escrow_address: str,
transaction_source_address: str,
creator_address: str,
destination_address: str,
provider_address: str,
cost_per_transaction: Decimal,
starting_native_asset: Decimal,
starting_custom_asset: Decimal,
expiration_date: str = None,
sequence: str = None,
) -> Tuple[Any, str]:
'''Building transaction for generating escrow wallet with minimum balance of lumens
and return unsigned XDR and transaction hash.
Args:
* escrow_address: an address of new wallet
* destination_address: an address of wallet which is target
* transaction_source_address an address from wallet pool
* provider_address: an address which provides custom_asset to new wallet
* creator_address: an address of source wallet which is owner of the transaction.
* cost_per_transaction: cost for each promotion deals.
* starting_native_asset: starting amount of XLM.
* starting_custom_asset: starting amount of custom asset(HOT).
* expiration_date: a date when escrow address is terminated.
'''
builder = Builder(
address=transaction_source_address,
horizon=settings['HORIZON_URL'],
network=settings['PASSPHRASE'],
sequence=sequence,
)
builder.append_create_account_op(source=creator_address,
destination=escrow_address,
starting_balance=starting_native_asset)
try:
builder.append_trust_op(
source=escrow_address,
destination=settings['ISSUER'],
code=settings['ASSET_CODE'],
limit=settings['LIMIT_ASSET'],
)
except DecodeError:
raise web.HTTPBadRequest(
reason='Parameter escrow_address or issuer address are not valid.')
except Exception as e:
msg = str(e)
raise web.HTTPInternalServerError(reason=msg)
builder.append_manage_data_op(source=escrow_address,
data_name='creator_address',
data_value=creator_address)
builder.append_manage_data_op(source=escrow_address,
data_name='destination_address',
data_value=destination_address)
builder.append_manage_data_op(source=escrow_address,
data_name='provider_address',
data_value=provider_address)
if expiration_date:
builder.append_manage_data_op(source=escrow_address,
data_name='expiration_date',
data_value=expiration_date)
builder.append_manage_data_op(source=escrow_address,
data_name='cost_per_transaction',
data_value=str(cost_per_transaction))
builder.append_set_options_op(source=escrow_address,
signer_address=creator_address,
signer_type='ed25519PublicKey',
signer_weight=1)
builder.append_set_options_op(source=escrow_address,
signer_address=provider_address,
signer_type='ed25519PublicKey',
signer_weight=1)
builder.append_set_options_op(source=escrow_address,
master_weight=0,
low_threshold=2,
med_threshold=2,
high_threshold=2)
builder.append_payment_op(
source=provider_address,
destination=escrow_address,
asset_code=settings['ASSET_CODE'],
asset_issuer=settings['ISSUER'],
amount=starting_custom_asset,
)
try:
xdr = builder.gen_xdr()
except Exception as e:
raise web.HTTPBadRequest(
reason='Bad request, Please ensure parameters are valid.')
tx_hash = builder.te.hash_meta()
return xdr.decode(), binascii.hexlify(tx_hash).decode()
async def build_joint_wallet(
transaction_source_address: str,
deal_address: str,
parties: List,
creator: str,
starting_xlm: Decimal,
meta: str = None,
sequence: str = None,
):
"""Build transaction for create joint wallet, trust HOT and set option signer."""
def _add_signer(builder: Builder, deal_address: str, party: str,
amount: Decimal):
"""Set permission of parties can signed transaction that generate from joint account"""
builder.append_set_options_op(source=deal_address,
signer_address=party,
signer_type='ed25519PublicKey',
signer_weight=1)
builder.append_payment_op(
source=party,
destination=deal_address,
asset_code=settings['ASSET_CODE'],
asset_issuer=settings['ISSUER'],
amount=amount,
)
builder = Builder(
address=transaction_source_address,
horizon=settings['HORIZON_URL'],
network=settings['PASSPHRASE'],
sequence=sequence,
)
builder.append_create_account_op(source=creator,
destination=deal_address,
starting_balance=starting_xlm)
builder.append_trust_op(source=deal_address,
destination=settings['ISSUER'],
code=settings['ASSET_CODE'],
limit=settings['LIMIT_ASSET'])
builder.append_set_options_op(source=deal_address,
signer_address=creator,
signer_type='ed25519PublicKey',
signer_weight=1)
for party in parties:
_add_signer(builder, deal_address, party['address'], party['amount'])
if meta and isinstance(meta, dict):
for key, value in meta.items():
builder.append_manage_data_op(source=deal_address,
data_name=key,
data_value=value)
builder.append_manage_data_op(source=deal_address,
data_name='creator_address',
data_value=creator)
weight = len(parties) + 1
builder.append_set_options_op(source=deal_address,
master_weight=0,
low_threshold=weight,
med_threshold=weight,
high_threshold=weight)
xdr = builder.gen_xdr()
tx_hash = builder.te.hash_meta()
return xdr.decode(), binascii.hexlify(tx_hash).decode()
async def build_remove_manage_data_operation(builder: Builder, source: str, list_name: List):
for name in list_name:
builder.append_manage_data_op(name, None, source=source)
