async_sequencer

type ActionHandler interface {
	// Note: New fulfillment states are not recorded until the very end of a worker
	//       run, which is why we need to pass it into this function.
	OnFulfillmentStateChange(ctx context.Context, fulfillmentRecord *fulfillment.Record, newState fulfillment.State) error
}

type CloseEmptyAccountActionHandler struct {
	// contains filtered or unexported fields
}

type CloseEmptyTimelockAccountFulfillmentHandler struct {
	// contains filtered or unexported fields
}

type ConfigProvider func() *conf

type FulfillmentHandler interface {
	// CanSubmitToBlockchain determines whether the given fulfillment can be
	// scheduled for submission to the blockchain.
	//
	// Implementations must consider global, account, intent, action and local
	// state relevant to the type of fulfillment being handled to determine if
	// it's safe to schedule.
	//
	// Implementations do not need to validate basic preconditions or basic
	// circuit breaking checks, which is performed by the contextual scheduler.
	CanSubmitToBlockchain(ctx context.Context, fulfillmentRecord *fulfillment.Record) (scheduled bool, err error)

	// SupportsOnDemandTransactions returns whether a fulfillment type supports
	// on demand transaction creation
	//
	// Note: This is also being abused for an initial version of packing virtual
	// instructions 1:1 into a Solana transaction. A new flow/strategy will be
	// needed when we require more efficient packing.
	SupportsOnDemandTransactions() bool

	// MakeOnDemandTransaction constructs a transaction at the time of submission
	// to the blockchain. This is an optimization for the nonce pool. Implementations
	// should not modify the provided fulfillment record or selected nonce, but rather
	// use relevant fields to make the corresponding transaction.
	MakeOnDemandTransaction(ctx context.Context, fulfillmentRecord *fulfillment.Record, selectedNonce *transaction_util.SelectedNonce) (*solana.Transaction, error)

	// OnSuccess is a callback function executed on a finalized transaction.
	OnSuccess(ctx context.Context, fulfillmentRecord *fulfillment.Record, txnRecord *transaction.Record) error

	// OnFailure is a callback function executed upon detecting a failed
	// transaction.
	//
	// In general, for automated and manual recovery, the steps should be
	//   1. Ensure the assigned nonce is transitioned back to available
	//      state with the correct blockhash.
	//   2. Update the fulfillment record with a new transaction, plus relevant
	//      metadata (eg. nonce, signature, etc), that does the exact same operation
	//      The fulfillment's state should be pending, so the fulfillment worker can
	//      begin submitting it immediately. The worker does this when recovered = true.
	OnFailure(ctx context.Context, fulfillmentRecord *fulfillment.Record, txnRecord *transaction.Record) (recovered bool, err error)

	// IsRevoked checks whether a fulfillment in the unknown state is revoked.
	// It also provides a hint as to whether the nonce was used or not. When in
	// doubt, say no or error out and let a human decide.
	IsRevoked(ctx context.Context, fulfillmentRecord *fulfillment.Record) (revoked bool, nonceUsed bool, err error)
}

type InitializeLockedTimelockAccountFulfillmentHandler struct {
	// contains filtered or unexported fields
}

type IntentHandler interface {
	// Note: As of right now, we're restricted to checking actions, whose state is
	//       guaranteed to be updated by the time this is called. As a result, the
	//       intent handler should just get the records as needed since they need
	//       a global view anyways.
	OnActionUpdated(ctx context.Context, intentId string) error
}

type NoPrivacyTransferActionHandler struct {
	// contains filtered or unexported fields
}

type NoPrivacyTransferWithAuthorityFulfillmentHandler struct {
	// contains filtered or unexported fields
}

type NoPrivacyWithdrawActionHandler struct {
	// contains filtered or unexported fields
}

type NoPrivacyWithdrawFulfillmentHandler struct {
	// contains filtered or unexported fields
}

type OpenAccountActionHandler struct {
	// contains filtered or unexported fields
}

type OpenAccountsIntentHandler struct {
	// contains filtered or unexported fields
}

type ReceivePaymentsPubliclyIntentHandler struct {
	// contains filtered or unexported fields
}

type Scheduler interface {
	// CanSubmitToBlockchain determines whether the given fulfillment can be
	// scheduled for submission to the blockchain.
	CanSubmitToBlockchain(ctx context.Context, record *fulfillment.Record) (bool, error)
}

type SendPublicPaymentIntentHandler struct {
	// contains filtered or unexported fields
}