core

type Core[C WalletConfig, S Signature[C]] interface {
	// DecodeSignature takes raw signature data and returns a Signature that can Recover a WalletConfig.
	DecodeSignature(data []byte) (S, error)

	// DecodeWalletConfig takes a decoded JSON object and returns a WalletConfig.
	DecodeWalletConfig(object any) (C, error)
}

type Digest struct {
	common.Hash

	// Preimage is the preimage of the digest, nil if unknown.
	Preimage []byte
}

type ImageHash struct {
	common.Hash

	// Preimage is the ImageHashable with this ImageHash, nil if unknown.
	Preimage ImageHashable
}

type ImageHashable interface {
	// ImageHash is the digest of the object.
	ImageHash() ImageHash
}

type Signature[C WalletConfig] interface {
	// Threshold is the minimum signing weight required for a signature to be valid.
	Threshold() uint16

	// Checkpoint is the nonce of the wallet configuration that the signature applies to.
	Checkpoint() uint32

	// Recover derives the wallet configuration that the signature applies to.
	// Also returns the signature's weight.
	// If chainID is not provided, provider must be provided.
	// If provider is not provided, EIP-1271 signatures are assumed to be NOT valid and ignored.
	// If signerSignatures is provided, it will be populated with the valid signer signatures of this signature.
	Recover(ctx context.Context, digest Digest, wallet common.Address, chainID *big.Int, provider *ethrpc.Provider, signerSignatures ...SignerSignatures) (C, *big.Int, error)

	// Recover a signature but only using the subdigest
	RecoverSubdigest(ctx context.Context, subdigest Subdigest, provider *ethrpc.Provider, signerSignatures ...SignerSignatures) (C, *big.Int, error)

	// Reduce returns an equivalent optimized signature.
	Reduce(subdigest Subdigest) Signature[C]

	// Join joins two signatures into one.
	Join(subdigest Subdigest, other Signature[C]) (Signature[C], error)

	// Data is the raw signature data.
	Data() ([]byte, error)

	// Write writes the raw signature data to a Writer.
	Write(writer io.Writer) error
}

type SignerSignature struct {
	Signer    common.Address
	Subdigest Subdigest
	Type      SignerSignatureType
	Signature []byte
	Error     error
}

type SignerSignatureType int

type SignerSignatures map[common.Address]map[common.Hash]SignerSignature

type SigningFunction func(ctx context.Context, signer common.Address, signatures []SignerSignature) (SignerSignatureType, []byte, error)

type Subdigest struct {
	common.Hash

	// Digest is the preimage of the subdigest, nil if unknown.
	Digest *Digest

	// Wallet is the target wallet of the subdigest, nil if unknown.
	Wallet *common.Address

	// ChainID is the target chain ID of the subdigest, nil if unknown.
	ChainID *big.Int

	// EthSignPreimage is the preimage of the eth_sign subdigest, nil if unknown.
	EthSignPreimage *Subdigest
}

type WalletConfig interface {
	ImageHashable

	// Threshold is the minimum signing weight required for a signature to be valid.
	Threshold() uint16

	// Checkpoint is the nonce of the wallet configuration.
	Checkpoint() uint32

	// Signers is the set of signers in the wallet configuration.
	Signers() map[common.Address]uint16

	// SignersWeight is the total weight of the signers passed to the function according to the wallet configuration.
	SignersWeight(signers []common.Address) uint16

	// IsUsable checks if it's possible to construct signatures that meet threshold.
	IsUsable() error
}