types

type Account interface {
	AccountIDProvider
	AccountNameProvider
	AccountPublicKeyProvider
}

type AccountCompositePublicKeyProvider interface {
	// CompositePublicKey provides the composite public key for the account.
	CompositePublicKey() e2types.PublicKey
}

type AccountIDProvider interface {
	// ID provides the ID for the account.
	ID() uuid.UUID
}

type AccountLocker interface {
	// Lock locks the account.  A locked account cannot sign.
	Lock(ctx context.Context) error

	// Unlock unlocks the account.  An unlocked account can sign.
	Unlock(ctx context.Context, passphrase []byte) error

	// IsUnlocked returns true if the account is unlocked.
	IsUnlocked(ctx context.Context) (bool, error)
}

type AccountMetadataProvider interface {
	// WalletID provides the ID for the wallet.
	WalletID() uuid.UUID

	// ID provides the ID for the account.
	ID() uuid.UUID

	// Name provides the name for the account.
	Name() string
}

type AccountNameProvider interface {
	// Name provides the name for the account.
	Name() string
}

type AccountParticipantsProvider interface {
	// Participants provides the participants that hold the composite key.
	Participants() map[uint64]string
}

type AccountPathProvider interface {
	// Path provides the path for the account.
	Path() string
}

type AccountPrivateKeyProvider interface {
	// PrivateKey provides the private key for the account.
	PrivateKey(ctx context.Context) (e2types.PrivateKey, error)
}

type AccountProtectingMultiSigner interface {
	// SignBeaconAttestations signs multiple beacon attestations with protection.
	SignBeaconAttestations(ctx context.Context,
		slot uint64,
		accounts []Account,
		committeeIndices []uint64,
		blockRoot []byte,
		sourceEpoch uint64,
		sourceRoot []byte,
		targetEpoch uint64,
		targetRoot []byte,
		domain []byte) ([]e2types.Signature, error)
}

type AccountProtectingSigner interface {
	// SignGeneric signs a generic root with protection.
	SignGeneric(ctx context.Context, data []byte, domain []byte) (e2types.Signature, error)

	// SignBeaconProposal signs a beacon proposal with protection.
	SignBeaconProposal(ctx context.Context,
		slot uint64,
		proposerIndex uint64,
		parentRoot []byte,
		stateRoot []byte,
		bodyRoot []byte,
		domain []byte) (e2types.Signature, error)

	// SignBeaconAttestation signs a beacon attestation with protection.
	SignBeaconAttestation(ctx context.Context,
		slot uint64,
		committeeIndex uint64,
		blockRoot []byte,
		sourceEpoch uint64,
		sourceRoot []byte,
		targetEpoch uint64,
		targetRoot []byte,
		domain []byte) (e2types.Signature, error)
}

type AccountPublicKeyProvider interface {
	// PublicKey provides the public key for the account.
	PublicKey() e2types.PublicKey
}

type AccountSigner interface {
	// Sign signs data with the account.
	Sign(ctx context.Context, data []byte) (e2types.Signature, error)
}

type AccountSigningThresholdProvider interface {
	// SigningThreshold provides the threshold to make a valid composite signature.
	SigningThreshold() uint32
}

type AccountVerificationVectorProvider interface {
	// VerificationVector provides the composite verification vector for regeneration.
	VerificationVector() []e2types.PublicKey
}

type AccountWalletProvider interface {
	// Wallet provides the wallet for this account.
	Wallet() Wallet
}

type BatchRetriever interface {
	// RetrieveBatch retrieves the batch of accounts for a given wallet.
	RetrieveBatch(ctx context.Context, walletID uuid.UUID) ([]byte, error)
}

type BatchStorer interface {
	// StoreBatch stores wallet batch data.  It will fail if it cannot store the data.
	StoreBatch(ctx context.Context, walletID uuid.UUID, walletName string, data []byte) error
}

type DistributedAccount interface {
	AccountIDProvider
	AccountNameProvider
	AccountCompositePublicKeyProvider
	AccountSigningThresholdProvider
	AccountParticipantsProvider
}

type Encryptor interface {
	// Name() provides the name of the encryptor.
	Name() string

	// Version() provides the version of the encryptor.
	Version() uint

	// String provides a string value for the encryptor.
	String() string

	// Encrypt encrypts a byte array with its encryption mechanism and key.
	Encrypt(data []byte, key string) (map[string]any, error)

	// Decrypt encrypts a byte array with its encryption mechanism and key.
	Decrypt(data map[string]any, key string) ([]byte, error)
}

type ShardedAccount interface {
	AccountIDProvider
	AccountNameProvider
	AccountCompositePublicKeyProvider
	AccountSigningThresholdProvider
	AccountParticipantsProvider
}

type Store interface {
	// Name provides the name of the store
	Name() string

	// StoreWallet stores wallet data.  It will fail if it cannot store the data.
	StoreWallet(walletID uuid.UUID, walletName string, data []byte) error

	// RetrieveWallet retrieves wallet data for all wallets.
	RetrieveWallets() <-chan []byte

	// RetrieveWallet retrieves wallet data for a wallet with a given name.
	// It will fail if it cannot retrieve the data.
	RetrieveWallet(walletName string) ([]byte, error)

	// RetrieveWalletByID retrieves wallet data for a wallet with a given ID.
	// It will fail if it cannot retrieve the data.
	RetrieveWalletByID(walletID uuid.UUID) ([]byte, error)

	// StoreAccount stores account data.  It will fail if it cannot store the data.
	StoreAccount(walletID uuid.UUID, accountID uuid.UUID, data []byte) error

	// RetrieveAccounts retrieves account information for all accounts.
	RetrieveAccounts(walletID uuid.UUID) <-chan []byte

	// RetrieveAccount retrieves account data for a wallet with a given ID.
	// It will fail if it cannot retrieve the data.
	RetrieveAccount(walletID uuid.UUID, accountID uuid.UUID) ([]byte, error)

	// StoreAccountsIndex stores the index of accounts for a given wallet.
	StoreAccountsIndex(walletID uuid.UUID, data []byte) error

	// RetrieveAccountsIndex retrieves the index of accounts for a given wallet.
	RetrieveAccountsIndex(walletID uuid.UUID) ([]byte, error)
}

type StoreLocationProvider interface {
	Location() string
}

type StoreProvider interface {
	// Store returns the store.
	Store() Store
}

type Wallet interface {
	WalletIDProvider
	WalletTypeProvider
	WalletNameProvider
	WalletVersionProvider
	WalletAccountsProvider
}

type WalletAccountByIDProvider interface {
	// AccountByID provides a single account from the wallet given its ID.
	// This will error if the account is not found.
	AccountByID(ctx context.Context, id uuid.UUID) (Account, error)
}

type WalletAccountByNameProvider interface {
	// AccountByName provides a single account from the wallet given its name.
	// This will error if the account is not found.
	AccountByName(ctx context.Context, name string) (Account, error)
}

type WalletAccountCreator interface {
	// CreateAccount creates a new account in the wallet.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name already exists.
	CreateAccount(ctx context.Context, name string, passphrase []byte) (Account, error)
}

type WalletAccountImporter interface {
	// ImportAccount creates a new account in the wallet from an existing private key.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name already exists.
	ImportAccount(ctx context.Context, name string, key []byte, passphrase []byte) (Account, error)
}

type WalletAccountsByPathProvider interface {
	// AccountsByPath provides all matching accounts in the wallet.
	AccountsByPath(ctx context.Context, path string) <-chan Account
}

type WalletAccountsProvider interface {
	// Accounts provides all accounts in the wallet.
	Accounts(ctx context.Context) <-chan Account
}

type WalletBatchCreator interface {
	// BatchWallet encrypts all accounts in a single entity, allowing for faster
	// decryption of wallets with large numbers of accounts.
	BatchWallet(ctx context.Context, passphrases []string, batchPassphrase string) error
}

type WalletDistributedAccountCreator interface {
	// CreateDistributedAccount creates a new distributed account in the wallet.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name already exists.
	CreateDistributedAccount(ctx context.Context,
		name string,
		particpants uint32,
		signingThreshold uint32,
		passphrase []byte,
	) (
		Account,
		error,
	)
}

type WalletDistributedAccountImporter interface {
	// ImportDistributedAccount creates a new distributed account in the wallet from provided data.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name already exists.
	ImportDistributedAccount(ctx context.Context,
		name string,
		key []byte,
		signingThreshold uint32,
		verificationVector [][]byte,
		participants map[uint64]string,
		passphrase []byte) (Account, error)
}

type WalletExporter interface {
	// Export exports the entire wallet, protected by an additional passphrase.
	Export(ctx context.Context, passphrase []byte) ([]byte, error)
}

type WalletIDProvider interface {
	// ID provides the ID for the wallet.
	ID() uuid.UUID
}

type WalletLocker interface {
	// Lock locks the wallet.  A locked account cannot create new accounts.
	Lock(ctx context.Context) error

	// Unlock unlocks the wallet.  An unlocked account can create new accounts.
	Unlock(ctx context.Context, passphrase []byte) error

	// IsUnlocked returns true if the wallet is unlocked.
	IsUnlocked(ctx context.Context) (bool, error)
}

type WalletNameProvider interface {
	// Name provides the name for the wallet.
	Name() string
}

type WalletPathedAccountCreator interface {
	// CreatePathedAccount creates a new account in the wallet with a given path.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name or path already exists.
	CreatePathedAccount(ctx context.Context, path string, name string, passphrase []byte) (Account, error)
}

type WalletShardedAccountImporter interface {
	// ImportShardedAccount creates a new sharded account in the wallet from provided data.
	// The only rule for names is that they cannot start with an underscore (_) character.
	// This will error if an account with the name already exists.
	ImportShardedAccount(ctx context.Context,
		name string,
		key []byte,
		signingThreshold uint32,
		compositePublicKey []byte,
		participants map[uint64]string,
		passphrase []byte) (Account, error)
}

type WalletTypeProvider interface {
	// Type provides the type for the wallet.
	Type() string
}

type WalletVersionProvider interface {
	// Version provides the version of the wallet.
	Version() uint
}