synapsecns/sanguine

package domains

import (
    "context"
    "errors"
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    ethTypes "github.com/ethereum/go-ethereum/core/types"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/event"
    "github.com/synapsecns/sanguine/agents/config"
    "github.com/synapsecns/sanguine/agents/contracts/summit"
    "github.com/synapsecns/sanguine/agents/contracts/test/pingpongclient"
    "github.com/synapsecns/sanguine/agents/types"
    "github.com/synapsecns/sanguine/ethergo/signer/signer"
)

// DomainClient represents a client used for interacting
// with contracts in a particular domain. The goal of a domain is that
// the particulars of interacting with an eth vs a solana contract are abstracted
// away and can be done through a set of common interfaces.
type DomainClient interface {
    // Name gets the name of the client. This can be used for logging.
    Name() string
    // Config gets the config that was used to create the client.
    Config() config.DomainConfig
    // BlockNumber gets the latest block
    BlockNumber(ctx context.Context) (uint32, error)
    // Origin retrieves a handle for the origin contract
    Origin() OriginContract
    // Summit is the summit
    Summit() SummitContract
    // Destination retrieves a handle for the destination contract
    Destination() DestinationContract
    // LightManager retrieves a handle for the light manager contract
    LightManager() LightManagerContract
    // BondingManager retrieves a handle for the bonding manager contract
    BondingManager() BondingManagerContract
    // LightInbox retrieves a handle for the light inbox contract
    LightInbox() LightInboxContract
    // Inbox retrieves a handle for the inbox contract
    Inbox() InboxContract
}

// OriginContract represents the origin contract on a particular chain.
type OriginContract interface {
    // IsValidState checks if the given state is valid on its origin.
    IsValidState(ctx context.Context, statePayload []byte) (isValid bool, err error)
    // SuggestLatestState gets the latest state on the origin
    SuggestLatestState(ctx context.Context) (types.State, error)
    // SuggestState gets the state on the origin with the given nonce if it exists
    SuggestState(ctx context.Context, nonce uint32) (types.State, error)
}

// SummitContract contains the interface for the summit.
type SummitContract interface {
    // GetLatestState gets the latest state signed by any guard for the given origin
    GetLatestState(ctx context.Context, origin uint32) (types.State, error)
    // GetLatestAgentState gets the latest state signed by the bonded signer for the given origin
    GetLatestAgentState(ctx context.Context, origin uint32, bondedAgentSigner signer.Signer) (types.State, error)
    // GetLatestNotaryAttestation gets the latest notary attestation signed by the notary and posted on Summit.
    GetLatestNotaryAttestation(ctx context.Context, notarySigner signer.Signer) (types.NotaryAttestation, error)
    // WatchAttestationSaved looks for attesation saved events
    WatchAttestationSaved(ctx context.Context, sink chan<- *summit.SummitAttestationSaved) (event.Subscription, error)
    // IsValidAttestation checks if the given attestation is valid on the summit
    IsValidAttestation(ctx context.Context, attestation []byte) (bool, error)
    // GetNotarySnapshot gets the snapshot payload corresponding to a given attestation
    GetNotarySnapshot(ctx context.Context, attPayload []byte) (types.Snapshot, error)
    // GetAttestation gets an attestation for a given attestationNonce.
    GetAttestation(ctx context.Context, attNonce uint32) (types.NotaryAttestation, error)
}

// InboxContract contains the interface for the inbox.
type InboxContract interface {
    // SubmitStateReportWithSnapshot reports to the inbox that a state within a snapshot is invalid.
    SubmitStateReportWithSnapshot(transactor *bind.TransactOpts, stateIndex uint8, signature signer.Signature, snapPayload []byte, snapSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitSnapshot submits a snapshot to the inbox (via the Inbox).
    SubmitSnapshot(transactor *bind.TransactOpts, encodedSnapshot []byte, signature signer.Signature) (tx *ethTypes.Transaction, err error)
    // VerifyAttestation verifies a snapshot on the inbox.
    VerifyAttestation(transactor *bind.TransactOpts, attestation []byte, attSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitStateReportWithAttestation submits a state report corresponding to an attesation for an invalid state.
    SubmitStateReportWithAttestation(transactor *bind.TransactOpts, stateIndex uint8, signature signer.Signature, snapPayload, attPayload, attSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitReceipt submits a receipt to the inbox.
    SubmitReceipt(transactor *bind.TransactOpts, rcptPayload []byte, rcptSignature signer.Signature, paddedTips *big.Int, headerHash [32]byte, bodyHash [32]byte) (tx *ethTypes.Transaction, err error)
    // VerifyReceipt verifies a receipt on the inbox.
    VerifyReceipt(transactor *bind.TransactOpts, rcptPayload []byte, rcptSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitReceiptReport submits a receipt report to the inbox.
    SubmitReceiptReport(transactor *bind.TransactOpts, rcptPayload []byte, rcptSignature []byte, rrSignature []byte) (tx *ethTypes.Transaction, err error)
}

// BondingManagerContract contains the interface for the bonding manager.
type BondingManagerContract interface {
    // GetAgentStatus returns the current agent status for the given agent.
    GetAgentStatus(ctx context.Context, address common.Address) (types.AgentStatus, error)
    // GetAgentRoot gets the current agent root
    GetAgentRoot(ctx context.Context) ([32]byte, error)
    // GetProof gets the proof that the agent is in the Agent Merkle Tree
    GetProof(ctx context.Context, address common.Address) ([][32]byte, error)
    // DisputeStatus gets the dispute status for the given agent.
    DisputeStatus(ctx context.Context, address common.Address) (disputeStatus DisputeStatus, err error)
    // GetDispute gets the dispute for a given dispute index.
    // TODO: Add more returned values here as needed.
    GetDispute(ctx context.Context, index *big.Int) (err error)
    // GetDisputeStatus gets the dispute status for the given agent.
    GetDisputeStatus(ctx context.Context, agent common.Address) (disputeStatus types.DisputeStatus, err error)
    // CompleteSlashing completes the slashing of an agent.
    CompleteSlashing(transactor *bind.TransactOpts, domain uint32, agent common.Address, proof [][32]byte) (tx *ethTypes.Transaction, err error)
    // GetAgent gets an agent status and address for a given agent index.
    GetAgent(ctx context.Context, index *big.Int) (types.AgentStatus, common.Address, error)
}

// DestinationContract contains the interface for the destination.
type DestinationContract interface {
    // Execute executes a message on the destination.
    Execute(transactor *bind.TransactOpts, message types.Message, originProof [32][32]byte, snapshotProof [][32]byte, index uint8, gasLimit uint64) (tx *ethTypes.Transaction, err error) // AttestationsAmount retrieves the number of attestations submitted to the destination.
    // AttestationsAmount retrieves the number of attestations submitted to the destination.
    AttestationsAmount(ctx context.Context) (uint64, error)
    // GetAttestationNonce gets the nonce of the attestation by snap root
    GetAttestationNonce(ctx context.Context, snapRoot [32]byte) (uint32, error)
    // MessageStatus takes a message and returns whether it has been executed or not. 0: None, 1: Failed, 2: Success.
    MessageStatus(ctx context.Context, message types.Message) (uint8, error)
    // IsValidReceipt checks if the given receipt is valid on the destination
    IsValidReceipt(ctx context.Context, rcptPayload []byte) (bool, error)
    // PassAgentRoot passes the agent root to the destination.
    PassAgentRoot(transactor *bind.TransactOpts) (tx *ethTypes.Transaction, err error)
}

// LightInboxContract contains the interface for the light inbox.
type LightInboxContract interface {
    // SubmitStateReportWithSnapshot reports to the inbox that a state within a snapshot is invalid.
    SubmitStateReportWithSnapshot(transactor *bind.TransactOpts, stateIndex uint8, signature signer.Signature, snapPayload []byte, snapSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitAttestation submits an attestation to the destination chain (via the light inbox contract)
    SubmitAttestation(
        transactor *bind.TransactOpts,
        attPayload []byte,
        signature signer.Signature,
        agentRoot [32]byte,
        snapGas []*big.Int,
    ) (tx *ethTypes.Transaction, err error)
    // SubmitStateReportWithAttestation submits a state report corresponding to an attesation for an invalid state.
    SubmitStateReportWithAttestation(transactor *bind.TransactOpts, stateIndex uint8, signature signer.Signature, snapPayload, attPayload, attSignature []byte) (tx *ethTypes.Transaction, err error)
    // VerifyStateWithSnapshot verifies a state within a snapshot.
    VerifyStateWithSnapshot(transactor *bind.TransactOpts, stateIndex uint8, snapPayload []byte, snapSignature []byte) (tx *ethTypes.Transaction, err error)
    // SubmitAttestationReport submits an attestation report to the inbox (via the light inbox contract)
    SubmitAttestationReport(transactor *bind.TransactOpts, attestation, arSignature, attSignature []byte) (tx *ethTypes.Transaction, err error)
    // VerifyStateWithAttestation verifies a state with attestation.
    VerifyStateWithAttestation(transactor *bind.TransactOpts, stateIndex uint8, snapPayload []byte, attPayload []byte, attSignature []byte) (tx *ethTypes.Transaction, err error)
    // VerifyReceipt verifies a receipt on the inbox.
    VerifyReceipt(transactor *bind.TransactOpts, rcptPayload []byte, rcptSignature []byte) (tx *ethTypes.Transaction, err error)
}

// LightManagerContract contains the interface for the light manager.
type LightManagerContract interface {
    // GetAgentStatus returns the current agent status for the given agent.
    GetAgentStatus(ctx context.Context, address common.Address) (types.AgentStatus, error)
    // GetAgentRoot gets the current agent root
    GetAgentRoot(ctx context.Context) ([32]byte, error)
    // UpdateAgentStatus updates the agent status on the remote chain.
    UpdateAgentStatus(
        transactor *bind.TransactOpts,
        agentAddress common.Address,
        agentStatus types.AgentStatus,
        agentProof [][32]byte) (*ethTypes.Transaction, error)
    // GetDispute gets the dispute for a given dispute index.
    // TODO: Add more returned values here as needed.
    GetDispute(ctx context.Context, index *big.Int) (err error)
}

// TestClientContract contains the interface for the test client.
type TestClientContract interface {
    // SendMessage sends a message through the TestClient.
    SendMessage(ctx context.Context, signer signer.Signer, destination uint32, recipient common.Address, optimisticSeconds uint32, gasLimit uint64, version uint32, message []byte) error
}

// PingPongClientContract contains the interface for the ping pong test client.
type PingPongClientContract interface {
    // DoPing sends a ping message through the PingPongClient.
    DoPing(ctx context.Context, signer signer.Signer, destination uint32, recipient common.Address, pings uint16) error
    WatchPingSent(ctx context.Context, sink chan<- *pingpongclient.PingPongClientPingSent) (event.Subscription, error)
    WatchPongReceived(ctx context.Context, sink chan<- *pingpongclient.PingPongClientPongReceived) (event.Subscription, error)
}

// ErrNoUpdate indicates no update has been produced.
var ErrNoUpdate = errors.New("no update produced")