def createBRTX(addressRSMC, addressOther, balanceSelf, RSMCScript, asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_RSMC = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressRSMC).Data)
outputTo = TransactionAttribute(usage=TransactionAttributeUsage.Remark1,
data=ToAddresstHash(addressOther).Data)
txAttributes = [address_hash_RSMC, time_stamp, outputTo]
op_data_to_other = create_opdata(address_from=addressRSMC,
address_to=addressOther,
value=balanceSelf,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_other)
return {
"txData":
tx.get_tx_data(),
"txId":
createTxid(tx.get_tx_data()),
"witness":
"01{blockheight_script}40{signOther}40{signSelf}fd" +
createVerifyScript(RSMCScript)
}
def createTx(addressFrom,addressTo,value,assetId):
if assetId == setting.NEO_ASSETID or assetId == setting.GAS_ASSETID:
if not _check_balance(address=addressFrom,assetId=assetId,value=value):
raise Exception("no enough balance")
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
address_hash = TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFrom).Data)
txAttributes = [address_hash,time_stamp]
inputs,inputs_total=_get_inputs(address=addressFrom,assetId=assetId,value=value)
outputs = _get_outputs(addressFrom=addressFrom,addressTo=addressTo,value=value,
assetId=assetId,inputs_total=inputs_total)
tx = ContractTransaction()
tx.inputs = inputs
tx.outputs = outputs
tx.Attributes = txAttributes
return {
"txData":tx.get_tx_data(),
"txid": createTxid(tx.get_tx_data()),
"witness": "014140{signature}2321{pubkey}ac"
}
else :
if len(assetId) != 42:
return {}
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
address_hash = TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFrom).Data)
txAttributes = [address_hash,time_stamp]
op_data = create_opdata(address_from=addressFrom, address_to=addressTo, value=value,
contract_hash=assetId)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data)
return {
"txData": tx.get_tx_data(),
"txid": createTxid(tx.get_tx_data()),
"witness":"014140{signature}2321{pubkey}ac"
}
def _createOutput(assetId, amount, address):
assetId = UInt256(data=binascii.unhexlify(hex_reverse(assetId)))
f8amount = Fixed8.TryParse(amount, require_positive=True)
address_hash = ToAddresstHash(address)
return TransactionOutput(AssetId=assetId,
Value=f8amount,
script_hash=address_hash)
def createMultiTx(addressFrom, addressTo, value, assetId):
if assetId == setting.CONTRACTHASH:
time_stamp = TransactionAttribute(
usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
address_hash = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFrom).Data)
txAttributes = [address_hash, time_stamp]
op_data = create_opdata(address_from=addressFrom,
address_to=addressTo,
value=value,
contract_hash=assetId)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data * 3)
return {
"txData": tx.get_tx_data(),
"txId": createTxid(tx.get_tx_data())
}
else:
return None
def createHERDTX(addressReceiver, HTLCValue, HETxId, RSMCScript,asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
pre_txid = TransactionAttribute(usage=TransactionAttributeUsage.Remark1, data=bytearray.fromhex(
hex_reverse(HETxId)))
outputTo = TransactionAttribute(usage=TransactionAttributeUsage.Remark2,
data=ToAddresstHash(addressReceiver).Data)
txAttributes = [time_stamp, pre_txid, outputTo]
tx = ContractTransaction()
RSMC_inputs = [tx.createInput(preHash=HETxId, preIndex=0)]
output_to_receiver = tx.createOutput(assetId=asset_id, amount=HTLCValue, address=addressReceiver)
tx.inputs = RSMC_inputs
tx.outputs = [output_to_receiver]
tx.Attributes = txAttributes
return {
"txData": tx.get_tx_data(),
"txId": createTxid(tx.get_tx_data()),
"witness": "01{blockheight_script}40{signReceiver}40{signSender}fd"+createVerifyScript(RSMCScript)
}
def createBRTX(addressOther,balanceSelf,RSMCScript,CTxId,asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
outputTo = TransactionAttribute(usage=TransactionAttributeUsage.Remark1, data=ToAddresstHash(addressOther).Data)
txAttributes = [time_stamp,outputTo]
tx = ContractTransaction()
RSMC_inputs=[tx.createInput(preHash=CTxId, preIndex=0)]
output_to_other= tx.createOutput(assetId=asset_id, amount=balanceSelf,address=addressOther)
tx.inputs = RSMC_inputs
tx.outputs = [output_to_other]
tx.Attributes = txAttributes
return {
"txData":tx.get_tx_data(),
"txId":createTxid(tx.get_tx_data()),
"witness": "01{blockheight_script}40{signOther}40{signSelf}fd" + createVerifyScript(RSMCScript)
}
def createHTDTX(addressHTLC, pubkeySender, HTLCValue, HTLCScript, asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_HTLC = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressHTLC).Data)
txAttributes = [address_hash_HTLC, time_stamp]
op_data_to_sender = create_opdata(address_from=addressHTLC,
address_to=pubkeyToAddress(pubkeySender),
value=HTLCValue,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_sender)
return {
"txData":
tx.get_tx_data(),
"txId":
createTxid(tx.get_tx_data()),
"witness":
"01{R_script}40{signOther}40{signSelf}fd" +
createVerifyScript(HTLCScript)
}
def createRefundTX(addressFunding, balanceSelf, balanceOther, pubkeySelf,
pubkeyOther, fundingScript, asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_funding = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFunding).Data)
txAttributes = [address_hash_funding, time_stamp]
op_data_to_self = create_opdata(address_from=addressFunding,
address_to=pubkeyToAddress(pubkeySelf),
value=balanceSelf,
contract_hash=asset_id)
op_data_to_other = create_opdata(address_from=addressFunding,
address_to=pubkeyToAddress(pubkeyOther),
value=balanceOther,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_self + op_data_to_other)
return {
"txData": tx.get_tx_data(),
"txId": createTxid(tx.get_tx_data()),
"witness": "018240{signSelf}40{signOther}da" + fundingScript
}
def create_sender_HCTX(pubkeySender, pubkeyReceiver, HTLCValue, balanceSender,
balanceReceiver, hashR, addressFunding, fundingScript,
asset_id):
RSMCContract = createRSMCContract(
hashSelf=pubkeyToAddressHash(pubkeySender),
pubkeySelf=pubkeySender,
hashOther=pubkeyToAddressHash(pubkeyReceiver),
pubkeyOther=pubkeyReceiver,
magicTimestamp=time.time())
HTLCContract = createHTLCContract(pubkeySelf=pubkeySender,
pubkeyOther=pubkeyReceiver,
futureTimestamp=int(time.time()) + 600,
hashR=hashR)
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_funding = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFunding).Data)
txAttributes = [address_hash_funding, time_stamp]
op_data_to_HTLC = create_opdata(address_from=addressFunding,
address_to=HTLCContract["address"],
value=HTLCValue,
contract_hash=asset_id)
op_data_to_RSMC = create_opdata(address_from=addressFunding,
address_to=RSMCContract["address"],
value=balanceSender,
contract_hash=asset_id)
op_data_to_receiver = create_opdata(
address_from=addressFunding,
address_to=pubkeyToAddress(pubkeyReceiver),
value=balanceReceiver,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_RSMC + op_data_to_receiver +
op_data_to_HTLC)
return {
"txData": tx.get_tx_data(),
"addressRSMC": RSMCContract["address"],
"addressHTLC": HTLCContract["address"],
"RSMCscript": RSMCContract["script"],
"HTLCscript": HTLCContract["script"],
"txId": createTxid(tx.get_tx_data()),
"witness": "018240{signSelf}40{signOther}da" + fundingScript
}
def createHERDTX(addressRSMC, addressReceiver, HTLCValue, HETxId, RSMCScript,
asset_id):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_RSMC = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressRSMC).Data)
pre_txid = TransactionAttribute(usage=TransactionAttributeUsage.Remark1,
data=bytearray.fromhex(
hex_reverse(HETxId)))
outputTo = TransactionAttribute(usage=TransactionAttributeUsage.Remark2,
data=ToAddresstHash(addressReceiver).Data)
txAttributes = [address_hash_RSMC, time_stamp, pre_txid, outputTo]
op_data_to_receiver = create_opdata(address_from=addressRSMC,
address_to=addressReceiver,
value=HTLCValue,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_receiver)
return {
"txData":
tx.get_tx_data(),
"txId":
createTxid(tx.get_tx_data()),
"witness":
"01{blockheight_script}40{signReceiver}40{signSender}fd" +
createVerifyScript(RSMCScript)
}
def construct_multi_tx(addressFrom, targetList, assetId):
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash = TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressFrom).Data)
txAttributes = [address_hash, time_stamp]
op_data = ""
for item in targetList:
op_data += create_opdata(address_from=addressFrom,
address_to=item[0],
value=item[1],
contract_hash=assetId)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data)
return {"txData": tx.get_tx_data(), "txid": createTxid(tx.get_tx_data())}
def createHETX(addressHTLC, pubkeySender, pubkeyReceiver, HTLCValue,
HTLCScript, asset_id):
RSMCContract = createRSMCContract(
hashSelf=pubkeyToAddressHash(pubkeyReceiver),
pubkeySelf=pubkeyReceiver,
hashOther=pubkeyToAddressHash(pubkeySender),
pubkeyOther=pubkeySender,
magicTimestamp=time.time())
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_HTLC = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(addressHTLC).Data)
txAttributes = [address_hash_HTLC, time_stamp]
op_data_to_RSMC = create_opdata(address_from=addressHTLC,
address_to=RSMCContract["address"],
value=HTLCValue,
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_data_to_RSMC)
return {
"txData":
tx.get_tx_data(),
"txId":
createTxid(tx.get_tx_data()),
"addressRSMC":
RSMCContract["address"],
"RSMCscript":
RSMCContract["script"],
"witness":
"01{R_script}40{signOther}40{signSelf}fd" +
createVerifyScript(HTLCScript)
}
def createFundingTx(walletSelf,walletOther,asset_id):
'''
:param walletSelf: dict {
"pubkey":"",
"deposit":0,
"assetId":"0x00000"
}
:param walletOhter: dict {
"pubkey":"",
"deposit":0,
"assetId":"0x00000"
:return:
'''
multi_contract = createMultiSigContract(walletSelf["pubkey"],walletOther["pubkey"])
contractAddress = multi_contract["address"]
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(hex(int(time.time()))[2:]))
txAttributes = [time_stamp]
tx = ContractTransaction()
walletSelf_vouts=get_vout_by_address(pubkeyToAddress(walletSelf["pubkey"]),walletSelf["deposit"],asset_id)
if not walletSelf_vouts:
return None
walletOther_vouts=get_vout_by_address(pubkeyToAddress(walletOther["pubkey"]),walletOther["deposit"],asset_id)
if not walletOther_vouts:
return None
self_inputs=[tx.createInput(preHash=item[0], preIndex=item[2]) for item in walletSelf_vouts ]
other_inputs=[tx.createInput(preHash=item[0], preIndex=item[2]) for item in walletOther_vouts ]
output_to_fundingaddress = tx.createOutput(assetId=asset_id, amount=walletSelf["deposit"]+walletOther["deposit"],
address=contractAddress)
self_inputs_total=0
other_inputs_total=0
for item in walletSelf_vouts:
self_inputs_total+=item[1]
for item in walletOther_vouts:
other_inputs_total+=item[1]
output_to_self= tx.createOutput(assetId=asset_id, amount=self_inputs_total-walletSelf["deposit"],
address=pubkeyToAddress(walletSelf["pubkey"])) if self_inputs_total>walletSelf["deposit"] \
else None
output_to_other= tx.createOutput(assetId=asset_id, amount=other_inputs_total-walletOther["deposit"],
address=pubkeyToAddress(walletOther["pubkey"])) if other_inputs_total>walletOther["deposit"] \
else None
tx.inputs = self_inputs+other_inputs
tx.outputs = [item for item in (output_to_fundingaddress,output_to_self,output_to_other) if item]
tx.Attributes = txAttributes
hash_self=ToAddresstHash(pubkeyToAddress(walletSelf["pubkey"]))
hash_other=ToAddresstHash(pubkeyToAddress(walletOther["pubkey"]))
if hash_self > hash_other:
witness = "024140{signOther}2321"+walletOther["pubkey"]+"ac"+"4140{signSelf}2321"+walletSelf["pubkey"]+"ac"
else:
witness = "024140{signSelf}2321"+walletSelf["pubkey"]+"ac"+"4140{signOther}2321"+walletOther["pubkey"]+"ac"
return {
"txData":tx.get_tx_data(),
"addressFunding":contractAddress,
"txId": createTxid(tx.get_tx_data()),
"scriptFunding":multi_contract["script"],
"witness":witness
}
def createFundingTx(walletSelf, walletOther, asset_id):
'''
:param walletSelf: dict {git
"pubkey":"",
"deposit":0
}
:param walletOhter: dict {
"pubkey":"",
"deposit":0
:return:
'''
multi_contract = createMultiSigContract(walletSelf["pubkey"],
walletOther["pubkey"])
contractAddress = multi_contract["address"]
time_stamp = TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=bytearray.fromhex(
hex(int(time.time()))[2:]))
address_hash_self = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(pubkeyToAddress(walletSelf["pubkey"])).Data)
address_hash_other = TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=ToAddresstHash(pubkeyToAddress(walletOther["pubkey"])).Data)
txAttributes = [address_hash_self, address_hash_other, time_stamp]
op_dataSelf = create_opdata(address_from=pubkeyToAddress(
walletSelf["pubkey"]),
address_to=contractAddress,
value=walletSelf["deposit"],
contract_hash=asset_id)
op_dataOther = create_opdata(address_from=pubkeyToAddress(
walletOther["pubkey"]),
address_to=contractAddress,
value=walletOther["deposit"],
contract_hash=asset_id)
tx = InvocationTransaction()
tx.Version = 1
tx.Attributes = txAttributes
tx.Script = binascii.unhexlify(op_dataSelf + op_dataOther)
hash_self = ToAddresstHash(pubkeyToAddress(walletSelf["pubkey"]))
hash_other = ToAddresstHash(pubkeyToAddress(walletOther["pubkey"]))
if hash_self > hash_other:
witness = "024140{signOther}2321" + walletOther[
"pubkey"] + "ac" + "4140{signSelf}2321" + walletSelf[
"pubkey"] + "ac"
else:
witness = "024140{signSelf}2321" + walletSelf[
"pubkey"] + "ac" + "4140{signOther}2321" + walletOther[
"pubkey"] + "ac"
return {
"txData": tx.get_tx_data(),
"addressFunding": contractAddress,
"txId": createTxid(tx.get_tx_data()),
"scriptFunding": multi_contract["script"],
"witness": witness
}