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, ])