multisig/MultiSig.cpp

Implementation of the standalone multi-signature primitive. More...

Namespaces

Name
sgns
sgns::multisig

Functions

	Name
bool	VerifyPayloadSignature(const std::string & address, const SignatureBytes & signature, const std::vector< uint8_t > & payload) Verifies a signature over an arbitrary raw-byte payload. Delegates entirely to GeniusAccount::VerifySignature; no custom crypto or signing-bytes construction is performed here (the payload is assumed already-canonical).

Detailed Description

Implementation of the standalone multi-signature primitive.

Date: 2026-07-21 Henrique A. Klein ([email protected])

Functions Documentation

function VerifyPayloadSignature

bool VerifyPayloadSignature(
    const std::string & address,
    const SignatureBytes & signature,
    const std::vector< uint8_t > & payload
)

Verifies a signature over an arbitrary raw-byte payload. Delegates entirely to GeniusAccount::VerifySignature; no custom crypto or signing-bytes construction is performed here (the payload is assumed already-canonical).

Parameters:

• address Public address (hex-encoded public key) the signature is claimed to be from.
• signature Raw signature bytes to verify.
• payload Raw payload bytes the signature is claimed to cover.

Return: true if the signature is valid for the given address and payload, false otherwise (including malformed address or incorrectly sized signature).

Source code

#include "multisig/MultiSig.hpp"

#include "account/GeniusAccount.hpp"

namespace sgns::multisig
{
    bool VerifyPayloadSignature( const std::string          &address,
                                 const SignatureBytes       &signature,
                                 const std::vector<uint8_t> &payload )
    {
        return sgns::GeniusAccount::VerifySignature( address, signature, payload );
    }

    MultiSig::MultiSig( const std::vector<std::string> &signer_set, uint64_t required_signatures ) :
        signer_set_( signer_set.begin(), signer_set.end() ), required_signatures_( required_signatures )
    {
    }

    bool MultiSig::IsValid() const
    {
        return required_signatures_ > 0 && required_signatures_ <= signer_set_.size();
    }

    uint64_t MultiSig::RequiredSignatures() const
    {
        return required_signatures_;
    }

    size_t MultiSig::AuthorizedSignerCount() const
    {
        return signer_set_.size();
    }

    QuorumResult MultiSig::EvaluateQuorum( const CollectedSignatures  &collected_signatures,
                                           const std::vector<uint8_t> &payload ) const
    {
        QuorumResult result;
        if ( !IsValid() )
        {
            return result;
        }

        std::unordered_set<std::string> valid_unique_signers;

        for ( const auto &[address, signature] : collected_signatures )
        {
            if ( valid_unique_signers.count( address ) != 0 )
            {
                continue; // dedup-first: already counted this signer, skip before verification
            }
            if ( signer_set_.count( address ) == 0 )
            {
                continue; // unauthorized signer
            }
            if ( !VerifyPayloadSignature( address, signature, payload ) )
            {
                continue; // invalid signature, skip silently
            }
            valid_unique_signers.insert( address );
        }

        result.valid_unique_count = valid_unique_signers.size();
        result.has_quorum         = valid_unique_signers.size() >= required_signatures_;
        return result;
    }
} // namespace sgns::multisig

---

Updated on 2026-08-06 at 13:59:19 +0000