add txmass calc endpoint

Author: x100111010

endpoints/get_transaction_mass.py

@@ -0,0 +1,72 @@
+from fastapi import HTTPException
+from pydantic import BaseModel
+
+from endpoints.get_transactions import search_for_transactions, TxSearch
+from endpoints.spectred_requests.submit_transaction_request import SubmitTxModel
+from helper.mass_calculation_compute import calc_compute_mass
+from helper.mass_calculation_storage import calc_storage_mass
+from server import app
+
+
+class TxMass(BaseModel):
+    mass: int
+    storage_mass: int
+    compute_mass: int
+
+
+def _get_amount_from_tx_output_index(txs, tx_id, output_index: int):
+    for tx in txs:
+        if tx["transaction_id"] == tx_id:
+            for output in tx["outputs"]:
+                if output.index == output_index:
+                    return output.amount
+
+
+@app.post(
+    "/transactions/mass",
+    response_model=TxMass,
+    tags=["Spectre transactions"],
+    response_model_exclude_unset=True,
+)
+async def calculate_transaction_mass(tx: SubmitTxModel):
+    """
+    This function calculates and returns the mass of a transaction, which is essential for determining the minimum fee. The mass calculation takes into account the storage mass as defined in KIP-0009.
+
+    Note: Be aware that if the transaction has a very low output amount or a high number of outputs, the mass can become significantly large.
+    """
+    previous_outpoints = [input.previousOutpoint for input in tx.inputs]
+
+    txs = list(
+        await search_for_transactions(
+            TxSearch(
+                transactionIds=list([x.transactionId for x in previous_outpoints])
+            ),
+            "",
+            False,
+        )
+    )
+
+    if len(txs) != len(previous_outpoints):
+        raise HTTPException(
+            status_code=404, detail="Previous outpoint(s) not found in database."
+        )
+
+    tx_input_amounts = [
+        _get_amount_from_tx_output_index(
+            txs,
+            previous_outpoint.transactionId,
+            previous_outpoint.index,
+        )
+        for previous_outpoint in previous_outpoints
+    ]
+
+    tx_output_amounts = [output.amount for output in tx.outputs]
+
+    storage_mass = calc_storage_mass(tx_input_amounts, tx_output_amounts)
+    compute_mass = calc_compute_mass(tx.dict())
+
+    return TxMass(
+        mass=max(storage_mass, compute_mass),
+        storage_mass=storage_mass,
+        compute_mass=compute_mass,
+    )

helper/mass_calculation_compute.py

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+MASS_PER_TX_BYTE = 1
+MASS_PER_SCRIPT_PUB_KEY_BYTE = 10
+MASS_PER_SIG_OP = 1000
+
+MAXIMUM_STANDARD_TRANSACTION_MASS = 100_000
+
+
+def outpoint_size(tx_input_outpoint):
+    """
+    size for outpoint
+    """
+    size = 0
+    size += 32  # one HASH_SIZE constant
+    size += 4  # Index
+    return size
+
+
+def tx_output_serialized(tx_output):
+    """
+    size for each output
+    """
+    size = 0
+    size += 8  # value
+    size += 2  # scriptpubkey version
+    size += 8  # length of script pub key
+    size += len(tx_output["scriptPublicKey"]["scriptPublicKey"]) / 2
+    return size
+
+
+def tx_input_serialized(tx_input):
+    """
+    size for each input
+    """
+    size = 0
+    size += outpoint_size(tx_input)  # previous outpoint size
+    size += 8  # length of signature script
+    size += len(tx_input["signatureScript"]) / 2
+    size += 8  # sequence
+    return size
+
+
+def tx_serialized_size(tx):
+    size = 0
+    size += 2  # 2 bytes for tx version
+    size += 8  # count of inputs
+    size += sum([tx_input_serialized(x) for x in tx["inputs"]])
+    size += 8  # count of outputs
+    size += sum([tx_output_serialized(x) for x in tx["outputs"]])
+    size += 8  # lock time
+    size += 20  # subnetwork id size
+    size += 8  # gas
+    size += 32  # hash size payload hash
+    size += 8  # length of the payload
+    size += len(tx.get("payload", "")) / 2  # length of payload
+
+    return size
+
+
+def calc_compute_mass(tx):
+    """
+    Calculate mass for a TX-OBJECT
+    :param tx:
+    :return:
+    """
+    if tx["subnetworkId"] == "0100000000000000000000000000000000000000":
+        return 0
+
+    # get the size of serialized tx
+    size = tx_serialized_size(tx)
+
+    # calc mass for serialized tx
+    mass = size * MASS_PER_TX_BYTE
+
+    # count ALL outputs (script public key version + script public key)
+    total_script_public_key_sum = sum(
+        [2 + (len(x["scriptPublicKey"]["scriptPublicKey"]) / 2) for x in tx["outputs"]]
+    )
+
+    # calc sum
+    total_script_public_key_mass = (
+        MASS_PER_SCRIPT_PUB_KEY_BYTE * total_script_public_key_sum
+    )
+
+    # calc mass for all inputs with sigOpCount
+    total_sigops_mass = MASS_PER_SIG_OP * sum([x["sigOpCount"] for x in tx["inputs"]])
+    return int(mass + total_script_public_key_mass + total_sigops_mass)

helper/mass_calculation_storage.py

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+# Storage mass constant
+C = 10**12
+
+
+def _negative_mass(inputs, outputs_num):
+    """
+    Calculates the negative component of the storage mass formula. Note that there is no dependency on output
+    values but only on their count. The code is designed to maximize precision and to avoid intermediate overflows.
+    """
+    inputs_num = len(inputs)
+    if outputs_num == 1 or inputs_num == 1 or (outputs_num == 2 and inputs_num == 2):
+        return sum(C // v for v in inputs)
+    return inputs_num * (C // (sum(inputs) // inputs_num))
+
+
+def calc_storage_mass(inputs, outputs):
+    """
+    Calculates the storage mass for the provided input/output collections
+    """
+    N = _negative_mass(inputs, outputs_num=len(outputs))
+    P = sum(C // o for o in outputs)
+    return max(P - N, 0)

main.py

@@ -22,6 +22,7 @@
 from endpoints.get_hashrate import get_hashrate
 from endpoints.get_health import health_state
 from endpoints.get_marketcap import get_marketcap
+from endpoints.get_transaction_mass import calculate_transaction_mass
 from endpoints.get_transactions import get_transaction
 from endpoints.get_virtual_chain_blue_score import (
     get_virtual_selected_parent_blue_score,
@@ -39,7 +40,7 @@
     f"{get_spectred_info}, {get_network}, {get_fee_estimate}, {get_marketcap}, {get_hashrate}, {get_blockreward}"
     f"{get_halving} {health_state} {get_transaction}"
     f"{get_virtual_selected_parent_blue_score} {get_transactions_for_address}"
-    f"{submit_a_new_transaction} {get_price}"
+    f"{submit_a_new_transaction} {calculate_transaction_mass} {get_price}"
 )
 
 if os.getenv("VSPC_REQUEST") == "true":