synapsecns/sanguine

package types

import (
    "bytes"
    "encoding/gob"
    "fmt"
    "github.com/ethereum/go-ethereum/common"
)

// Proof is a merkle proof object. The leaf it's path to the root and its index in the tree.
type Proof interface {
    // Leaf is the leaf in the proof
    Leaf() common.Hash
    // Index is the index in the tree
    Index() uint32
    // Path is the merkle branch
    Path() common.Hash
    // Encode encodes a message
    Encode() ([]byte, error)
}

// proofImpl implements the merkle proof.
type proofImpl struct {
    leaf  common.Hash
    index uint32
    path  common.Hash
}

// ProofEncoder is exported to allow proofs to be encoded/deoded from binary.
type ProofEncoder struct {
    Leaf  common.Hash
    Index uint32
    Path  common.Hash
}

// NewProof creates a new merkle proof.
func NewProof(leaf common.Hash, index uint32, path common.Hash) Proof {
    return proofImpl{
        leaf:  leaf,
        index: index,
        path:  path,
    }
}

// DecodeProof decodes a proof.
func DecodeProof(rawProof []byte) (Proof, error) {
    dec := gob.NewDecoder(bytes.NewReader(rawProof))

    var proofEncoder ProofEncoder
    err := dec.Decode(&proofEncoder)
    if err != nil {
        return nil, fmt.Errorf("could not decode proof: %w", err)
    }

    return proofImpl{
        leaf:  proofEncoder.Leaf,
        index: proofEncoder.Index,
        path:  proofEncoder.Path,
    }, nil
}

func (p proofImpl) Leaf() common.Hash {
    return p.leaf
}

func (p proofImpl) Index() uint32 {
    return p.index
}

func (p proofImpl) Path() common.Hash {
    return p.path
}

func (p proofImpl) Encode() ([]byte, error) {
    var res bytes.Buffer
    enc := gob.NewEncoder(&res)

    proofEncoder := ProofEncoder{
        Leaf:  p.leaf,
        Index: p.index,
        Path:  p.path,
    }

    err := enc.Encode(proofEncoder)
    if err != nil {
        return nil, fmt.Errorf("could not encode %T: %w", p, err)
    }
    return res.Bytes(), nil
}