def test_transfer_success(self):
ACCOUNT_AMOUNT1 = 1000
ACCOUNT_AMOUNT2 = 500
TRANSFER_VALUE = ACCOUNT_AMOUNT1
self.send_transaction(
TokenMethod.TRANSFER,
TokenClient.get_transfer_payload(self.account_address2,
TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({
self.account_address1:
TokenClient.get_account_model(ACCOUNT_AMOUNT1)
})
self.expect_get({
self.account_address2:
TokenClient.get_account_model(ACCOUNT_AMOUNT2)
})
self.expect_set({
self.account_address1:
TokenClient.get_account_model(ACCOUNT_AMOUNT1 - TRANSFER_VALUE),
self.account_address2:
TokenClient.get_account_model(ACCOUNT_AMOUNT2 + TRANSFER_VALUE)
})
self.expect_ok()
def certificate_already_exist(cert):
token_client = TokenClient()
address = token_client.make_address_from_data(cert.public_bytes(serialization.Encoding.DER).hex())
try:
value = token_client.get_value(address)
except KeyNotFound:
return False
return True
def test_transfer_fail_to_zeroaddress(self):
ACCOUNT_AMOUNT1 = 500
TRANSFER_VALUE = 200
self.send_transaction(
TokenMethod.TRANSFER,
TokenClient.get_transfer_payload(
self.handler.make_address(ZERO_ADDRESS), TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({
self.account_address1:
TokenClient.get_account_model(ACCOUNT_AMOUNT1)
})
self.expect_invalid_transaction()
def test_transfer_fail_no_state_address1(self):
ACCOUNT_AMOUNT2 = 500
TRANSFER_VALUE = 200
self.send_transaction(
TokenMethod.TRANSFER,
TokenClient.get_transfer_payload(self.account_address2,
TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({self.account_address1: None})
self.expect_get({
self.account_address2:
TokenClient.get_account_model(ACCOUNT_AMOUNT2)
})
self.expect_invalid_transaction()
def test_genesis_fail(self):
TOTAL_SUPPLY = 10000
zero_address = self.handler.make_address(ZERO_ADDRESS)
self.send_transaction(TokenMethod.GENESIS,
TokenClient.get_genesis_payload(TOTAL_SUPPLY),
[zero_address, self.account_address1])
genesis_status = GenesisStatus()
genesis_status.status = True
self.expect_get({self.account_address1: None})
self.expect_get({zero_address: genesis_status})
self.expect_invalid_transaction()
def test_genesis_empty(self):
TOTAL_SUPPLY = 10000
zero_address = self.handler.make_address(ZERO_ADDRESS)
self.send_transaction(TokenMethod.GENESIS,
TokenClient.get_genesis_payload(TOTAL_SUPPLY),
[zero_address, self.account_address1])
self.expect_get({self.account_address1: None})
self.expect_get({zero_address: None})
genesis_status = GenesisStatus()
genesis_status.status = True
account = Account()
account.balance = TOTAL_SUPPLY
self.expect_set({
self.account_address1: account,
zero_address: genesis_status
})
self.expect_ok()
# limitations under the License.
# ------------------------------------------------------------------------
import argparse
from remme.protos.token_pb2 import TokenMethod
from remme.token.token_client import TokenClient
from remme.token.token_handler import TokenHandler, TransactionPayload
OUTPUT_BATCH = '/genesis/batch/token-proposal.batch'
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='File with a public key to assign initial supply.')
parser.add_argument('token_supply')
args = parser.parse_args()
token_client = TokenClient()
zero_address = TokenHandler.make_address('0' * 64)
target_address = TokenHandler.make_address_from_data(token_client.get_signer().get_public_key().as_hex())
print('Issuing {} tokens to address {}'.format(args.token_supply, target_address))
addresses_input_output = [zero_address, target_address]
payload = TransactionPayload()
payload.method = TokenMethod.GENESIS
payload.data = token_client.get_genesis_payload(args.token_supply).SerializeToString()
batch_list = TokenClient().make_batch_list(payload, addresses_input_output)
batch_file = open(OUTPUT_BATCH, 'wb')
def is_valid_token_balance():
token_client = TokenClient()
signer_pub_key = token_client.get_signer().get_public_key().as_hex()
signer_balance = token_client.get_balance(TokenHandler.make_address_from_data(signer_pub_key))
return signer_balance >= CERT_STORE_PRICE
def __init__(self):
self.client = TokenClient()
class TokenCli(BasicCli):
def __init__(self):
self.client = TokenClient()
def parser_transfer(self, subparsers, parent_parser):
message = 'Send REMME token transfer transaction.'
parser = subparsers.add_parser(
METHOD_TRANSFER,
parents=[parent_parser],
description=message,
help='Transfers <amount> of tokens to <address>.')
parser.add_argument('address_to',
type=str,
help='REMME account address.')
parser.add_argument(
'value',
type=int,
help='Amount of REMME tokens to transfer with 4 decimals.')
def parser_balance(self, subparsers, parent_parser):
message = 'Show address balance.'
parser = subparsers.add_parser(METHOD_BALANCE,
parents=[parent_parser],
description=message,
help='Balance of <address>.')
parser.add_argument(
'address',
type=str,
help='Check address. Specify "me" to use your address.')
def parser_address(self, subparsers, parent_parser):
message = 'Show current address or make one from public key.'
parser = subparsers.add_parser(
METHOD_ADDRESS,
parents=[parent_parser],
description=message,
help='You may specify "me" instead of a public key.')
parser.add_argument(
'pub_key',
type=str,
help=
'Type "me" or public address from which to show address in REMME network'
)
def do_address(self, args):
public_key = args.pub_key
if public_key == 'me':
public_key = self.client._signer.get_public_key().as_hex()
if not int(public_key, 16) or len(public_key) != 66:
raise CliException(
'Please, make sure public key is a 66 digit hex number: {}'.
format(public_key))
print(self.client.make_address_from_data(public_key))
def do_transfer(self, args):
status = self.client.transfer(address_to=args.address_to,
value=args.value)
print('Transfer status check: {}'.format(status['link']))
def do_balance(self, args):
if args.address == 'me':
args.address = self.client.make_address_from_data(
self.client._signer.get_public_key().as_hex())
try:
account = self.client.get_account(address=args.address)
print("Balance: {}\n".format(account.balance))
except KeyNotFound:
print('Balance: 0 REM')
except Exception as e:
print(e)
def init(self):
commands = []
commands += [{
'name': METHOD_TRANSFER,
'parser': self.parser_transfer,
'action': self.do_transfer
}, {
'name': METHOD_BALANCE,
'parser': self.parser_balance,
'action': self.do_balance
}, {
'name': METHOD_ADDRESS,
'parser': self.parser_address,
'action': self.do_address
}]
self.main_wrapper(commands)