async def init_transaction(self, tsx_data, tsx_ctr):
"""
Initializes a new transaction.
:param tsx_data:
:param tsx_ctr:
:return:
"""
self.tsx_data = tsx_data
self.gen_r()
# Additional keys
class_res = classify_subaddresses(
tsx_data.outputs, tsx_data.change_dts.addr if tsx_data.change_dts else None
)
num_stdaddresses, num_subaddresses, single_dest_subaddress = class_res
# if this is a single-destination transfer to a subaddress, we set the tx pubkey to R=s*D
if num_stdaddresses == 0 and num_subaddresses == 1:
self.r_pub = crypto.ge_scalarmult(
self.r, crypto.decodepoint(single_dest_subaddress.m_spend_public_key)
)
self.need_additional_txkeys = num_subaddresses > 0 and (
num_stdaddresses > 0 or num_subaddresses > 1
)
if self.need_additional_txkeys:
for _ in range(len(tsx_data.outputs)):
self.additional_tx_keys.append(crypto.random_scalar())
# Extra processing, payment id
self.tx.version = 2
self.tx.unlock_time = tsx_data.unlock_time
await self.process_payment_id()
await self.compute_hmac_keys(tsx_ctr)
def generate_key_image(public_key, secret_key):
"""
Key image: secret_key * H_p(pub_key)
:param public_key: encoded point
:param secret_key:
:return:
"""
point = crypto.hash_to_ec(public_key)
point2 = crypto.ge_scalarmult(secret_key, point)
return point2
async def _set_out1_additional_keys(self, dst_entr):
additional_txkey = None
additional_txkey_priv = None
if self.need_additional_txkeys:
use_provided = self.num_dests() == len(self.additional_tx_private_keys)
additional_txkey_priv = (
self.additional_tx_private_keys[self.out_idx]
if use_provided
else crypto.random_scalar()
)
if dst_entr.is_subaddress:
additional_txkey = crypto.ge_scalarmult(
additional_txkey_priv,
crypto.decodepoint(dst_entr.addr.m_spend_public_key),
)
else:
additional_txkey = crypto.ge_scalarmult_base(additional_txkey_priv)
self.additional_tx_public_keys.append(crypto.encodepoint(additional_txkey))
if not use_provided:
self.additional_tx_private_keys.append(additional_txkey_priv)
return additional_txkey_priv
async def set_out1(self, dst_entr):
"""
Set destination entry
:param src_entr
:type src_entr: xmrtypes.TxDestinationEntry
:return:
"""
self.out_idx += 1
change_addr = (
self.tsx_data.change_dts.addr if self.tsx_data.change_dts else None
)
if dst_entr.amount <= 0 and self.tx.version <= 1:
raise ValueError("Destination with wrong amount: %s" % dst_entr.amount)
if self.need_additional_txkeys:
if dst_entr.is_subaddress:
additional_txkey = crypto.ge_scalarmult(
self.additional_tx_keys[self.out_idx],
crypto.decodepoint(dst_entr.addr.m_spend_public_key),
)
else:
additional_txkey = crypto.ge_scalarmult_base(
self.additional_tx_keys[self.out_idx]
)
self.additional_tx_public_keys.append(additional_txkey)
if change_addr and dst_entr.addr == change_addr:
# sending change to yourself; derivation = a*R
derivation = monero.generate_key_derivation(
self.r_pub, self.creds.view_key_private
)
else:
# sending to the recipient; derivation = r*A (or s*C in the subaddress scheme)
deriv_priv = (
self.additional_tx_keys[self.out_idx]
if dst_entr.is_subaddress and self.need_additional_txkeys
else self.r
)
derivation = monero.generate_key_derivation(
crypto.decodepoint(dst_entr.addr.m_view_public_key), deriv_priv
)
amount_key = crypto.derivation_to_scalar(derivation, self.out_idx)
tx_out_key = crypto.derive_public_key(
derivation,
self.out_idx,
crypto.decodepoint(dst_entr.addr.m_spend_public_key),
)
tk = xmrtypes.TxoutToKey(key=crypto.encodepoint(tx_out_key))
tx_out = xmrtypes.TxOut(amount=dst_entr.amount, target=tk)
self.tx.vout.append(tx_out)
self.summary_outs_money += dst_entr.amount
self.output_secrets.append((amount_key,))
# Last output?
if self.out_idx + 1 == len(self.tsx_data.outputs):
await self.all_out1_set()
async def init_transaction(self, tsx_data, tsx_ctr):
"""
Initializes a new transaction.
:param tsx_data:
:type tsx_data: TsxData
:param tsx_ctr:
:return:
"""
from monero_glue.xmr.sub.addr import classify_subaddresses
self.gen_r()
self.state.init_tsx()
self._log_trace(1)
# Ask for confirmation
confirmation = await self.trezor.iface.confirm_transaction(tsx_data, self.creds)
if not confirmation:
from monero_glue.messages import FailureType
from monero_glue.messages.Failure import Failure
return Failure(code=FailureType.ActionCancelled, message="rejected")
gc.collect()
self._log_trace(3)
# Basic transaction parameters
self.input_count = tsx_data.num_inputs
self.output_count = len(tsx_data.outputs)
self.output_change = misc.dst_entry_to_stdobj(tsx_data.change_dts)
self.mixin = tsx_data.mixin
self.fee = tsx_data.fee
self.use_simple_rct = self.input_count > 1
self.use_bulletproof = tsx_data.is_bulletproof
self.multi_sig = tsx_data.is_multisig
self.state.inp_cnt(self.in_memory())
self.check_change(tsx_data.outputs)
self.exp_tx_prefix_hash = common.defval_empty(tsx_data.exp_tx_prefix_hash, None)
# Provided tx key, used mostly in multisig.
if len(tsx_data.use_tx_keys) > 0:
for ckey in tsx_data.use_tx_keys:
crypto.check_sc(crypto.decodeint(ckey))
self.gen_r(use_r=crypto.decodeint(tsx_data.use_tx_keys[0]))
self.additional_tx_private_keys = [
crypto.decodeint(x) for x in tsx_data.use_tx_keys[1:]
]
# Additional keys w.r.t. subaddress destinations
class_res = classify_subaddresses(tsx_data.outputs, self.change_address())
num_stdaddresses, num_subaddresses, single_dest_subaddress = class_res
# if this is a single-destination transfer to a subaddress, we set the tx pubkey to R=s*D
if num_stdaddresses == 0 and num_subaddresses == 1:
self.r_pub = crypto.ge_scalarmult(
self.r, crypto.decodepoint(single_dest_subaddress.m_spend_public_key)
)
self.need_additional_txkeys = num_subaddresses > 0 and (
num_stdaddresses > 0 or num_subaddresses > 1
)
self._log_trace(4)
# Extra processing, payment id
self.tx.version = 2
self.tx.unlock_time = tsx_data.unlock_time
await self.process_payment_id(tsx_data)
await self.compute_sec_keys(tsx_data, tsx_ctr)
gc.collect()
# Iterative tx_prefix_hash hash computation
await self._tprefix_update()
gc.collect()
# Final message hasher
self.full_message_hasher.init(self.use_simple_rct)
await self.full_message_hasher.set_type_fee(self.get_rct_type(), self.get_fee())
# Sub address precomputation
if tsx_data.account is not None and tsx_data.minor_indices:
self.precompute_subaddr(tsx_data.account, tsx_data.minor_indices)
self._log_trace(5)
# HMAC outputs - pinning
hmacs = []
for idx in range(self.num_dests()):
c_hmac = await self.gen_hmac_tsxdest(tsx_data.outputs[idx], idx)
hmacs.append(c_hmac)
gc.collect()
self._log_trace(6)
from monero_glue.messages.MoneroTransactionInitAck import (
MoneroTransactionInitAck
)
return MoneroTransactionInitAck(
in_memory=self.in_memory(),
many_inputs=self.many_inputs(),
many_outputs=self.many_outputs(),
hmacs=hmacs,
)
def generate_sub_address_keys(view_sec, spend_pub, major, minor):
m = get_subaddress_secret_key(view_sec, major=major, minor=minor)
M = crypto.scalarmult_base(m)
D = crypto.point_add(spend_pub, M)
C = crypto.ge_scalarmult(view_sec, D)
return D, C