def test_is_cancellable():
""" test if a transaction is cancellable """
# Setup
ledger_1 = ledger.Ledger('monies')
tid_0 = 0
ledger_1.transaction_cancelled_tids = [1, 5, 7]
ledger_1.transaction_sequence = 100
# Test when transaction doesn't exist
true_or_false = ledger_1.is_cancellable(tid_0)
assert true_or_false == False
# test when transaction exists
tid_3 = 3
true_or_false = ledger_1.is_cancellable(tid_3)
assert true_or_false == True
# test when the transaction is itself
tid_5 = 5
ledger_1.transaction_sequence = 5
true_or_false = ledger_1.is_cancellable(tid_5)
assert true_or_false == False
# test when the transaction is the first one
tid_5 = 5
ledger_1.transaction_sequence = 6
ledger_1._block_limit = 0
true_or_false = ledger_1.is_cancellable(tid_5)
assert true_or_false == False
def readOld(inFile):
with inFile.open("r") as f:
transactions = yaml.load(f, Loader=FullLoader)
ledger_ = ledger.Ledger()
for str_transaction in transactions:
transaction = getTransaction(ledger_, str_transaction)
ledger_.addTransaction(transaction)
return ledger_
def __init__(self, n):
self.nodes = []
self.lastProps = [[], [], [], []]
self.lastVals = [ledger.Ledger()] * n
for i in range(n):
if i == 3:
self.nodes.append(node.Node(self, i))
else:
self.nodes.append(node_random.RandomNode(self, i))
self.round = 0
self.stringarray = []
def read(inFile):
with inFile.open("r") as f:
lines = f.readlines()
topAccount, accounts = getAccountsFromLines(lines)
transactions = [
Transaction.deserialize(line, accounts) for line in lines
]
ledger_ = ledger.Ledger()
ledger_.topAccount = topAccount
for transaction in transactions:
ledger_.addTransaction(transaction)
x = ledger_.topAccount.reset()
return ledger_
def __init__(self, lines):
"""Receives a list of line Guids
[Guid, ...]
"""
self.drone_ledger = ledger.Ledger(lines)
# self.coord_ledger = ledger.Ledger()
# self.coord_ledger.complete_as_coord_ledger(lines)
# self.line_ledger = ledger.Ledger()
# self.line_ledger.complete_as_line_ledger(lines)
# self.coord_ledger = self.make_new_coord_ledger(lines)
# self.line_ledger = self.make_new_line_ledger(lines)
self.tab = ' '
def __init__(self, env, id, ledg=None):
self.queue = []
self.transactions = []
self.lastVals = []
self.propositions = []
if ledg is None:
self.currentLedger = ledger.Ledger(None, [])
else:
self.currentLedger = ledg
self.round = 0
self.id = id
self.env = env
self.roundstring = ""
def make_new_coord_ledger(self, lines):
"""Receives a list of line Guids:
[Guid, ...]
Returns a list of coords:
[(num, num, num), ...]
"""
coords = []
for line in lines:
points = rs.CurvePoints(line)
for p in points:
coord = (p.X, p.Y, p.Z)
coords.append(coord)
coord_ledger = ledger.Ledger(coords)
print('coord ledger: %s' % coord_ledger.elements)
return coord_ledger
def test_median_value():
""" Test transactions on ledger can return the median """
# Setup
ledger_1 = ledger.Ledger('monies')
# test when no there are no values
ledger_1.transaction_values = []
assert ledger_1.median_value() == 0
# test when it is odd
ledger_1.transaction_values = [1, 5, 7]
assert ledger_1.median_value() == 5
# test sort and even numbers
ledger_1.transaction_values = [1, 7, 6, 5]
assert ledger_1.median_value() == 5.5
def test_is_block_full():
""" test if a block is full """
# Setup
ledger_2 = ledger.Ledger('monies2')
# test base case
true_or_false = ledger_2.is_block_full()
assert true_or_false == False
# test if there are 256 transactions and limit is 256
ledger_2.transaction_sequence = 256
true_or_false = ledger_2.is_block_full()
assert true_or_false == True
# test if there are 255 transactions
ledger_2.transaction_sequence = 255
true_or_false = ledger_2.is_block_full()
assert true_or_false == False
def Login_System(self):
u = (self.Username.get())
p = (self.Password.get())
if (u == str(1) and p == str(1)):
self.frame.destroy()
# self.frame.pack_forget()
# frameobj.pack() to show
# frameobj.grid_forget() to hide
# frameobj.pack_forget() to hide
ledger.Ledger(self.master)
# Demo2(self.master, self.master)
else:
tkinter.messagebox.showinfo("Login Systems",
"Invalid login details")
self.Username.set("")
self.Password.set("")
self.txtUsername.focus()
def make_new_line_ledger(self, lines):
"""Receives a list of line Guids:
[Guid, ...]
Returns a list of line coord index pairs:
[(int, int), ...]
"""
index_pairs = []
for line in lines:
points = rs.CurvePoints(line)
coord_pair = []
for p in points:
coord = (p.X, p.Y, p.Z)
coord_pair.append(coord)
index_pair = []
for coord in coord_pair:
index = self.coord_ledger.get_index(coord)
index_pair.append(index)
index_pairs.append(index_pair)
line_ledger = ledger.Ledger(index_pairs)
print('line ledger: %s' % line_ledger.elements)
return line_ledger
def run(args):
hosts = ["localhost", "localhost"]
ledger_filename = None
with infra.ccf.network(hosts,
args.binary_dir,
args.debug_nodes,
args.perf_nodes,
pdb=args.pdb) as network:
network.start_and_join(args)
primary, term = network.find_primary()
LOG.debug("Propose to add a new member (with a different curve)")
infra.proc.ccall(
network.key_generator,
f"--name=member4",
"--gen-key-share",
f"--curve={infra.ccf.ParticipantsCurve.secp256k1.name}",
)
result, error = network.consortium.propose_add_member(
1, primary, "member4_cert.pem", "member4_kshare_pub.pem")
# When proposal is added the proposal id and the result of running
# complete proposal are returned
assert not result["completed"]
proposal_id = result["id"]
# 2 out of 3 members vote to accept the new member so that
# that member can send its own proposals
LOG.debug("2/3 members accept the proposal")
result = network.consortium.vote(1, primary, proposal_id, True)
assert result[0] and not result[1]
LOG.debug("Failed vote as unsigned")
result = network.consortium.vote(2, primary, proposal_id, True, True)
assert (not result[0] and result[1]["code"]
== infra.jsonrpc.ErrorCode.RPC_NOT_SIGNED.value)
result = network.consortium.vote(2, primary, proposal_id, True)
assert result[0] and result[1]
ledger_filename = network.find_primary()[0].remote.ledger_path()
LOG.debug("Audit the ledger file for member votes")
l = ledger.Ledger(ledger_filename)
# this maps a member_id to a cert object, and is updated when we iterate the transactions,
# so that we always have the correct cert for a member on a given transaction
members = {}
verified_votes = 0
for tr in l:
tables = tr.get_public_domain().get_tables()
members_table = tables["ccf.member_certs"]
for cert, member_id in members_table.items():
members[member_id] = cert
if "ccf.voting_history" in tables:
votinghistory_table = tables["ccf.voting_history"]
for member_id, signed_request in votinghistory_table.items():
# if the signed vote is stored - there has to be a member at this point
assert member_id in members
cert = members[member_id]
sig = signed_request[0][0]
req = signed_request[0][1]
raw_req = signed_request[0][2]
digest = signed_request[0][3]
verify_sig(cert, sig, req, raw_req, digest)
verified_votes += 1
assert verified_votes >= 2
def test_calculate_return(self):
test_cases = [
Case(
name='Only good buys',
args={
'last_known_price':
100,
'operations': [
ledger.Operation('BCHEUR', 1, 90, ledger.Buy),
ledger.Operation('BCHEUR', 1, 95, ledger.Buy),
ledger.Operation('BCHEUR', 1, 100, ledger.Buy),
],
},
expected=15,
),
Case(
name='Good and bad buys',
args={
'last_known_price':
100,
'operations': [
ledger.Operation('BCHEUR', 1, 90, ledger.Buy),
ledger.Operation('BCHEUR', 1, 110, ledger.Buy),
ledger.Operation('BCHEUR', 1, 100, ledger.Buy),
],
},
expected=0,
),
Case(
name='Only bad buys',
args={
'last_known_price':
100,
'operations': [
ledger.Operation('BCHEUR', 1, 115, ledger.Buy),
ledger.Operation('BCHEUR', 0.5, 55, ledger.Buy),
],
},
expected=-20,
),
Case(
name='Only good sells',
args={
'last_known_price':
100,
'operations': [
ledger.Operation('BCHEUR', 1, 115, ledger.Sell),
ledger.Operation('BCHEUR', 1, 110, ledger.Sell),
ledger.Operation('BCHEUR', 1, 100, ledger.Sell),
],
},
expected=25,
),
Case(
name='Only bad sells',
args={
'last_known_price':
100,
'operations': [
ledger.Operation('BCHEUR', 1, 80, ledger.Sell),
ledger.Operation('BCHEUR', 0.5, 45, ledger.Sell),
ledger.Operation('BCHEUR', 1, 100, ledger.Sell),
],
},
expected=-25,
),
]
for test_case in test_cases:
test_ledger = ledger.Ledger('BCHEUR')
test_ledger.operations = test_case.args['operations']
got = test_ledger.calculate_return(
test_case.args['last_known_price'])
self.assertEqual(got, test_case.expected, test_case.name)
def run(args):
hosts = ["localhost", "localhost"]
ledger_filename = None
with infra.ccf.network(hosts,
args.build_dir,
args.debug_nodes,
args.perf_nodes,
pdb=args.pdb) as network:
primary, others = network.start_and_join(args)
# propose to add a new member
# proposal number 0
infra.proc.ccall("./genesisgenerator", "cert", "--name=member4")
result = infra.proc.ccall(
"./memberclient",
"add_member",
"--cert=member1_cert.pem",
"--privk=member1_privk.pem",
"--host={}".format(primary.host),
"--port={}".format(primary.tls_port),
"--member_cert=member4_cert.pem",
"--ca=networkcert.pem",
)
# when proposal is added the proposal id and the result of running complete proposal are returned
j_result = json.loads(result.stdout)
assert not j_result["result"]["completed"]
assert j_result["result"]["id"] == 0
# 2 out of 3 members vote to accept the new member so that that member can send its own proposals
result = infra.proc.ccall(
"./memberclient",
"vote",
"--accept",
"--cert=member1_cert.pem",
"--privk=member1_privk.pem",
"--host={}".format(primary.host),
"--port={}".format(primary.tls_port),
"--id=0",
"--ca=networkcert.pem",
"--sign",
)
j_result = json.loads(result.stdout)
assert not j_result["result"]
# this request should fail, as it is not signed
result = infra.proc.ccall(
"./memberclient",
"vote",
"--accept",
"--cert=member2_cert.pem",
"--privk=member2_privk.pem",
"--host={}".format(primary.host),
"--port={}".format(primary.tls_port),
"--id=0",
"--ca=networkcert.pem",
)
j_result = json.loads(result.stdout)
assert j_result["error"][
"code"] == infra.jsonrpc.ErrorCode.RPC_NOT_SIGNED.value
result = infra.proc.ccall(
"./memberclient",
"vote",
"--accept",
"--cert=member2_cert.pem",
"--privk=member2_privk.pem",
"--host={}".format(primary.host),
"--port={}".format(primary.tls_port),
"--id=0",
"--ca=networkcert.pem",
"--sign",
)
j_result = json.loads(result.stdout)
assert j_result["result"]
ledger_filename = network.find_leader()[0].remote.ledger_path()
l = ledger.Ledger(ledger_filename)
# this maps a member_id to a cert object, and is updated when we iterate the transactions,
# so that we always have the correct cert for a member on a given transaction
members = {}
verified_votes = 0
for tr in l:
tables = tr.get_public_domain().get_tables()
members_table = tables["membercerts"]
for cert, member_id in members_table.items():
members[member_id] = cert
if "votinghistory" in tables:
votinghistory_table = tables["votinghistory"]
for member_id, signed_request in votinghistory_table.items():
# if the signed vote is stored - there has to be a member at this point
assert member_id in members
cert = members[member_id]
sig = signed_request[0][0]
req = signed_request[0][1]
verify_sig(cert, sig, req)
verified_votes += 1
assert verified_votes >= 2
def __init__(self):
self.ledger = ledger.Ledger()
if isinstance(message, ledger.Ledger):
self.lastVals[i] = message
else:
self.lastProps[i] = message
def receive(self):
for temp in self.nodes:
temp.lastVals = self.lastVals
temp.propositions = self.lastProps.copy()
if __name__ == "__main__":
random.seed(988999)
env = Env(4)
genesis_ledger = ledger.Ledger()
env.lastVals = [
genesis_ledger, genesis_ledger, genesis_ledger, genesis_ledger
]
env.receive()
for node_ in env.nodes:
node_.start(genesis_ledger)
node_.broadcast(genesis_ledger)
env.receive()
env.round = env.lastVals[0].sequence_num
for i in range(4000):
#while env.lastVals[3].sequence_num < n or env.lastVals[1].sequence_num < n \
# or env.lastVals[2].sequence_num < n or env.lastVals[0].sequence_num < n:
#print(str(env.lastVals[0].sequence_num) + " " + str(env.lastVals[1].sequence_num) + " " + str(env.lastVals[2].sequence_num) + " " + str(env.lastVals[3].sequence_num))
