chain

type BondedECDSAKeepApplicationHandle interface {
	// ID returns the id of this application in a host chain-agnostic format.
	ID() ID

	// RegisterAsMemberCandidate registers this instance's operator as a
	// candidate to be selected to a keep.
	RegisterAsMemberCandidate() error

	// IsRegisteredForApplication checks if this instance's operator is
	// registered as a signer candidate in the factory for the given
	// application.
	IsRegisteredForApplication() (bool, error)

	// IsEligibleForApplication checks if this instance's operator is eligible
	// to register as a signer candidate for the given application.
	IsEligibleForApplication() (bool, error)

	// IsStatusUpToDateForApplication checks if this instance's operator's
	// status is up to date in the signers' pool of the given application.
	IsStatusUpToDateForApplication() (bool, error)

	// UpdateStatusForApplication updates this instance's operator's status in
	// the signers' pool for the given application.
	UpdateStatusForApplication() error
}

type BondedECDSAKeepCreatedEvent struct {
	Keep                 BondedECDSAKeepHandle
	MemberIDs            []ID // keep member ids
	HonestThreshold      uint64
	BlockNumber          uint64
	ThisOperatorIsMember bool
}

type BondedECDSAKeepFactory interface {
	// TBTCApplicationHandle returns a handle for interacting with the tBTC
	// application associated with this BondedECDSAKeepManager. Returns nil with
	// an error if no tBTC application exists for this manager.
	TBTCApplicationHandle() (TBTCHandle, error)

	// OnBondedECDSAKeepCreated installs a callback that is invoked when an
	// on-chain notification of a new bonded ECDSA keep creation is seen.
	OnBondedECDSAKeepCreated(
		handler func(event *BondedECDSAKeepCreatedEvent),
	) subscription.EventSubscription

	// IsOperatorAuthorized checks if the factory has the authorization to
	// operate on stake represented by the provided operator.
	IsOperatorAuthorized(operator ID) (bool, error)

	// GetKeepCount returns number of keeps.
	GetKeepCount() (*big.Int, error)

	// GetKeepAtIndex returns a handle to the keep at the given index.
	GetKeepAtIndex(keepIndex *big.Int) (BondedECDSAKeepHandle, error)
	// GetKeepWithID returns a handle to the keep with the given ID.
	GetKeepWithID(keepID ID) (BondedECDSAKeepHandle, error)
}

type BondedECDSAKeepHandle interface {
	// ID returns the id of this keep in a host chain-agnostic format.
	ID() ID

	// OnSignatureRequested installs a callback that is invoked when an on-chain
	// notification of a new signing request for a given keep is seen.
	OnSignatureRequested(
		handler func(event *SignatureRequestedEvent),
	) (subscription.EventSubscription, error)

	// OnConflictingPublicKeySubmitted installs a callback that is invoked upon
	// notification of mismatched public keys that were submitted by keep members.
	OnConflictingPublicKeySubmitted(
		handler func(event *ConflictingPublicKeySubmittedEvent),
	) (subscription.EventSubscription, error)

	// OnPublicKeyPublished installs a callback that is invoked upon
	// notification of a published public key, which means that all members have
	// submitted the same key.
	OnPublicKeyPublished(
		handler func(event *PublicKeyPublishedEvent),
	) (subscription.EventSubscription, error)

	// SubmitKeepPublicKey submits a 64-byte serialized public key to a keep
	// contract deployed under a given address.
	SubmitKeepPublicKey(publicKey [64]byte) error

	// SubmitSignature submits a signature to a keep contract deployed under a
	// given address.
	SubmitSignature(signature *ecdsa.Signature) error

	// OnKeepClosed installs a callback that will be called on closing the
	// given keep.
	OnKeepClosed(
		handler func(event *KeepClosedEvent),
	) (subscription.EventSubscription, error)

	// OnKeepTerminated installs a callback that will be called on terminating
	// the given keep.
	OnKeepTerminated(
		handler func(event *KeepTerminatedEvent),
	) (subscription.EventSubscription, error)

	// IsAwaitingSignature checks if the keep is waiting for a signature to be
	// calculated for the given digest.
	IsAwaitingSignature(digest [32]byte) (bool, error)

	// IsActive checks if the keep with the given address is active and responds
	// to signing request. This function returns false only for closed keeps.
	IsActive() (bool, error)

	// LatestDigest returns the latest digest requested to be signed.
	LatestDigest() ([32]byte, error)

	// SignatureRequestedBlock returns block number from the moment when a
	// signature was requested for the given digest from a keep.
	// If a signature was not requested for the given digest, returns 0.
	SignatureRequestedBlock(digest [32]byte) (uint64, error)

	// GetPublicKey returns keep's public key. If there is no public key yet,
	// an empty slice is returned.
	GetPublicKey() ([]uint8, error)

	// GetMembers returns keep's members.
	GetMembers() ([]ID, error)

	// GetOwner returns the keep's owner.
	GetOwner() (ID, error)

	// IsThisOperatorMember returns true if the current operator belongs to the
	// BondedECDSAKeep represented by this handle, false otherwise, or an error
	// if the process of determining this fails.
	IsThisOperatorMember() (bool, error)

	// OperatorIndex returns the index of the current operator in this keep's
	// set of members, or an error if the process of determining this fails. If
	// the operator is not a member this will return -1 (and no error) and
	// IsOperatorMember will return false.
	OperatorIndex() (int, error)

	// GetHonestThreshold returns keep's honest threshold.
	GetHonestThreshold() (uint64, error)

	// GetOpenedTimestamp returns timestamp when the keep was created.
	GetOpenedTimestamp() (time.Time, error)

	// PastSignatureSubmittedEvents returns all signature submitted events
	// for the given keep which occurred after the provided start block.
	// All implementations should returns those events sorted by the
	// block number in the ascending order.
	PastSignatureSubmittedEvents(
		startBlock uint64,
	) ([]*SignatureSubmittedEvent, error)
}

type Config struct {
	TBTCSystem string
}

type ConflictingPublicKeySubmittedEvent struct {
	SubmittingMember     ID
	ConflictingPublicKey []byte
	BlockNumber          uint64
}

type Deposit interface {
	// Keep returns the underlying keep for the provided deposit.
	Keep(depositAddress string) (BondedECDSAKeepHandle, error)

	// RetrieveSignerPubkey retrieves the signer public key for the
	// provided deposit.
	RetrieveSignerPubkey(depositAddress string) error

	// ProvideRedemptionSignature provides the redemption signature for the
	// provided deposit.
	ProvideRedemptionSignature(
		depositAddress string,
		v uint8,
		r [32]uint8,
		s [32]uint8,
	) error

	// IncreaseRedemptionFee increases the redemption fee for the
	// provided deposit.
	IncreaseRedemptionFee(
		depositAddress string,
		previousOutputValueBytes [8]uint8,
		newOutputValueBytes [8]uint8,
	) error

	// ProvideRedemptionProof provides the redemption proof for the
	// provided deposit.
	ProvideRedemptionProof(
		depositAddress string,
		txVersion [4]uint8,
		txInputVector []uint8,
		txOutputVector []uint8,
		txLocktime [4]uint8,
		merkleProof []uint8,
		txIndexInBlock *big.Int,
		bitcoinHeaders []uint8,
	) error

	// CurrentState returns the current state for the provided deposit.
	CurrentState(depositAddress string) (DepositState, error)
}

type DepositRedemptionRequestedEvent struct {
	DepositAddress       string
	RequesterAddress     string
	Digest               [32]byte
	UtxoValue            *big.Int
	RedeemerOutputScript []byte
	RequestedFee         *big.Int
	Outpoint             []byte
	BlockNumber          uint64
}

type DepositState int

type FundingInfo struct {
	UtxoValueBytes  [8]uint8
	FundedAt        *big.Int
	TransactionHash string
	OutputIndex     uint32
}

type Handle interface {
	OfflineHandle

	// StakeMonitor returns a stake monitor.
	StakeMonitor() (chain.StakeMonitor, error)
	// BlockCounter returns a block counter.
	BlockCounter() chain.BlockCounter
	// Signing returns a signer interface allowing to sign and verify messages
	// using the chain implementation-specific mechanism as well as to
	// convert between public key and address.
	Signing() chain.Signing
	// BlockTimestamp returns given block's timestamp.
	// In case the block is not yet mined, an error should be returned.
	BlockTimestamp(blockNumber *big.Int) (uint64, error)

	BondedECDSAKeepFactory
}

type ID interface {
	fmt.Stringer

	ChainName() string
	IsForChain(handle Handle) bool
}

type KeepClosedEvent struct {
	BlockNumber uint64
}

type KeepTerminatedEvent struct {
	BlockNumber uint64
}

type OfflineHandle interface {
	// Return a simple name for this chain handle. This name should consist only
	// of lowercase letters, numbers, and - or _, and should start with a letter
	// (that is, it should conform to the regular expression [a-z][a-z0-9-_]*).
	// It should describe the chain in a way distinguishable from other chains,
	// and generally should be the name of the underlying chain. It can include
	// additional information such as the name of the specific network (e.g.
	// mainnet or the name of a testnet) if desired, but should be stable for a
	// given network indefinitely once the chain has been used in production.
	//
	// This name may be used to construct persistence paths that need to work
	// across node instances, and in general is expected to be stable across
	// executable instances and different remote chain nodes.
	Name() string

	// OperatorID returns operator ID for the client this handle represents on chain.
	OperatorID() ID

	// PublicKeyToOperatorID takes a public key in Go crypto package format and
	// returns an OperatorID suitable for use with any component interacting
	// with this chain handle.
	PublicKeyToOperatorID(publicKey *cecdsa.PublicKey) ID

	// UnmarshalID takes an ID string produced by this chain in the past and
	// unmarshals it into a KeepID object for this chain. Returns an error if
	// the ID string was invalid. It should be safe to call this function from
	// multiple goroutines.
	//
	// Note that unmarshaling the ID used by one chain from a string produced by
	// a different chain is not supported and could lead to unexpected behavior.
	UnmarshalID(idString string) (ID, error)
}

type PublicKeyPublishedEvent struct {
	PublicKey   []byte
	BlockNumber uint64
}

type SignatureRequestedEvent struct {
	Digest      [32]byte
	BlockNumber uint64
}

type SignatureSubmittedEvent struct {
	Digest      [32]byte
	R           [32]byte
	S           [32]byte
	RecoveryID  uint8
	BlockNumber uint64
}

type TBTCHandle interface {
	BondedECDSAKeepApplicationHandle

	Deposit
	TBTCSystem
}

type TBTCSystem interface {
	// OnDepositCreated installs a callback that is invoked when an
	// on-chain notification of a new deposit creation is seen.
	OnDepositCreated(
		handler func(depositAddress string),
	) subscription.EventSubscription

	// OnDepositRegisteredPubkey installs a callback that is invoked when an
	// on-chain notification of a deposit's pubkey registration is seen.
	OnDepositRegisteredPubkey(
		handler func(depositAddress string),
	) subscription.EventSubscription

	// OnDepositRedemptionRequested installs a callback that is invoked when an
	// on-chain notification of a deposit redemption request is seen.
	OnDepositRedemptionRequested(
		handler func(depositAddress string),
	) subscription.EventSubscription

	// OnDepositGotRedemptionSignature installs a callback that is invoked
	// when an on-chain notification of a deposit receiving a redemption
	// signature is seen.
	OnDepositGotRedemptionSignature(
		handler func(depositAddress string),
	) subscription.EventSubscription

	// OnDepositRedeemed installs a callback that is invoked when an
	// on-chain notification of a deposit redemption is seen.
	OnDepositRedeemed(
		handler func(depositAddress string),
	) subscription.EventSubscription

	// PastDepositRedemptionRequestedEvents returns all redemption requested
	// events for the given deposit which occurred after the provided start block.
	// All implementations should return those events sorted by the
	// block number in the ascending order.
	PastDepositRedemptionRequestedEvents(
		startBlock uint64,
		depositAddress string,
	) ([]*DepositRedemptionRequestedEvent, error)

	// FundingInfo retrieves the funding info for a particular deposit address
	//
	// Returns ErrDepositNotFunded error if the deposit has not been funded.
	FundingInfo(
		depositAddress string,
	) (*FundingInfo, error)
}