def test_from_type_and_payload(
network_type, payload, network_id, version, should_throw
):
if should_throw:
with pytest.raises(ValueError) as e:
AssetAddress.from_type_and_payload(
network_type, payload, network_id=network_id, version=version
)
else:
try:
AssetAddress.from_type_and_payload(
network_type, payload, network_id=network_id, version=version
)
except Exception as e: # noqa : E841
raise pytest.fail(f"Unexpected exception: {e}")
def test_from_type_and_payload_mutisig():
sig = MultiSig(
2,
1,
[
H160("1111111111111111111111111111111111111111"),
H160("2222222222222222222222222222222222222222"),
],
)
address1 = AssetAddress.from_string(
"tcaqypsyqg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyfzyg3zyg3zyg3zyg3zyg3zyg3zyg3zygsn28hf0"
)
address2 = AssetAddress.from_type_and_payload(3, sig, network_id="tc")
assert address1.value == address2.value
def create_mint_transaction(self, recipient: Union[AssetAddress, str]):
if self.network_id is None:
raise ValueError("networkId is undefined")
if self.shard_id is None:
raise ValueError("shardId is undefined")
return MintAsset(
self.network_id,
self.shard_id,
self.metadata,
AssetMintOutput(self.supply, AssetAddress.ensure(recipient)),
self.approver,
self.registrar,
self.allowd_script_hashes,
[],
)
def test_from_string_mutisig():
address = AssetAddress.from_string(
"tcaqypsyqg3zyg3zyg3zyg3zyg3zyg3zyg3zyg3zyfzyg3zyg3zyg3zyg3zyg3zyg3zyg3zygsn28hf0"
)
payload = address.payload
network_type = address.address_type
assert network_type == 3
n, m, pubkeys = payload
assert n == 2
assert m == 1
assert pubkeys[0] == H160("1111111111111111111111111111111111111111")
assert pubkeys[1] == H160("2222222222222222222222222222222222222222")
def create_mint_asset_transaction(
self,
recipient: AssetAddress,
scheme: AssetScheme = None,
approvals: List[str] = None,
network_id: str = None,
shard_id: int = None,
metadata=None,
approver: PlatformAddress = None,
registrar: PlatformAddress = None,
allowed_script_hashes: List[H160] = None,
supply: U64 = None,
):
if approvals is None:
approvals = []
if scheme is None and (shard_id is None or metadata is None):
raise ValueError(
f"Either scheme params or proper arguments should be provided {scheme}"
)
network_id = self.network_id if network_id is None else network_id
shard_id = shard_id
supply = U64(U64.MAX_VALUE) if supply is None else supply
check_metadata(metadata)
metadata = metadata if isinstance(metadata, str) else str(metadata)
check_asset_address_recipient(recipient)
check_network_id(network_id)
if shard_id is None:
raise ValueError("shard_id is None")
check_shard_id(shard_id)
check_approver(approver)
check_registrar(registrar)
check_amount(supply)
return MintAsset(
network_id,
shard_id,
metadata,
AssetMintOutput(U64(supply), None, None,
AssetAddress.ensure(recipient)),
None if approver is None else PlatformAddress.ensure(approver),
None if registrar is None else PlatformAddress.ensure(registrar),
[] if allowed_script_hashes is None else allowed_script_hashes,
approvals,
)
def create_transfer_transaction(
self,
network_id: str,
recipient: List = None,
timelock: Union[Timelock, None] = None,
metadata="",
approvals: List[str] = None,
expiration: int = None,
):
if recipient is None:
recipient = []
if approvals is None:
approvals = []
from .assettransferoutput import AssetTransferOutput
from .transferasset import TransferAsset
return TransferAsset(
[],
[AssetTransferInput(self.out_point, timelock, bytes(), bytes())],
list(
map(
lambda x: AssetTransferOutput(
self.asset_type,
self.shard_id,
x.quantity,
AssetAddress.ensure(x.address),
),
recipient,
)),
[],
network_id,
metadata,
approvals,
expiration,
)
def check_asset_address_recipient(recipient: AssetAddress):
if not AssetAddress.check(recipient):
raise ValueError(
f"Expected recipient param to be a AssetAddress but found {recipient}"
)
def create_address(self, passphrase=None):
key_hash = self.raw_keystore.asset.create_key(passphrase)
return AssetAddress.from_type_and_payload(1,
key_hash,
network_id=self.network_id)
def from_string():
assert AssetAddress.from_string(validAddress) == validAddress
with pytest.raises(ValueError):
AssetAddress.from_string("cccqyqjmvml2hdp8s8xzqnr57r8ywtduy2u6gcq89vff")
def test_ensure():
assert AssetAddress.ensure(validAddressString) == validAddress
assert AssetAddress.ensure(validAddress) == validAddress
def test_check():
assert AssetAddress.check(validAddressString)
assert AssetAddress.check(validAddress)
assert not AssetAddress.check(invalidAddressString)
import inspect
import pytest
from codechain.primitives import AssetAddress
from codechain.primitives import H160
from codechain.primitives import MultiSig
validAddressString = "ccaqyqjmvml2hdp8s8xzqnr57r8ywtduy2u6gcq89vffl"
validAddress = AssetAddress.from_string(validAddressString)
invalidAddressString = "ccaqyqjmvml2hdp8s8xzqnr57r8ywtduy2u6gcq89vff"
def test_import():
assert inspect.isclass(AssetAddress)
assert inspect.isclass(MultiSig)
def test_check():
assert AssetAddress.check(validAddressString)
assert AssetAddress.check(validAddress)
assert not AssetAddress.check(invalidAddressString)
def test_ensure():
assert AssetAddress.ensure(validAddressString) == validAddress
assert AssetAddress.ensure(validAddress) == validAddress
@pytest.mark.parametrize(
"network_type, payload, network_id, version, should_throw",