Dev Release 15

Hey BlockDAG Community,

As we are moving forward with our implementations in our BlockDAG project, we are also looking into the security for our end user. So our developers are also working on MultiSig Module implementation.

Multisig transactions offer enhanced security for blockDAG ecosystems by requiring multiple parties to authorize spending. Here's a detailed breakdown of implementing multisig in blockDAG, incorporating technical details and specific algorithms:

Transaction Structure:
 

• Inputs: These reference previous transactions in the blockDAG that spend to the current multisig address. Each input includes the previous transaction hash, output index, and the signature script (explained later).
• Outputs: Specify the recipients and amount of cryptocurrency being distributed.
• Signatures: Each participating party signs the transaction using their private key. The signature script specifies how these signatures are combined to authorize spending.
• Metadata: Optional data attached to the transaction, potentially including timestamps, transaction fees, or additional information relevant to the specific blockDAG protocol.

Signature Script:
The signature script plays a crucial role in multisig transactions. It's a script written in a stack-based scripting language like Forth embedded within the transaction. This script defines the multisig conditions for spending:
 

• Public Keys: The script includes the public keys of all parties involved in the multisig.
• Threshold (M): Defines the minimum number of signatures required (M-of-N) to authorize spending.
• Locking Script: This script specifies the cryptographic operation required to unlock the funds. In multisig, it typically involves verifying a specific number of valid signatures against the listed public keys.

Algorithms:

• ECDSA (Elliptic Curve Digital Signature Algorithm): Used for signing transactions with private keys and verifying signatures with public keys.
• SHA-256 (Secure Hash Algorithm 256): This cryptographic hash function can be used within the redeem script to generate unique identifiers for multisig addresses based on public keys and the locking script.

Signature Validation and Redeem Script Processing:
 

1. Miners or validators in the blockDAG network retrieve the transaction.
2. They locate the referenced transactions (inputs) and verify their validity.
3. The signature script within each input is parsed.
4. The script engine executes the redeem script, verifying:

• Presence of all required public keys (N).
• Validity of each signature (M) against their corresponding public keys using ECDSA.

Scripting Language Considerations:
 

• Existing scripting languages used in blockchains like Bitcoin Script can be adapted for blockDAGs with modifications to handle the specific DAG structure and consensus mechanisms.
• Alternatively, a new scripting language can be designed specifically for the blockDAG, potentially offering more flexibility and features tailored to multisig transactions.

Transaction Propagation and Confirmation:
 

• BlockDAG networks need to modify their transaction propagation and confirmation processes to handle multisig transactions.
• Consensus rules must be adapted to ensure all validators agree on the validity of multisig transactions based on the redeem script conditions.

This outlines a high-level algorithmic approach for implementing multisig transactions in a blockDAG system, focusing on core cryptographic operations and validation logic:

1. Multisig Address Generation Algorithm:
Input: Public keys (Pk_1, Pk_2, ..., Pk_N) of participating parties and threshold (M) for required signatures.
Output: Multisig address (M-of-N address).

Steps:

1. Hashing Public Keys: Compute a cryptographic hash (H) of each public key (Pk_i).
2. Concatenation: Concatenate the hashed public keys (H(Pk_1) || H(Pk_2) || ... || H(Pk_N)) and threshold (M) into a single data string (Data).
3. Final Hash: Apply another cryptographic hash function (H') to the Data string to generate a unique identifier.
4. Address Derivation: Encode the resulting hash (H'(Data)) and additional information (e.g., network prefix) to form the final multisig address.

2. Multisig Transaction Validation Algorithm:
Input: Transaction object (Tx) containing inputs, outputs, and signatures.
Output: Boolean (True if valid, False otherwise).

Steps:

1. Iterate over Inputs: For each input (Tx_in) in the transaction:

• Extract the signature script (ScriptSig) from Tx_in.
• Parse the ScriptSig to extract:
• Public key index (index_i) referencing a public key (Pk_i) from the redeem script.
• Signature (Sig_i) of the corresponding party.

1. Retrieve Redeem Script: Locate the redeem script associated with the multisig address referenced in the transaction.
2. Parse Redeem Script: Extract the following from the redeem script:

• Public keys (Pk_1, Pk_2, ..., Pk_N) involved in the multisig.
• Threshold (M) required number of signatures.

1. Signature Verification: For each extracted signature (Sig_i):

• Use the corresponding public key (Pk_i) retrieved from the redeem script (based on index_i).
• Verify Sig_i using ECDSA with the previous transaction hash referenced in Tx_in.

1. Signature Count: Check if the total number of valid signatures (verified_count) is equal to the threshold (M) defined in the redeem script.
2. Output Validation: Perform additional validation specific to the blockDAG protocol (e.g., checking for sufficient funds in referenced outputs).

7. Return True if all steps succeed, False otherwise.
This algorithmic approach provides a foundational understanding of multisig transactions in blockDAGs. The specific implementation details like cryptographic hash functions (SHA-256, BLAKE2b) and script language syntax will vary depending on the chosen blockDAG platform.

Lets explore some pseudo-code on how keys are generated and transactions are signed :
// Multisignature Address Setup
function setupMultisig(m, n):
 keys = generateKeyPairs(n) // Generate n key pairs for authorized parties
 multisigAddress = generateMultisigAddress(keys, m, n) // Generate multisig address
 return multisigAddress// Transaction Signing
function signTransaction(transaction, privateKey):
 signature = sign(transaction, privateKey) // Sign transaction with private key
 return signatureMultisignature transactions offer several benefits, including:
 

• Enhanced Security: Unauthorized parties cannot spend funds without the required number of signatures.
• Redundancy: If one key is compromised or lost, the funds are still secure as long as the remaining authorized parties can provide their signatures.
• Trustless Cooperation: Multisignature addresses allow parties to collaborate without having to trust a single entity with control over the funds.

The current multisig implementation provides a secure foundation for multi-party transactions in blockDAGs. Future development will focus on integrating smart contracts to enable more sophisticated spending logic and unlock the full potential of decentralized applications on the blockDAG platform