domain

type Account struct {
	// The unique identifier for this blockchain that we are managing the state for.
	ChainID uint16 `bson:"chain_id" json:"chain_id"`

	// The public address of the account.
	Address *common.Address `bson:"address" json:"address"`

	// The Nonce field in the Account struct is not directly related to the
	// Nonce field in the BlockHeader struct. Instead, it's used to prevent
	// replay attacks on transactions.
	//
	// In Ethereum and other blockchain systems, a nonce is a counter that is
	// used to prevent a transaction from being replayed on the network. When a
	// user wants to send a transaction, they need to specify the nonce value
	// for their account. The nonce value is incremented each time a transaction
	// is sent from the account.
	//
	// In this context, the Nonce field in the Account struct represents the
	// nonce value of the last transaction sent from the account. This value is
	// used to prevent replay attacks by ensuring that each transaction has a
	// unique nonce value.
	//
	// Here's how it works:
	// 1. When a user wants to send a transaction, they retrieve the current nonce value for their account from the blockchain.
	// 2. They increment the nonce value by 1 and include it in the transaction.
	// 3. The transaction is sent to the network and verified by the nodes.
	// 4. If the transaction is valid, the nonce value is incremented again and stored in the account's state.
	//
	// By including the Nonce field in the Account struct, the blockchain can
	// keep track of the nonce value for each account and prevent replay attacks.
	//
	// It's worth noting that the Nonce field in the BlockHeader struct has a
	// different purpose. It's used to solve the proof-of-work puzzle required
	// to mine a new block.
	NonceBytes []byte `bson:"nonce_bytes" json:"nonce_bytes"`

	// The balance of the account in coins.
	Balance uint64 `bson:"balance" json:"balance"`
}

type AccountRepository interface {
	// Upsert inserts or updates an account in the repository.
	Upsert(ctx context.Context, acc *Account) error

	// GetByAddress retrieves an account by its ID.
	GetByAddress(ctx context.Context, addr *common.Address) (*Account, error)

	// ListByChainID retrieves all accounts in the repository for the particular chain ID.
	ListByChainID(ctx context.Context, chainID uint16) ([]*Account, error)

	ListWithFilterByAddresses(ctx context.Context, addrs []*common.Address) ([]*Account, error)

	// DeleteByID deletes an account by its ID.
	DeleteByAddress(ctx context.Context, addr *common.Address) error

	// HashStateByChainID returns a hash based on the contents of the accounts and
	// their balances. This is added to each block and checked by peers.
	HashStateByChainID(ctx context.Context, chainID uint16) (string, error)

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}

type Block struct {
	// Header is the block header, which contains metadata about the block.
	Header *BlockHeader

	// The signature of this block's "Header" field which was applied by the
	// proof-of-authority validator.
	HeaderSignatureBytes []byte `bson:"header_signature_bytes" json:"header_signature_bytes"`

	// MerkleTree is the Merkle tree of transactions, which allows for efficient verification of transaction inclusion.
	MerkleTree *merkle.Tree[BlockTransaction]

	// The proof-of-authority validator whom executed the validation of
	// this block data in our blockchain.
	Validator *Validator `bson:"validator" json:"validator"`
}

type BlockData struct {
	// Hash is the unique hash of the block.
	Hash string `bson:"hash" json:"hash"`

	// Header is the block header, which contains metadata about the block.
	Header *BlockHeader `bson:"header" json:"header"`

	// The signature of this block's "Header" field which was applied by the
	// proof-of-authority validator.
	HeaderSignatureBytes []byte `bson:"header_signature_bytes" json:"header_signature_bytes"`

	// Trans is the list of (coin) transactions in the block.
	Trans []BlockTransaction `bson:"trans" json:"trans"`

	// The proof-of-authority validator whom executed the validation of
	// this block data in our blockchain.
	Validator *Validator `bson:"validator" json:"validator"`
}

type BlockDataDTO BlockData

type BlockDataDTORepository interface {
	GetFromBlockchainAuthorityByHash(ctx context.Context, hash string) (*BlockDataDTO, error)
	GetFromBlockchainAuthorityByHeaderNumber(ctx context.Context, headerNumber *big.Int) (*BlockDataDTO, error)
}

type BlockDataRepository interface {
	// Upsert upserts a block data into the repository.
	// It takes a block data and returns an error if one occurs.
	Upsert(ctx context.Context, bd *BlockData) error

	// GetByHash gets a block data by its hash.
	// It takes a hash and returns the block data and an error if one occurs.
	GetByHash(ctx context.Context, hash string) (*BlockData, error)

	GetByHeaderNumber(ctx context.Context, headerNumber *big.Int) (*BlockData, error)

	GetByTransactionNonce(ctx context.Context, txNonce *big.Int) (*BlockData, error)

	// ListByChainID lists all block data in the repository for the particular chain.
	ListByChainID(ctx context.Context, chainID uint16) ([]*BlockData, error)

	// DeleteByHash deletes a block data by its hash.
	// It takes a hash and returns an error if one occurs.
	DeleteByHash(ctx context.Context, hash string) error

	// ListBlockTransactionsByAddress lists all the transactions for a particular address.
	ListBlockTransactionsByAddress(ctx context.Context, address *common.Address) ([]*BlockTransaction, error)

	// ListBlockTransactionsByAddress lists all the transactions for a particular address.
	ListWithLimitForBlockTransactionsByAddress(ctx context.Context, address *common.Address, limit int64) ([]*BlockTransaction, error)

	GetByBlockTransactionTimestamp(ctx context.Context, timestamp uint64) (*BlockData, error)

	// GetLatestBlockTransactionByAddress will return the most recent block transaction for the particular address.
	GetLatestBlockTransactionByAddress(ctx context.Context, address *common.Address) (*BlockTransaction, error)

	GetLatestTokenIDByChainID(ctx context.Context, chainID uint16) (*big.Int, error)

	ListOwnedTokenBlockTransactionsByAddress(ctx context.Context, address *common.Address) ([]*BlockTransaction, error)

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}

type BlockHeader struct {
	ChainID        uint16         `bson:"chain_id" json:"chain_id"`               // Keep track of which chain this block belongs to.
	NumberBytes    []byte         `bson:"number_bytes" json:"number_bytes"`       // Ethereum: Block number in the chain.
	NumberString   string         `bson:"-" json:"number_string"`                 // Read-only response in string format - will not be saved in database, only returned via API.
	PrevBlockHash  string         `bson:"prev_block_hash" json:"prev_block_hash"` // Bitcoin: Hash of the previous block in the chain.
	TimeStamp      uint64         `bson:"timestamp" json:"timestamp"`             // Bitcoin: Time the block was mined.
	Difficulty     uint16         `bson:"difficulty" json:"difficulty"`           // Ethereum: Number of 0's needed to solve the hash solution.
	Beneficiary    common.Address `bson:"beneficiary" json:"beneficiary"`         // Ethereum: The account who is receiving fees .
	TransactionFee uint64         `bson:"transaction_fee" json:"transaction_fee"` // ComicCoin: Fee that must be paid for every transaction. This value is provided by the authority.

	// The StateRoot represents a hash of the in-memory account balance
	// database. This field allows the blockchain to provide a guarantee that
	// the accounting of the transactions and fees for each account on each
	// node is exactly the same.
	StateRoot string `bson:"state_root" json:"state_root"` // Ethereum: Represents a hash of the accounts and their balances.

	TransRoot   string `bson:"trans_root" json:"trans_root"`   // Both: Represents the merkle tree root hash for the transactions in this block.
	NonceBytes  []byte `bson:"nonce_bytes" json:"nonce_bytes"` // Both: Value identified to solve the hash solution.
	NonceString string `bson:"-" json:"nonce_string"`          // Read-only response in string format - will not be saved in database, only returned via API.

	LatestTokenIDBytes  []byte `bson:"latest_token_id_bytes" json:"latest_token_id_bytes"` // ComicCoin: The latest token that the blockchain points to.
	LatestTokenIDString string `bson:"-" json:"latest_token_id_string"`                    // Read-only response in string format - will not be saved in database, only returned via API.
	TokensRoot          string `bson:"tokens_root" json:"tokens_root"`                     // ComicCoin: Represents the hash of all the tokens and their owners.
}

type BlockNumberByHash struct {
	Number uint64 `bson:"number"`
	Hash   string `bson:"hash"`
}

type BlockTransaction struct {
	SignedTransaction
	TimeStamp uint64 `bson:"timestamp" json:"timestamp"` // Ethereum: The time the transaction was received.
	Fee       uint64 `bson:"fee" json:"fee"`             // ComicCoin: Fee paid for this transaction to the ComicCoin authority.
}

type BlockchainState struct {
	// The unique identifier for this blockchain that we are managing the state for.
	ChainID uint16 `bson:"chain_id" json:"chain_id"`

	LatestBlockNumberBytes []byte `bson:"latest_block_number_bytes" json:"latest_block_number_bytes"`
	LatestHash             string `bson:"latest_hash" json:"latest_hash"`
	LatestTokenIDBytes     []byte `bson:"latest_token_id_bytes" json:"latest_token_id_bytes"`

	// The current transaction fee to be apply for every transaction as of this moment in time that is received by the Authority from the Global Blockchain Network.
	TransactionFee uint64 `bson:"transaction_fee" json:"transaction_fee"`

	AccountHashState string `bson:"account_hash_state" json:"account_hash_state"`
	TokenHashState   string `bson:"token_hash_state" json:"token_hash_state"`
}

type BlockchainStateChangeEventDTORepository interface {
	SubscribeToBlockchainAuthority(ctx context.Context, chainID uint16) (<-chan uint16, error)
}

type BlockchainStateDTO BlockchainState

type BlockchainStateDTORepository interface {
	GetFromBlockchainAuthorityByChainID(ctx context.Context, chainID uint16) (*BlockchainStateDTO, error)
}

type BlockchainStateRepository interface {
	// Upsert inserts or updates an blockchain state in the repository.
	UpsertByChainID(ctx context.Context, acc *BlockchainState) error

	// GetByChainID retrieves an blockchain state by its chain ID.
	GetByChainID(ctx context.Context, chainID uint16) (*BlockchainState, error)

	// ListAll retrieves all blockchain states in the repository.
	ListAll(ctx context.Context) ([]*BlockchainState, error)

	// DeleteByChainID deletes an blockchain state by its chain ID.
	DeleteByChainID(ctx context.Context, chainID uint16) error

	GetUpdateChangeStreamChannel(ctx context.Context) (<-chan BlockchainState, chan struct{}, error)

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}

type GenesisBlockData BlockData

type GenesisBlockDataDTO GenesisBlockData

type GenesisBlockDataDTORepository interface {
	GetFromBlockchainAuthorityByChainID(ctx context.Context, chainID uint16) (*GenesisBlockDataDTO, error)
}

type GenesisBlockDataRepository interface {
	GetByChainID(ctx context.Context, chainID uint16) (*GenesisBlockData, error)
	UpsertByChainID(ctx context.Context, genesis *GenesisBlockData) error

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}

type MempoolTransaction struct {
	ID primitive.ObjectID `bson:"_id" json:"id"`

	// The signed transaction data, including sender, recipient, amount, and other metadata like V, R, S, etc.
	SignedTransaction
}

type MempoolTransactionDTO MempoolTransaction

type MempoolTransactionDTORepository interface {
	SubmitToBlockchainAuthority(ctx context.Context, dto *MempoolTransactionDTO) error
}

type MempoolTransactionRepository interface {
	GetByID(ctx context.Context, id primitive.ObjectID) (*MempoolTransaction, error)

	// Upsert inserts or updates a mempool transaction in the repository.
	Upsert(ctx context.Context, mempoolTx *MempoolTransaction) error

	// ListAll retrieves all mempool transactions in the repository.
	ListByChainID(ctx context.Context, chainID uint16) ([]*MempoolTransaction, error)

	// DeleteByChainID deletes all mempool transactions in the repository for the particular chainID.
	DeleteByChainID(ctx context.Context, chainID uint16) error

	DeleteByID(ctx context.Context, id primitive.ObjectID) error

	GetInsertionChangeStreamChannel(ctx context.Context) (<-chan MempoolTransaction, chan struct{}, error)
}

type NFTAsset struct {
	Filename      string `json:"filename"`       // The name of the file being retrieved, derived from Content-Disposition headers.
	Content       []byte `json:"content"`        // The raw file content in bytes.
	ContentType   string `json:"content_type"`   // The MIME type of the file, determined by server response headers.
	ContentLength uint64 `json:"content_length"` // The length of the content in bytes.
}

type NFTAssetRepository interface {
	// Version fetches the current version of the remote IPFS server.
	// It returns the version as a string and any error encountered.
	Version(ctx context.Context) (string, error)

	// PinAddViaFilepath pins a file located at the specified filepath to the IPFS server.
	// The filepath should be a full local path, and it returns the CID of the pinned file or an error.
	PinAddViaFilepath(ctx context.Context, filepath string) (string, error)

	// Get retrieves a file from the IPFS server using its CID (Content Identifier).
	// It returns a NFTAsset containing file metadata, content, and any error encountered.
	Get(ctx context.Context, cidString string) (*NFTAsset, error)
}

type NonFungibleToken struct {
	TokenID     *big.Int                  `json:"token_id"`
	MetadataURI string                    `json:"metadata_uri"`
	Metadata    *NonFungibleTokenMetadata `json:"metadata"`
	State       string                    `bson:"state" json:"state"`
}

type NonFungibleTokenMetadata struct {
	Image           string                               `bson:"image" json:"image"`
	ExternalURL     string                               `bson:"external_url" json:"external_url"`
	Description     string                               `bson:"description" json:"description"`
	Name            string                               `bson:"name" json:"name"`
	Attributes      []*NonFungibleTokenMetadataAttribute `bson:"attributes" json:"attributes"`
	BackgroundColor string                               `bson:"background_color" json:"background_color"`
	AnimationURL    string                               `bson:"animation_url" json:"animation_url"`
	YoutubeURL      string                               `bson:"youtube_url" json:"youtube_url"`
}

type NonFungibleTokenMetadataAttribute struct {
	DisplayType string `bson:"display_type" json:"display_type"`
	TraitType   string `bson:"trait_type" json:"trait_type"`
	Value       string `bson:"value" json:"value"`
}

type NonFungibleTokenRepository interface {
	// Upsert inserts or updates an nfts in the repository.
	Upsert(acc *NonFungibleToken) error

	// GetByID retrieves an nft by its token id.
	GetByTokenID(tokenID *big.Int) (*NonFungibleToken, error)

	// ListAll retrieves all nfts in the repository.
	ListAll() ([]*NonFungibleToken, error)

	// ListByTokenIDs retrieves nfts that have the token is in the parameter
	ListWithFilterByTokenIDs(tokIDs []*big.Int) ([]*NonFungibleToken, error)

	// DeleteByID deletes an nft by its token id.
	DeleteByTokenID(tokenID *big.Int) error

	OpenTransaction() error

	CommitTransaction() error

	DiscardTransaction()
}

type SignedTransaction struct {
	Transaction

	VBytes []byte `bson:"v_bytes,omitempty" json:"v_bytes"`  // Ethereum: Recovery identifier, either 29 or 30 with comicCoinID.
	RBytes []byte `bson:"r_bytes,omitempty"  json:"r_bytes"` // Ethereum: First coordinate of the ECDSA signature.
	SBytes []byte `bson:"s_bytes,omitempty"  json:"s_bytes"` // Ethereum: Second coordinate of the ECDSA signature.
}

type Token struct {
	// The unique identifier for this blockchain that we are managing the state for.
	ChainID uint16 `bson:"chain_id" json:"chain_id"`

	IDBytes     []byte          `bson:"id_bytes" json:"id_bytes"`
	Owner       *common.Address `bson:"owner" json:"owner"`
	MetadataURI string          `bson:"metadata_uri" json:"metadata_uri"` // ComicCoin: URI pointing to Token metadata file (if this transaciton is an Token).
	NonceBytes  []byte          `bson:"nonce_bytes" json:"nonce_bytes"`   // ComicCoin: Newly minted tokens always start at zero and for every transaction action afterwords (transfer, burn, etc) this value is increment by 1.
}

type TokenRepository interface {
	// Upsert inserts or updates an token in the repository.
	Upsert(ctx context.Context, tok *Token) error

	// GetByAddress retrieves an token by its ID.
	GetByID(ctx context.Context, id *big.Int) (*Token, error)

	// ListByChainID retrieves all accounts in the repository for the particular chain ID.
	ListByChainID(ctx context.Context, chainID uint16) ([]*Token, error)

	// ListByOwner retrieves all the tokens in the repository that belongs
	// to the owner address.
	ListByOwner(ctx context.Context, owner *common.Address) ([]*Token, error)

	// CountByOwner counts all the tokens owned by the owner.
	CountByOwner(ctx context.Context, owner *common.Address) (int64, error)

	// DeleteByID deletes an token by its ID.
	DeleteByID(ctx context.Context, id *big.Int) error

	// HashStateByChainID returns a hash based on the contents of the tokens and
	// their metadata. This is added to each block and checked by peers.
	HashStateByChainID(ctx context.Context, chainID uint16) (string, error)

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}

type Transaction struct {
	ChainID          uint16          `bson:"chain_id" json:"chain_id"`                     // Ethereum: The chain id that is listed in the genesis file.
	NonceBytes       []byte          `bson:"nonce_bytes" json:"nonce_bytes"`               // Ethereum: Unique id for the transaction supplied by the user.
	NonceString      string          `bson:"-" json:"nonce_string"`                        // Read-only response in string format - will not be saved in database, only returned via API.
	From             *common.Address `bson:"from" json:"from"`                             // Ethereum: Account sending the transaction. Will be checked against signature.
	To               *common.Address `bson:"to" json:"to"`                                 // Ethereum: Account receiving the benefit of the transaction.
	Value            uint64          `bson:"value" json:"value"`                           // Ethereum: Monetary value received from this transaction.
	Data             []byte          `bson:"data" json:"data"`                             // Ethereum: Extra data related to the transaction.
	DataString       string          `bson:"-" json:"data_string"`                         // Read-only response in string format - will not be saved in database, only returned via API.
	Type             string          `bson:"type" json:"type"`                             // ComicCoin: The type of transaction this is, either `coin` or `token`.
	TokenIDBytes     []byte          `bson:"token_id_bytes" json:"token_id_bytes"`         // ComicCoin: Unique identifier for the Token (if this transaciton is an Token).
	TokenIDString    string          `bson:"-" json:"token_id_string"`                     // Read-only response in string format - will not be saved in database, only returned via API.
	TokenMetadataURI string          `bson:"token_metadata_uri" json:"token_metadata_uri"` // ComicCoin: URI pointing to Token metadata file (if this transaciton is an Token).
	TokenNonceBytes  []byte          `bson:"token_nonce_bytes" json:"token_nonce_bytes"`   // ComicCoin: For every transaction action (mint, transfer, burn, etc), increment token nonce by value of 1.
	TokenNonceString string          `bson:"-" json:"token_nonce_string"`                  // Read-only response in string format - will not be saved in database, only returned via API.
}

type Validator struct {
	ID             string `bson:"id" json:"id"`
	PublicKeyBytes []byte `bson:"public_key_bytes" json:"public_key_bytes"`
}

type Wallet struct {
	// The (Optional) description for this wallet.
	Label string `bson:"label" json:"label"`

	// The public address of the wallet.
	Address *common.Address `bson:"address" json:"address"`

	// FileContent contains
	KeystoreBytes []byte `bson:"keystore_bytes" json:"keystore_bytes"`
}

type WalletRepository interface {
	// Upsert inserts or updates an wallet in the repository.
	Upsert(ctx context.Context, acc *Wallet) error

	// GetByID retrieves an wallet by its Address.
	GetByAddress(ctx context.Context, address *common.Address) (*Wallet, error)

	// ListAll retrieves all wallets in the repository.
	ListAll(ctx context.Context) ([]*Wallet, error)

	// ListAllAddresses retrieves all wallet addresses in the repository.
	ListAllAddresses(ctx context.Context) ([]*common.Address, error)

	// DeleteByID deletes an wallet by its Address.
	DeleteByAddress(ctx context.Context, address *common.Address) error

	OpenTransaction() error
	CommitTransaction() error
	DiscardTransaction()
}