def storage():
db_name = 'fee.db'
db = ContextDatabase.from_path(db_name)
assert db is not None
storage = FeeStorage(db)
yield storage
rmtree(db_name)
def setUp(self):
empty_address = MalformedAddress.from_string('')
short_address_without_hx = MalformedAddress.from_string('12341234')
short_address = MalformedAddress.from_string('hx1234512345')
long_address_without_hx = MalformedAddress.from_string(
'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf')
long_address = MalformedAddress.from_string(
'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf'
)
self.malformed_addresses = [
empty_address, short_address_without_hx, short_address,
long_address_without_hx, long_address
]
self.db_name = 'engine.db'
db = ContextDatabase.from_path(self.db_name)
self.engine = IcxEngine()
self._from = Address.from_string('hx' + 'a' * 40)
self.to = Address.from_string('hx' + 'b' * 40)
self.genesis_address = Address.from_string('hx' + '0' * 40)
self.fee_treasury_address = Address.from_string('hx' + '1' * 40)
self.total_supply = 10**20 # 100 icx
self.context = IconScoreContext(IconScoreContextType.DIRECT)
icx_storage = IcxStorage(db)
self.engine.open(icx_storage)
self.engine.init_account(self.context, AccountType.GENESIS, 'genesis',
self.genesis_address, self.total_supply)
self.engine.init_account(self.context, AccountType.TREASURY,
'treasury', self.fee_treasury_address, 0)
def test_var_db(self, context, key_value_db, old_value, new_value, value_type):
context_db = ContextDatabase(key_value_db, is_shared=False)
address = Address(AddressPrefix.CONTRACT, os.urandom(20))
score_db = IconScoreDatabase(address, context_db)
self._init_context(context, address)
self._set_revision(context, Revision.USE_RLP.value - 1)
name = "var_db"
var_db = VarDB(name, score_db, value_type)
var_db.set(old_value)
assert var_db.get() == old_value
key = _get_final_key(address, ContainerTag.VAR, name.encode(), use_rlp=False)
assert key_value_db.get(key) == ContainerUtil.encode_value(old_value)
self._set_revision(context, Revision.USE_RLP.value)
assert key_value_db.get(key) == ContainerUtil.encode_value(old_value)
var_db.set(new_value)
assert var_db.get() == new_value
assert var_db.get() != old_value
key = _get_final_key(address, ContainerTag.VAR, name.encode(), use_rlp=True)
assert key_value_db.get(key) == ContainerUtil.encode_value(new_value)
var_db.remove()
assert var_db.get() == get_default_value(value_type)
assert len(key_value_db) == 0
def setUp(self):
empty_address = MalformedAddress.from_string('')
short_address_without_hx = MalformedAddress.from_string('12341234')
short_address = MalformedAddress.from_string('hx1234512345')
long_address_without_hx = MalformedAddress.from_string(
'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf')
long_address = MalformedAddress.from_string(
'hxcf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf'
)
self.addresses = [
empty_address, short_address_without_hx, short_address,
long_address_without_hx, long_address
]
self.db_name = 'icx.db'
db = ContextDatabase.from_path(self.db_name)
self.assertIsNotNone(db)
self.storage = IcxStorage(db)
context = IconScoreContext(IconScoreContextType.DIRECT)
mock_block: 'Mock' = Mock(spec=Block)
mock_block.attach_mock(Mock(return_value=0), 'height')
context.block = mock_block
self.context = context
def test_1_depth_dict_db(self, context, key_value_db, keys, old_values, new_values, value_type):
context_db = ContextDatabase(key_value_db, is_shared=False)
score_address = Address(AddressPrefix.CONTRACT, os.urandom(20))
score_db = IconScoreDatabase(score_address, context_db)
self._init_context(context, score_address)
self._set_revision(context, Revision.USE_RLP.value - 1)
name = "dict_db_depth_1"
dict_db = DictDB(name, score_db, depth=1, value_type=value_type)
# Put two items to dict_db
for i in range(2):
k, v = keys[i], old_values[i]
dict_db[k] = v
assert dict_db[k] == v
key = _get_final_key(
score_address, ContainerTag.DICT, name.encode(), ContainerUtil.encode_key(k),
use_rlp=False
)
assert key_value_db.get(key) == ContainerUtil.encode_value(v)
self._set_revision(context, Revision.USE_RLP.value)
# Read old-formatted data on Revision.USE_RLP
for i in range(2):
k, v = keys[i], old_values[i]
assert dict_db[k] == v
key = _get_final_key(
score_address, ContainerTag.DICT, name.encode(), ContainerUtil.encode_key(k),
use_rlp=False
)
assert key_value_db.get(key) == ContainerUtil.encode_value(v)
# Put 4 items to dict_db
for i, k in enumerate(keys):
old_v = old_values[i]
new_v = new_values[i]
dict_db[k] = new_v
assert dict_db[k] == new_v
assert dict_db[k] != old_v
key = _get_final_key(
score_address, ContainerTag.DICT, name.encode(), ContainerUtil.encode_key(k),
use_rlp=True
)
assert key_value_db.get(key) == ContainerUtil.encode_value(new_v)
# If there is no value for a given key, default value is returned
for k in keys:
del dict_db[k]
assert dict_db[k] == get_default_value(value_type)
assert len(key_value_db) == 0
def storage(context):
db_name = 'icx.db'
db = ContextDatabase.from_path(db_name)
storage = Storage(db)
context.storage = ContextStorage(icx=storage)
storage.open(context)
yield storage
storage.close(context)
shutil.rmtree(db_name)
def setUp(self):
self.db_name = 'fee.db'
self.address = create_address(AddressPrefix.EOA)
db = ContextDatabase.from_path(self.db_name)
self.assertIsNotNone(db)
self.storage = FeeStorage(db)
context = IconScoreContext(IconScoreContextType.DIRECT)
context.tx_batch = TransactionBatch()
context.block_batch = BlockBatch()
self.context = context
def setUp(self):
self.key_value_mock = MockKeyValueDatabase({})
self.db = IconScoreDatabase(self.sender,
ContextDatabase(self.key_value_mock))
IconScoreBase.get_owner = lambda score_object, score_address: self.sender
self.smart_wallet = SmartWallet(self.db)
type(self.smart_wallet).msg = PropertyMock(
return_value=Message(sender=self.sender, value=10000))
# print test name
print(f"===== {self._testMethodName} ==========================")
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'0')
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
self.db = IconScoreDatabase(address, context_db=context_db, prefix=b'')
self.address = address
def setUp(self):
self.db_name = 'icx.db'
self.address = create_address(AddressPrefix.EOA)
db = ContextDatabase.from_path(self.db_name)
self.assertIsNotNone(db)
self.storage = IcxStorage(db)
self.factory = IconScoreContextFactory(max_size=1)
context = self.factory.create(IconScoreContextType.DIRECT)
context.tx_batch = TransactionBatch()
context.block_batch = BlockBatch()
self.context = context
def setUp(self):
self.db_name = 'icx.db'
db = ContextDatabase.from_path(self.db_name)
self.assertIsNotNone(db)
self.storage = IcxStorage(db)
context = IconScoreContext(IconScoreContextType.DIRECT)
context.tx_batch = TransactionBatch()
mock_block: 'Mock' = Mock(spec=Block)
mock_block.attach_mock(Mock(return_value=0), 'height')
context.block = mock_block
context.block_batch = BlockBatch()
self.context = context
def setUp(self):
empty_address = MalformedAddress.from_string('')
short_address_without_hx = MalformedAddress.from_string('12341234')
short_address = MalformedAddress.from_string('hx1234512345')
long_address_without_hx = MalformedAddress.from_string(
'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf')
long_address = MalformedAddress.from_string(
'hxdf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf'
)
self.malformed_addresses = [
empty_address, short_address_without_hx, short_address,
long_address_without_hx, long_address
]
self.db_name = 'engine.db'
db = ContextDatabase.from_path(self.db_name)
self.engine = IcxEngine()
self._from = Address.from_string('hx' + 'a' * 40)
self.to = Address.from_string('hx' + 'b' * 40)
self.genesis_address = Address.from_string('hx' + '0' * 40)
self.fee_treasury_address = Address.from_string('hx' + '1' * 40)
self.total_supply = 10**20 # 100 icx
self.context = IconScoreContext(IconScoreContextType.DIRECT)
block = Mock(spec=Block)
block.attach_mock(Mock(return_value=0), 'height')
self.context.block = block
self.storage = IcxStorage(db)
self.engine.open()
accounts: list = [{
'address': self.genesis_address,
'balance': self.total_supply
}, {
'address': self.fee_treasury_address,
'balance': 0
}]
self.context.storage = ContextStorage(deploy=None,
fee=None,
icx=self.storage,
iiss=None,
prep=None,
issue=None,
rc=None,
meta=None)
self.storage.put_genesis_accounts(self.context, accounts)
def test_score_db(self, context, key_value_db, prefixes, old_values, new_values):
context_db = ContextDatabase(key_value_db, is_shared=False)
score_address = Address(AddressPrefix.CONTRACT, os.urandom(20))
score_db = IconScoreDatabase(score_address, context_db)
args = [score_address]
self._init_context(context, score_address)
self._set_revision(context, Revision.USE_RLP.value - 1)
for prefix in prefixes:
score_db = score_db.get_sub_db(prefix)
args.append(prefix)
for i, value in enumerate(old_values):
key: bytes = f"key{i}".encode()
encoded_value: bytes = ContainerUtil.encode_value(value)
score_db.put(key, encoded_value)
assert score_db.get(key) == encoded_value
final_key: bytes = _get_final_key(*args, key, use_rlp=False)
assert key_value_db.get(final_key) == encoded_value
self._set_revision(context, Revision.USE_RLP.value)
for i, value in enumerate(old_values):
key: bytes = f"key{i}".encode()
encoded_value: bytes = ContainerUtil.encode_value(value)
assert score_db.get(key) == encoded_value
final_key: bytes = _get_final_key(*args, key, use_rlp=False)
assert key_value_db.get(final_key) == encoded_value
for i, value in enumerate(new_values):
key: bytes = f"key{i}".encode()
encoded_value: bytes = ContainerUtil.encode_value(value)
score_db.put(key, encoded_value)
assert score_db.get(key) == encoded_value
final_key: bytes = _get_final_key(*args, key, use_rlp=True)
assert key_value_db.get(final_key) == encoded_value
score_db.delete(key)
assert score_db.get(key) is None
assert key_value_db.get(final_key) is None
def test_array_db(self, context, key_value_db, values, value_type):
context_db = ContextDatabase(key_value_db, is_shared=False)
address = Address(AddressPrefix.CONTRACT, os.urandom(20))
score_db = IconScoreDatabase(address, context_db)
self._init_context(context, score_db.address)
self._set_revision(context, Revision.USE_RLP.value - 1)
name = "array_db"
array_db = ArrayDB(name, score_db, value_type)
for i in range(2):
array_db.put(values[i])
assert len(array_db) == 2
self._set_revision(context, Revision.USE_RLP.value)
array_db.put(values[2])
array_db.put(values[3])
assert len(array_db) == 4
for i, value in enumerate(array_db):
assert value == values[i]
final_key: bytes = _get_final_key(address, ContainerTag.ARRAY, name.encode(), use_rlp=True)
assert key_value_db.get(final_key) == int_to_bytes(len(array_db))
for i, use_rlp in enumerate((False, False, True, True)):
key = _get_final_key(
address.to_bytes(),
ContainerTag.ARRAY.value,
name.encode(),
int_to_bytes(i),
use_rlp=use_rlp,
)
assert key_value_db.get(key) == ContainerUtil.encode_value(values[i])
for v in reversed(values):
assert v == array_db.pop()
assert len(array_db) == 0
# 2 values for array_db size still remain
# even though all items in array_db have been popped.
assert len(key_value_db) == 2
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'score')
context = IconScoreContext(IconScoreContextType.INVOKE)
context.block_batch = BlockBatch()
context.tx_batch = TransactionBatch()
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
meta_context_db = MetaContextDatabase(context_db.key_value_db)
self.context_db = context_db
self.meta_context_db = meta_context_db
self.address = address
self.context = context
def setUp(self):
state_db_root_path = 'state_db'
self.state_db_root_path = state_db_root_path
rmtree(state_db_root_path)
os.mkdir(state_db_root_path)
address = Address.from_data(AddressPrefix.CONTRACT, b'score')
context_factory = IconScoreContextFactory(max_size=2)
context = context_factory.create(IconScoreContextType.INVOKE)
context.block_batch = BlockBatch()
context.tx_batch = TransactionBatch()
db_path = os.path.join(state_db_root_path, 'db')
context_db = ContextDatabase.from_path(db_path, True)
self.context_factory = context_factory
self.context_db = context_db
self.address = address
self.context = context
def setUp(self):
self.db_name = 'engine.db'
db = ContextDatabase.from_path(self.db_name)
self.engine = IcxEngine()
self.from_ = Address.from_string('hx' + 'a' * 40)
self.to = Address.from_string('hx' + 'b' * 40)
self.genesis_address = Address.from_string('hx' + '0' * 40)
self.fee_treasury_address = Address.from_string('hx' + '1' * 40)
self.total_supply = 10**20 # 100 icx
self.context = IconScoreContext(IconScoreContextType.DIRECT)
icx_storage = IcxStorage(db)
self.engine.open(icx_storage)
self.engine.init_account(self.context, AccountType.GENESIS, 'genesis',
self.genesis_address, self.total_supply)
self.engine.init_account(self.context, AccountType.TREASURY,
'treasury', self.fee_treasury_address, 0)
def setUp(self):
empty_address = MalformedAddress.from_string('')
short_address_without_hx = MalformedAddress.from_string('12341234')
short_address = MalformedAddress.from_string('hx1234512345')
long_address_without_hx = MalformedAddress.from_string(
'cf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf')
long_address = MalformedAddress.from_string(
'hxcf85fac2d0b507a2db9ce9526e6d01476f16a2d269f51636f9c4b2d512017faf'
)
self.addresses = [
empty_address, short_address_without_hx, short_address,
long_address_without_hx, long_address
]
self.db_name = 'icx.db'
db = ContextDatabase.from_path(self.db_name)
self.assertIsNotNone(db)
self.storage = IcxStorage(db)
context = IconScoreContext(IconScoreContextType.DIRECT)
self.context = context
def setUp(self):
self.key_value_mock = MockKeyValueDatabase({})
self.db = IconScoreDatabase(self.sender,
ContextDatabase(self.key_value_mock))
IconScoreBase.get_owner = lambda score_object, score_address: self.sender
self.smart_wallet = SmartWallet(self.db)
type(self.smart_wallet).msg = PropertyMock(
return_value=Message(sender=self.sender, value=10000))
SmartWallet.Account = lambda _self, account: None
self.smart_wallet.on_install(
json.dumps({
"id": 0,
"tokenType": "icx",
"balance": 3000,
"sendLimit": 1000,
"totalUsed": 500,
"lastUsedDate": "2018-11-21",
"dids": []
}))
# print test name
print("=====================================================")
print(f"{self._testMethodName}")
def setUp(self):
self.db_name = 'engine.db'
db = ContextDatabase.from_path(self.db_name)
self.engine = IcxEngine()
self.storage = IcxStorage(db)
self.from_ = Address.from_string('hx' + 'a' * 40)
self.to = Address.from_string('hx' + 'b' * 40)
self.genesis_address = Address.from_string('hx' + '0' * 40)
self.fee_treasury_address = Address.from_string('hx' + '1' * 40)
self.total_supply = 10**20 # 100 icx
self.fee_treasury_address_icx_amount = 0
self.context = IconScoreContext(IconScoreContextType.DIRECT)
block = Mock(spec=Block)
block.attach_mock(Mock(return_value=0), 'height')
self.context.block = block
self.engine.open()
accounts: list = [{
'address': self.genesis_address,
'balance': self.total_supply
}, {
'address': self.fee_treasury_address,
'balance': 0
}]
self.context.storage = ContextStorage(deploy=None,
fee=None,
icx=self.storage,
iiss=None,
prep=None,
issue=None,
rc=None,
meta=None)
self.storage.put_genesis_accounts(self.context, accounts)
def test_2_depth_dict_db(self, context, key_value_db, keys1, keys2, old_values, new_values, value_type):
context_db = ContextDatabase(key_value_db, is_shared=False)
score_address = Address(AddressPrefix.CONTRACT, os.urandom(20))
score_db = IconScoreDatabase(score_address, context_db)
self._init_context(context, score_address)
self._set_revision(context, Revision.USE_RLP.value - 1)
name = "dict_db_depth_2"
dict_db = DictDB(name, score_db, depth=2, value_type=value_type)
# To assign a value to middle-layer dict_db is forbidden
for k1, v in zip(keys1, old_values):
with pytest.raises(InvalidContainerAccessException):
dict_db[k1] = v
# Assign values to dict_db on Revision.USE_RLP - 1
for k1 in keys1:
for k2, v in zip(keys2, old_values):
dict_db[k1][k2] = v
assert len(key_value_db) == len(keys1) * len(keys2)
for k1 in keys1:
for k2, v in zip(keys2, old_values):
assert dict_db[k1][k2] == v
key: bytes = _get_final_key(
score_address,
ContainerTag.DICT, name.encode(),
ContainerTag.DICT, ContainerUtil.encode_key(k1),
ContainerUtil.encode_key(k2),
use_rlp=False
)
assert key_value_db.get(key) == ContainerUtil.encode_value(v)
self._set_revision(context, Revision.USE_RLP.value)
# Check if reading old-formatted key:value data works on Revision.USE_RLP
for k1 in keys1:
for k2, v in zip(keys2, old_values):
assert dict_db[k1][k2] == v
# Replace all old_values with new_values on Revision.USE_RLP
for k1 in keys1:
for k2, v in zip(keys2, new_values):
dict_db[k1][k2] = v
# old_values + new_values
assert len(key_value_db) == len(keys1) * len(keys2) * 2
for k1 in keys1:
for k2, v in zip(keys2, new_values):
assert dict_db[k1][k2] == v
key: bytes = _get_final_key(
score_address,
ContainerTag.DICT, name.encode(),
ContainerUtil.encode_key(k1),
ContainerUtil.encode_key(k2),
use_rlp=True
)
assert key_value_db.get(key) == ContainerUtil.encode_value(v)
for k1 in keys1:
for k2 in keys2:
del dict_db[k1][k2]
assert dict_db[k1][k2] == get_default_value(value_type)
assert len(key_value_db) == 0
def create_db():
mock_db = MockKeyValueDatabase.create_db()
context_db = ContextDatabase(mock_db)
return IconScoreDatabase(create_address(), context_db)
def _create_mock_db(range_cnt: int):
mock_db = MockKeyValueDatabase.create_db()
context_db = ContextDatabase(mock_db)
return IconScoreDatabase(SCORE_ADDR, context_db)
def _create_plyvel_db(self, range_cnt: int):
_db = KeyValueDatabase.from_path(f"{DB_PATH}{range_cnt}")
context_db = ContextDatabase(_db)
return IconScoreDatabase(SCORE_ADDR, context_db)
def context_db():
mocked_kv_db: 'KeyValueDatabase' = MockKeyValueDatabase.create_db()
return ContextDatabase(mocked_kv_db)
