types

type CallResultLink struct {
	ContractTransactionIndex TxIndex
}

type ChannelInfo struct {
	Port    string `json:"port" yaml:"port"`       // the port on which the packet will be sent
	Channel string `json:"channel" yaml:"channel"` // the channel by which the packet will be sent
}

type ChannelKeeper interface {
	GetChannel(ctx sdk.Context, srcPort, srcChan string) (channel channel.Channel, found bool)
	GetNextSequenceSend(ctx sdk.Context, portID, channelID string) (uint64, bool)
	SendPacket(ctx sdk.Context, channelCap *capability.Capability, packet channelexported.PacketI) error
	PacketExecuted(ctx sdk.Context, chanCap *capability.Capability, packet channelexported.PacketI, acknowledgement []byte) error
}

type Committer interface {
	Precommit(id []byte) error
	Commit(id []byte) error
	CommitImmediately() error
	Discard(id []byte) error
	OPs() OPs
}

type ConstantValueObject struct {
	K []byte
	V []byte
}

type ContractCallInfo []byte

type ContractCallResult struct {
	ChainID         string           `json:"chain_id" yaml:"chain_id"`
	Height          int64            `json:"height" yaml:"height"`
	Signers         []sdk.AccAddress `json:"signers" yaml:"signers"`
	CallInfo        ContractCallInfo `json:"call_info" yaml:"call_info"`
	StateConstraint StateConstraint  `json:"state_constraint" yaml:"state_constraint"`
}

type ContractHandler interface {
	GetState(ctx sdk.Context, callInfo ContractCallInfo, rtInfo ContractRuntimeInfo) (State, error)
	Handle(ctx sdk.Context, callInfo ContractCallInfo, rtInfo ContractRuntimeInfo) (State, ContractHandlerResult, error)
	OnCommit(ctx sdk.Context, result ContractHandlerResult) ContractHandlerResult
}

type ContractHandlerAbortResult struct{}

type ContractHandlerResult interface {
	GetData() []byte
	GetEvents() sdk.Events
}

type ContractRuntimeInfo struct {
	StateConstraintType    StateConstraintType
	ExternalObjectResolver ObjectResolver
}

type ContractTransaction struct {
	Source          ChannelInfo      `json:"source" yaml:"source"`
	Signers         []sdk.AccAddress `json:"signers" yaml:"signers"`
	CallInfo        ContractCallInfo `json:"call_info" yaml:"call_info"`
	StateConstraint StateConstraint  `json:"state_constraint" yaml:"state_constraint"`
	ReturnValue     *ReturnValue     `json:"return_value" yaml:"return_value"`
	Links           []Link           `json:"links" yaml:"links"`
}

type ContractTransactionInfo struct {
	Transaction ContractTransaction `json:"transaction" yaml:"transaction"`
	LinkObjects []Object            `json:"link_objects" yaml:"link_objects"`
}

type ContractTransactions = []ContractTransaction

type CoordinatorInfo struct {
	Transactions []string      // {TransactionID => ConnectionID}
	Channels     []ChannelInfo // {TransactionID => Channel}

	Status                uint8
	Decision              uint8
	ConfirmedTransactions []TxIndex // [TransactionID]
	Acks                  []TxIndex // [TransactionID]
}

type FakeResolver struct{}

type HexByteArray32 [32]byte

type Link interface {
	Type() LinkType
	SourceIndex() TxIndex
}

type LinkType = uint8

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

type MsgInitiate struct {
	Sender               sdk.AccAddress
	ChainID              string // chainID of Coordinator node
	ContractTransactions []ContractTransaction
	TimeoutHeight        int64 // Timeout for this msg
	Nonce                uint64
}

type OP interface {
	Equal(OP) bool
	String() string
}

type OPs []OP

type Object interface {
	Type() ObjectType
	Key() []byte
	Evaluate([]byte) ([]byte, error)
}

type ObjectResolver interface {
	Resolve(key []byte) (Object, error)
}

type ObjectResolverProvider func(libs []Object) (ObjectResolver, error)

type ObjectType = uint8

type PacketAcknowledgement interface {
	ValidateBasic() error
	GetBytes() []byte
	Type() string
}

type PacketCommitAcknowledgement struct{}

type PacketData interface {
	ValidateBasic() error
	GetBytes() []byte
	GetTimeoutHeight() uint64
	GetTimeoutTimestamp() uint64
	Type() string
}

type PacketDataCommit struct {
	TxID          TxID
	TxIndex       TxIndex
	IsCommittable bool
}

type PacketDataPrepare struct {
	Sender  sdk.AccAddress
	TxID    TxID
	TxIndex TxIndex
	TxInfo  ContractTransactionInfo
}

type PacketPrepareAcknowledgement struct {
	Status uint8
}

type PortKeeper interface {
	BindPort(ctx sdk.Context, portID string) *capability.Capability
}

type QueryCoordinatorStatusRequest struct {
	TxID TxID `json:"tx_id" yaml:"tx_id"`
}

type QueryCoordinatorStatusResponse struct {
	TxID            TxID            `json:"tx_id" yaml:"tx_id"`
	CoordinatorInfo CoordinatorInfo `json:"coordinator_info" yaml:"coordinator_info"`
	Completed       bool            `json:"completed" yaml:"completed"`
}

type QueryUnacknowledgedPacketsRequest struct{}

type QueryUnacknowledgedPacketsResponse struct {
	Packets []UnacknowledgedPacket `json:"packets" yaml:"packets"`
}

type ReturnValue []byte

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

type State interface {
	Store
	Committer
}

type StateConstraint struct {
	Type StateConstraintType `json:"type" yaml:"type"`
	OPs  OPs                 `json:"ops" yaml:"ops"`
}

type StateConstraintType = uint8

type Store interface {
	// Get returns nil iff key doesn't exist. Panics on nil key.
	Get(key []byte) []byte

	// Has checks if a key exists. Panics on nil key.
	Has(key []byte) bool

	// Set sets the key. Panics on nil key or value.
	Set(key, value []byte)

	// Delete deletes the key. Panics on nil key.
	Delete(key []byte)
}

type TxID = HexByteArray32

type TxIndex = uint8

type TxInfo struct {
	Status                  uint8  `json:"status" yaml:"status"`
	PrepareResult           uint8  `json:"prepare_result" yaml:"prepare_result"`
	CoordinatorConnectionID string `json:"coordinator_connection_id" yaml:"coordinator_connection_id"`
	ContractCallInfo        []byte `json:"contract_call_info" yaml:"contract_call_info"`
}

type UnacknowledgedPacket struct {
	Sequence      uint64 `json:"sequence" yaml:"sequence"`             // number corresponds to the order of sends and receives, where a Packet with an earlier sequence number must be sent and received before a Packet with a later sequence number.
	SourcePort    string `json:"source_port" yaml:"source_port"`       // identifies the port on the sending chain.
	SourceChannel string `json:"source_channel" yaml:"source_channel"` // identifies the channel end on the sending chain.
}