def testEncodeString(self):
self._encodeAndDecodeAll([
_EncodeTestParams("Empty", cadence.String(""),
'{"type":"String","value":""}'),
_EncodeTestParams(
"Non-empty",
cadence.String("foo"),
'{"type":"String","value":"foo"}',
),
])
def create_account_template(
*,
keys: list[AccountKey],
reference_block_id: bytes = None,
payer: cadence.Address = None,
proposal_key: ProposalKey = None,
contracts: dict[Annotated[str, "name"], Annotated[str, "source"]] = None
) -> Tx:
if keys:
cadence_public_keys = cadence.Array(
[cadence.String(k.hex()) for k in keys])
else:
cadence_public_keys = cadence.Array([])
if contracts:
cadence_contracts = cadence.Dictionary([
cadence.KeyValuePair(cadence.String(k),
cadence.String(v.encode("utf-8").hex()))
for (k, v) in contracts.items()
])
else:
cadence_contracts = cadence.Dictionary([])
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=reference_block_id,
payer=payer,
proposal_key=proposal_key,
).add_arguments(cadence_public_keys).add_arguments(cadence_contracts))
return tx
def test_add_arguments(self):
with self.subTest(msg="No arguments"):
s = Script(code="")
s.add_arguments()
self.assertEqual(0, len(s.arguments))
with self.subTest(msg="One argument"):
s = Script(code="")
s.add_arguments(cadence.Bool(True))
self.assertEqual(1, len(s.arguments))
self.assertEqual(cadence.Bool(True), s.arguments[0])
with self.subTest(msg="One argument + one argument"):
s = Script(code="")
s.add_arguments(cadence.Bool(True))
s.add_arguments(cadence.String("42"))
self.assertEqual(2, len(s.arguments))
self.assertEqual(cadence.Bool(True), s.arguments[0])
self.assertEqual(cadence.String("42"), s.arguments[1])
with self.subTest(msg="Multiple arguments"):
s = Script(code="")
s.add_arguments(cadence.Bool(True), cadence.String("42"))
self.assertEqual(2, len(s.arguments))
self.assertEqual(cadence.Bool(True), s.arguments[0])
self.assertEqual(cadence.String("42"), s.arguments[1])
with self.subTest(msg="None Argument; should fail"):
s = Script(code="")
with self.assertRaises(exceptions.NotCadenceValueError):
# noinspection PyTypeChecker
s.add_arguments(None)
with self.subTest(msg="Non-cadence Argument; should fail"):
s = Script(code="")
with self.assertRaises(exceptions.NotCadenceValueError):
# noinspection PyTypeChecker
s.add_arguments("42")
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)
def testEncodeContract(self):
simple_contract_type = cadence.ContractType(
_test_location,
"FooContract",
[
cadence.Field(
"a",
type(cadence.Int),
),
cadence.Field(
"b",
type(cadence.String),
),
],
)
simple_contract = _EncodeTestParams(
"Simple",
cadence.Contract(
[cadence.Int(1), cadence.String("foo")], simple_contract_type),
"""
{
"type": "Contract",
"value": {
"id": "S.test.FooContract",
"fields": [
{ "name": "a", "value": { "type": "Int", "value": "1" } },
{ "name": "b", "value": { "type": "String", "value": "foo" } }
]
}
}
""",
)
resource_contract_type = cadence.ContractType(
_test_location,
"FooContract",
[
cadence.Field(
"a",
type(cadence.Int),
),
cadence.Field(
"b",
_foo_resource_type,
),
],
)
resource_contract = _EncodeTestParams(
"Resources",
cadence.Contract(
[
cadence.String("foo"),
cadence.Resource([cadence.Int(42)], _foo_resource_type),
],
resource_contract_type,
),
"""
{
"type": "Contract",
"value": {
"id": "S.test.FooContract",
"fields": [
{ "name": "a", "value": { "type": "String", "value": "foo" } },
{
"name": "b",
"value": {
"type": "Resource",
"value": {
"id": "S.test.Foo",
"fields": [
{ "name": "bar", "value": { "type": "Int", "value": "42" } }
]
}
}
}
]
}
}
""",
)
self._encodeAndDecodeAll([simple_contract, resource_contract])
def testEncodeDictionary(self):
simple_dict = _EncodeTestParams(
"Simple",
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("a"),
cadence.Int(1),
),
cadence.KeyValuePair(
cadence.String("b"),
cadence.Int(2),
),
cadence.KeyValuePair(
cadence.String("c"),
cadence.Int(3),
),
]),
"""{"type":"Dictionary","value":[
{"key":{"type":"String","value":"a"},"value":{"type":"Int","value":"1"}},
{"key":{"type":"String","value":"b"},"value":{"type":"Int","value":"2"}},
{"key":{"type":"String","value":"c"},"value":{"type":"Int","value":"3"}}
]}""",
)
nested_dict = _EncodeTestParams(
"Nested",
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("a"),
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("1"),
cadence.Int(1),
),
]),
),
cadence.KeyValuePair(
cadence.String("b"),
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("2"),
cadence.Int(2),
),
]),
),
cadence.KeyValuePair(
cadence.String("c"),
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("3"),
cadence.Int(3),
),
]),
),
]),
"""
{
"type": "Dictionary",
"value": [
{
"key": { "type": "String", "value": "a" },
"value": {
"type": "Dictionary",
"value": [
{
"key": { "type": "String", "value": "1" },
"value": { "type": "Int", "value": "1" }
}
]
}
},
{
"key": { "type": "String", "value": "b" },
"value": {
"type": "Dictionary",
"value": [
{
"key": { "type": "String", "value": "2" },
"value": { "type": "Int", "value": "2" }
}
]
}
},
{
"key": { "type": "String", "value": "c" },
"value": {
"type": "Dictionary",
"value": [
{
"key": { "type": "String", "value": "3" },
"value": { "type": "Int", "value": "3" }
}
]
}
}
]
}
""",
)
resource_dict = _EncodeTestParams(
"Resources",
cadence.Dictionary([
cadence.KeyValuePair(
cadence.String("a"),
cadence.Resource([cadence.Int(1)], _foo_resource_type),
),
cadence.KeyValuePair(
cadence.String("b"),
cadence.Resource([cadence.Int(2)], _foo_resource_type),
),
cadence.KeyValuePair(
cadence.String("c"),
cadence.Resource([cadence.Int(3)], _foo_resource_type),
),
]),
"""
{
"type": "Dictionary",
"value": [
{
"key": { "type": "String", "value": "a" },
"value": {
"type": "Resource",
"value": {
"id": "S.test.Foo",
"fields": [
{ "name": "bar", "value": { "type": "Int", "value": "1" } }
]
}
}
},
{
"key": { "type": "String", "value": "b" },
"value": {
"type": "Resource",
"value": {
"id": "S.test.Foo",
"fields": [
{ "name": "bar", "value": { "type": "Int", "value": "2" } }
]
}
}
},
{
"key": { "type": "String", "value": "c" },
"value": {
"type": "Resource",
"value": {
"id": "S.test.Foo",
"fields": [
{ "name": "bar", "value": { "type": "Int", "value": "3" } }
]
}
}
}
]
}
""",
)
self._encodeAndDecodeAll([
simple_dict,
nested_dict,
resource_dict,
])
