def merge_utxo(alicepub, alicepriv, include_spent):
asset = Asset(data={
"bicycle": {
"manufacturer": "bkfab",
"serial_number": "abcd1234"
}
},
data_id="334cd061-846b-4213-bd25-588e951def5f")
metadata = {'planet': 'earth'}
b = Bigchain()
utxo = b.get_outputs_filtered_not_include_freeze(alicepub, include_spent)
for u in utxo:
# print(u)
u.pop('details')
print('userA unspent asset:')
print(json.dumps(utxo, indent=4))
inputs = []
balance = 0
utxo = b.get_outputs_filtered_not_include_freeze(alicepub, include_spent)
for i in utxo:
f = Fulfillment.from_dict({
'fulfillment': i['details'],
'input': {
'cid': i['cid'],
'txid': i['txid'],
},
'owners_before': [alicepub],
})
inputs.append(f)
balance += i['amount']
length = len(utxo)
if balance <= 0:
print('No need to merge, because of lack of balance')
elif length <= 1:
print('No need to merge, because utxo len = 1')
else:
tx = Transaction.transfer(inputs, [([alicepub], balance)],
metadata=metadata,
asset=asset)
tx = tx.sign([alicepriv])
tx_id = tx.to_dict()['id']
# write to backlog
b.write_transaction(tx)
# wait 2 sec
print("========userA merge multi-asset========")
print("========wait for block and vote...========")
sleep(5)
# get tx by id
tx = b.get_transaction(tx_id)
print("merge txid:" + tx.to_dict()['id'])
utxo = b.get_outputs_filtered_not_include_freeze(alicepub, include_spent)
for u in utxo:
# print(u)
u.pop('details')
print('userA unspent asset:')
print(json.dumps(utxo, indent=4))
def create_double():
##################################################### 1.CREATE
# Cryptographic Identities Generation
alice, bob = generate_keypair(), generate_keypair()
# Digital Asset Definition (e.g. money)
asset = Asset(data={'money': 'RMB'},
data_id='20170628150000',
divisible=True)
# Metadata Definition
metadata = {'planet': 'earth'}
# create trnsaction TODO : owners_before might be node_pubkey in v0.8.0
tx = Transaction.create([alice.public_key], [([alice.public_key], 100),
([alice.public_key], 100)],
metadata=metadata,
asset=asset)
print(" ")
print("1.tx_create asset id : alice-----money(",
tx.to_dict()['transaction']['asset']['id'], ")----->alice")
print("1.tx_create tx id : ", tx.to_dict()['id'])
# sign with alice's private key
tx = tx.sign([alice.private_key])
tx_id = tx.to_dict()['id']
# write to backlog
b = Bigchain()
print("1.tx_create db response : ", b.write_transaction(tx))
# wait 2 sec
sleep(delay)
# get tx by id
tx = b.get_transaction(tx_id)
unspent = b.get_outputs_filtered_not_include_freeze(
alice.public_key, False)
print("1.tx_create query : ", tx)
print("1.tx_create unspent : ", unspent)
print(" ")
##################################################### 2.TRANSFER
# inputs and asset
cid = 0
condition = tx.to_dict()['transaction']['conditions'][cid]
inputs = Fulfillment.from_dict({
'fulfillment':
condition['condition']['details'],
'input': {
'cid': cid,
'txid': tx.to_dict()['id'],
},
'owners_before': [alice.public_key],
})
asset = Asset.from_dict(tx.to_dict()['transaction']['asset'])
# transfer
tx1 = Transaction.transfer([inputs], [([bob.public_key], 100)], asset)
print("2.tx_transfer asset id : alice-----money(",
tx1.to_dict()['transaction']['asset']['id'], ")----->bob")
print("2.tx_transfer tx id : ", tx1.to_dict()['id'])
# sign with alice's private key
tx1 = tx1.sign([alice.private_key])
tx1_id = tx1.to_dict()['id']
# write to backlog
b = Bigchain()
print("2.tx_transfer db response : ", b.write_transaction(tx1))
# wait 2 sec
sleep(delay)
# get tx by id
tx1 = b.get_transaction(tx1_id)
block = list(b.get_blocks_status_containing_tx(tx1_id).keys())[0]
votes = list(b.backend.get_votes_by_block_id(block))
votes_cast = [vote['vote']['is_block_valid'] for vote in votes]
election = b.get_blocks_status_containing_tx(tx1_id)
print("2.tx_transfer query : ", tx1)
print("2.tx_transfer block : ", block)
print("2. votes : ", votes)
print("2. votes_cast : ", votes_cast)
print("2. election : ", election)
print(" ")
##################################################### 3.INTERVAL
# Cryptographic Identities Generation
alice, bob = generate_keypair(), generate_keypair()
# Digital Asset Definition (e.g. money)
asset = Asset(data={'money': 'RMB'},
data_id='20170628150000',
divisible=True)
# Metadata Definition
metadata = {'planet': 'earth'}
# create trnsaction TODO : owners_before might be node_pubkey in v0.8.0
txi = Transaction.create([alice.public_key], [([alice.public_key], 100),
([alice.public_key], 100)],
metadata=metadata,
asset=asset)
print(" ")
print("1.tx_create asset id : alice-----money(",
tx.to_dict()['transaction']['asset']['id'], ")----->alice")
print("1.tx_create tx id : ", txi.to_dict()['id'])
# sign with alice's private key
txi = txi.sign([alice.private_key])
tx_id = txi.to_dict()['id']
# write to backlog
b = Bigchain()
print("1.tx_create db response : ", b.write_transaction(tx))
# wait 2 sec
sleep(delay)
##################################################### 3.TRANSFER
# inputs and asset [double spend]
cid = 1
condition = tx.to_dict()['transaction']['conditions'][cid]
inputs = Fulfillment.from_dict({
'fulfillment':
condition['condition']['details'],
'input': {
'cid': cid,
'txid': tx.to_dict()['id'],
},
'owners_before': [alice.public_key],
})
asset = Asset.from_dict(tx.to_dict()['transaction']['asset'])
# transfer
tx1 = Transaction.transfer([inputs], [([bob.public_key], 100)], asset)
print("3.tx_double asset id : alice-----money(",
tx1.to_dict()['transaction']['asset']['id'], ")----->bob")
print("3.tx_double tx id : ", tx1.to_dict()['id'])
# sign with alice's private key
tx1 = tx1.sign([alice.private_key])
tx1_id = tx1.to_dict()['id']
# write to backlog
b = Bigchain()
print("3.tx_double db response : ", b.write_transaction(tx1))
# wait 2 sec
sleep(delay)
# get tx by id
tx1 = b.get_transaction(tx1_id)
block = list(b.get_blocks_status_containing_tx(tx1_id).keys())[0]
votes = list(b.backend.get_votes_by_block_id(block))
votes_cast = [vote['vote']['is_block_valid'] for vote in votes]
election = b.get_blocks_status_containing_tx(tx1_id)
print("3.tx_transfer query : ", tx1)
print("3.tx_transfer block : ", block)
print("3. votes : ", votes)
print("3. votes_cast : ", votes_cast)
print("3. election : ", election)
print(" ")
def create_transfer(public_key, private_key, include_spent):
asset = Asset(data={
"bicycle": {
"manufacturer": "bkfab",
"serial_number": "abcd1234"
}
},
data_id="334cd061-846b-4213-bd25-588e951def5f")
##################################################### 1.getfreeze
b = Bigchain()
utxo_freeze = b.get_freeze_outputs_only(public_key)
# for u in utxo_freeze:
# # print(u)
# u.pop('details')
print('userA frozen asset:')
print(json.dumps(utxo_freeze, indent=4))
# print(json.load(utxo))
#
# ##################################################### 2.Unfreeze
inputs = []
balance = 0
for i in utxo_freeze:
f = Fulfillment.from_dict({
'fulfillment': i['details'],
'input': {
'cid': i['cid'],
'txid': i['txid'],
},
'owners_before': [public_key],
})
inputs.append(f)
balance += i['amount']
# create trnsaction
tx = Transaction.freeze_asset(inputs, [([public_key], balance, False)],
asset)
# # inputs and asset
# sign with alice's private key
tx = tx.sign([private_key])
tx_id = tx.to_dict()['id']
# write to backlog
b = Bigchain()
b.write_transaction(tx)
print("unfreeze asset for userA")
print("========wait for block and vote...========")
# wait 2 sec
sleep(5)
# get tx by id
tx = b.get_transaction(tx_id)
print("unfreeze asset tx1_id:" + tx.to_dict()['id'])
##################################################### 3.UTXO
# inputs and asset
utxo = b.get_outputs_filtered_not_include_freeze(public_key, include_spent)
for u in utxo:
# print(u)
u.pop('details')
print('userA unspent asset:')
print(json.dumps(utxo, indent=4))
def create_transfer(alicepub, alicepriv, include_spent):
##################################################### 1.CREATE
# Cryptographic Identities Generation
# alice, bob = generate_keypair(), generate_keypair()
# Digital Asset Definition (e.g. bicycle)
asset = Asset(data={
"bicycle": {
"manufacturer": "bkfab",
"serial_number": "abcd1234"
}
},
data_id="334cd061-846b-4213-bd25-588e951def5f")
# Metadata Definition
metadata = {'planet': 'earth'}
# create trnsaction TODO : owners_before might be node_pubkey in v0.8.0
tx = Transaction.create([alicepub], [([alicepub], 100)],
metadata=metadata,
asset=asset)
# sign with alice's private key
tx = tx.sign([alicepriv])
tx_id = tx.to_dict()['id']
# write to backlog
b = Bigchain()
b.write_transaction(tx)
print("========create 100 asset for userA========")
print("========wait for block and vote...========")
# wait 2 sec
sleep(5)
# get tx by id
tx = b.get_transaction(tx_id)
print("create 100 asset tx1_id:" + tx.to_dict()['id'])
##################################################### 3.UTXO
# inputs and asset
utxo = b.get_outputs_filtered_not_include_freeze(alicepub, include_spent)
for u in utxo:
# print(u)
u.pop('details')
print('userA unspent asset:')
print(json.dumps(utxo, indent=4))
# print(json.load(utxo))
##################################################### 2.Freeze
# inputs and asset
cid = 0
condition = tx.to_dict()['transaction']['conditions'][cid]
inputs = Fulfillment.from_dict({
'fulfillment':
condition['condition']['details'],
'input': {
'cid': cid,
'txid': tx.to_dict()['id'],
},
'owners_before':
condition['owners_after'],
})
asset = Asset.from_dict(tx.to_dict()['transaction']['asset'])
# transfer
tx = Transaction.freeze_asset([inputs], [([alicepub], 90, True),
([alicepub], 10, False)], asset)
# sign with alice's private key
tx = tx.sign([alicepriv])
tx_id = tx.to_dict()['id']
# write to backlog
b = Bigchain()
b.write_transaction(tx)
print("========freeze 90 asset for userA ========")
print("========wait for block and vote...========")
# wait 2 sec
sleep(5)
# get tx by id
tx = b.get_transaction(tx_id)
print("freeze 90 asset tx2_id:" + tx.to_dict()['id'])
##################################################### 3.UTXO
# inputs and asset
utxo = b.get_outputs_filtered_not_include_freeze(alicepub, include_spent)
for u in utxo:
# print(u)
u.pop('details')
print('userA unspent asset:')
print(json.dumps(utxo, indent=4))
