nft

type API interface {
	// ValidateNFT validates the Proofs and triggers a bridge event to mint NFT on Ethereum chain.
	ValidateNFT(
		ctx context.Context,
		anchorID [32]byte,
		depositAddress [20]byte,
		proofs []SubstrateProof,
		staticProofs [3][32]byte) (err error)

	// CreateRegistry creates a new nft registry on centrifuge chain
	CreateRegistry(ctx context.Context, info RegistryInfo) (registryID common.Address, err error)

	// MintNFT sends an extrinsic to mint nft in given registry on cent chain
	MintNFT(ctx context.Context, owner types.AccountID, registry types.H160, tokenID types.U256, assetInfo AssetInfo, mintInfo MintInfo) (info centchain.ExtrinsicInfo, err error)

	// TransferNFT transfers nft from current account to destAcc
	TransferNFT(ctx context.Context, registry common.Address, tokenID TokenID, destAcc types.AccountID) (info centchain.ExtrinsicInfo, err error)

	// OwnerOf returns the current owner of the Token
	OwnerOf(registry common.Address, tokenID TokenID) (owner types.AccountID, err error)
}

type AssetInfo struct {
	Metadata []byte
}

type Bootstrapper struct{}

type Config interface {
	GetEthereumContextWaitTimeout() time.Duration
}

type MintInfo struct {
	AnchorID     [32]byte
	StaticHashes [3][32]byte
	Proofs       []Proof
}

type MintNFTJob struct {
	jobs.Base
	// contains filtered or unexported fields
}

type MintNFTOnCCJob struct {
	jobs.Base
	// contains filtered or unexported fields
}

type MintNFTOnCCRequest struct {
	DocumentID         []byte
	ProofFields        []string
	RegistryAddress    common.Address
	DepositAddress     types.AccountID
	GrantNFTReadAccess bool
}

type MintNFTRequest struct {
	DocumentID               []byte
	ProofFields              []string
	RegistryAddress          common.Address
	DepositAddress           common.Address
	AssetManagerAddress      common.Address
	GrantNFTReadAccess       bool
	SubmitTokenProof         bool
	SubmitNFTReadAccessProof bool
}

type MintRequest struct {

	// To is the address of the recipient of the minted token
	To common.Address

	// TokenID is the ID for the minted token
	TokenID *big.Int

	// AnchorID is the ID of the document as identified by the set up anchorRepository.
	AnchorID anchors.AnchorID

	// NextAnchorID is the next ID of the document, when updated
	NextAnchorID *big.Int

	// LeftDataRoot of the document
	LeftDataRoot [32]byte

	// RightDataRoot of the document
	RightDataRoot [32]byte

	// SigningRoot of the document
	SigningRoot [32]byte

	// SignaturesRoot of the document
	SignaturesRoot [32]byte

	// Props contains the compact props for readRole and tokenRole
	Props [][]byte

	// Values are the values of the leafs that is being proved Will be converted to string and concatenated for proof
	// verification as outlined in precise-proofs library.
	Values [][]byte

	// Salts are the salts for the field that is being proved Will be concatenated for proof verification as outlined
	// in precise-proofs library.
	Salts [][32]byte

	// Proofs are the documents Proofs that are needed
	Proofs [][][32]byte

	// BundledHash is the keccak hash of to + (props+values+salts)
	BundledHash [32]byte

	// StaticProofs holds data root, sibling root and signature root
	StaticProofs [3][32]byte
}

type Proof struct {
	Value    []byte
	Property []byte
	Salt     [32]byte
	Hashes   [][32]byte
}

type RegistryInfo struct {
	OwnerCanBurn bool
	Fields       [][]byte
}

type Service interface {
	// MintNFT mints an NFT
	MintNFT(ctx context.Context, request MintNFTRequest) (*TokenResponse, error)
	// TransferFrom transfers an NFT to another address
	TransferFrom(ctx context.Context, registry common.Address, to common.Address, tokenID TokenID) (*TokenResponse, error)
	// OwnerOf returns the owner of an NFT
	OwnerOf(registry common.Address, tokenID []byte) (owner common.Address, err error)
	// MintNFTOnCC mints an NFT on Centrifuge chain
	MintNFTOnCC(ctx context.Context, req MintNFTOnCCRequest) (*TokenResponse, error)
	// OwnerOfOnCC returns the owner of the NFT
	OwnerOfOnCC(registry common.Address, tokenID []byte) (types.AccountID, error)
	// TransferNFT transfers NFT to `to` account
	TransferNFT(ctx context.Context, registry common.Address, tokenID TokenID, to types.AccountID) (*TokenResponse, error)
}

type SubstrateProof struct {
	LeafHash     [32]byte
	SortedHashes [][32]byte
}

type TokenID [TokenIDLength]byte

type TokenResponse struct {
	TokenID string
	JobID   string
}

type TransferNFTJob struct {
	jobs.Base
	// contains filtered or unexported fields
}