async def run(self, ctx: Config):
async with flow_client(host=ctx.access_node_host,
port=ctx.access_node_port) as client:
pub_key, priv_key = random_key_pair(SignAlgo.ECDSA_secp256k1)
# prepare parameters
account_key = AccountKey(
public_key=pub_key,
sign_algo=SignAlgo.ECDSA_secp256k1,
hash_algo=HashAlgo.SHA3_256,
)
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = (create_account_template(keys=[account_key]).add_authorizers(
ctx.service_account_address).with_reference_block_id(block.id).
with_payer(ctx.service_account_address).with_proposal_key(
ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
)).with_payload_signature(
ctx.service_account_address, 0,
ctx.service_account_signer).with_envelope_signature(
ctx.service_account_address, 0,
ctx.service_account_signer))
result = await client.execute_transaction(tx)
log.info(f"new address {result.events[0]}")
async def run(self, ctx: Config):
async with flow_client(host=ctx.access_node_host,
port=ctx.access_node_port) as client:
address, _, _ = await random_account(
client=client,
ctx=ctx,
contracts={
"EventDemo":
"""
pub contract EventDemo {
pub event Add(x: Int, y: Int, sum: Int)
pub fun add(_ x: Int, _ y: Int) {
let sum = x + y
emit Add(x: x, y: y, sum: sum)
}
}""",
},
)
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = Tx(
code=f"""
import EventDemo from {address.hex_with_prefix()}
transaction() {{
prepare() {{
EventDemo.add(1, 6)
}}
}}
""",
reference_block_id=block.id,
payer=ctx.service_account_address,
proposal_key=ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
),
).with_envelope_signature(
ctx.service_account_address,
ctx.service_account_key_id,
ctx.service_account_signer,
)
result = await client.execute_transaction(tx)
add_event = [
e.value for e in result.events
if isinstance(e.value, cadence.Event)
][0]
assert add_event.fields[2].as_type(cadence.Int).value == 7
async def run(self, ctx: Config):
async with flow_client(host=ctx.access_node_host,
port=ctx.access_node_port) as client:
pub_key, _ = random_key_pair(SignAlgo.ECDSA_secp256k1)
# prepare parameters
account_key = AccountKey(
public_key=pub_key,
sign_algo=SignAlgo.ECDSA_secp256k1,
hash_algo=HashAlgo.SHA3_256,
)
account_key_hex = cadence.String(account_key.hex())
cadence_public_keys = cadence.Array([account_key_hex])
cadence_contracts = cadence.Dictionary([])
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = (Tx(
code="""
transaction(publicKeys: [String], contracts:{String: String}) {
prepare(signer: AuthAccount) {
let acct = AuthAccount(payer: signer)
for key in publicKeys {
acct.addPublicKey(key.decodeHex())
}
for contract in contracts.keys {
acct.contracts.add(name: contract, code: contracts[contract]!.decodeHex())
}
}
}
""",
reference_block_id=block.id,
payer=ctx.service_account_address,
proposal_key=ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
),
).add_authorizers(
ctx.service_account_address).add_arguments(cadence_public_keys)
.add_arguments(cadence_contracts).with_payload_signature(
ctx.service_account_address, 0,
ctx.service_account_signer).with_envelope_signature(
ctx.service_account_address, 0,
ctx.service_account_signer))
await client.execute_transaction(tx)
async def random_account(
*,
client: AccessAPI,
ctx: Config,
contracts: dict[Annotated[str, "name"], Annotated[str, "source"]] = None,
) -> (cadence.Address, AccountKey, Signer):
pub, priv = random_key_pair(SignAlgo.ECDSA_secp256k1)
account_key = AccountKey(public_key=pub,
sign_algo=SignAlgo.ECDSA_secp256k1,
hash_algo=HashAlgo.SHA3_256)
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = (create_account_template(
keys=[account_key],
contracts=contracts,
reference_block_id=block.id,
payer=ctx.service_account_address,
proposal_key=ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
),
).add_authorizers(ctx.service_account_address).with_envelope_signature(
ctx.service_account_address, 0, ctx.service_account_signer))
result = await client.execute_transaction(tx)
new_addresses = [
e.value.address for e in result.events
if isinstance(e.value, cadence.AccountCreatedEvent)
]
return (
new_addresses[0],
account_key,
InMemorySigner(
sign_algo=SignAlgo.ECDSA_secp256k1,
hash_algo=HashAlgo.SHA3_256,
private_key_hex=priv.hex(),
),
)
async def run(self, ctx: Config):
async with flow_client(host=ctx.access_node_host,
port=ctx.access_node_port) as client:
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = Tx(
code="""transaction(){prepare(){log("OK")}}""",
reference_block_id=block.id,
payer=ctx.service_account_address,
proposal_key=ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
),
).with_envelope_signature(
ctx.service_account_address,
ctx.service_account_key_id,
ctx.service_account_signer,
)
await client.execute_transaction(tx)
async def run(self, ctx: Config):
async with flow_client(host=ctx.access_node_host,
port=ctx.access_node_port) as client:
address, _, _ = await random_account(
client=client,
ctx=ctx,
contracts={
"EventDemo":
"""
pub contract EventDemo {
pub event Add(x: Int, y: Int, sum: Int)
pub fun add(_ x: Int, _ y: Int) {
let sum = x + y
emit Add(x: x, y: y, sum: sum)
}
}""",
},
)
class AddEvent(cadence.BaseEvent):
def __init__(self, fields: list[cadence.Value],
event_type: cadence.EventType):
super().__init__(fields, event_type)
self.x = self.fields[0].as_type(cadence.Int).value
self.y = self.fields[1].as_type(cadence.Int).value
self.sum = self.fields[2].as_type(cadence.Int).value
@classmethod
def event_id_constraint(cls) -> str:
return f"A.{address.hex()}.EventDemo.Add"
cadence.EventTypeRegistry.register_event_type(AddEvent)
block = await client.get_latest_block()
proposer = await client.get_account_at_latest_block(
address=ctx.service_account_address.bytes)
tx = Tx(
code=f"""
import EventDemo from {address.hex_with_prefix()}
transaction() {{
prepare() {{
EventDemo.add(1, 6)
}}
}}
""",
reference_block_id=block.id,
payer=ctx.service_account_address,
proposal_key=ProposalKey(
key_address=ctx.service_account_address,
key_id=ctx.service_account_key_id,
key_sequence_number=proposer.keys[
ctx.service_account_key_id].sequence_number,
),
).with_envelope_signature(
ctx.service_account_address,
ctx.service_account_key_id,
ctx.service_account_signer,
)
result = await client.execute_transaction(tx)
add_event = [
e.value for e in result.events
if isinstance(e.value, AddEvent)
][0]
assert add_event.sum == 7