chainadapter

type AddressFormat uint8

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

type AlgorandBlock struct {
	Round       uint64   `json:"round"`
	Hash        [32]byte `json:"hash"`
	PrevHash    [32]byte `json:"prevHash"`
	Seed        [32]byte `json:"seed"` // VRF seed
	TxnRoot     [32]byte `json:"txnRoot"`
	Timestamp   uint64   `json:"timestamp"`
	Certificate []byte   `json:"certificate"` // Block certificate
}

type AppChain struct {

	// Identity
	ID        ids.ID    `json:"id"`
	Name      string    `json:"name"`
	Owner     []byte    `json:"owner"`
	CreatedAt time.Time `json:"createdAt"`

	// Configuration
	Config *AppChainConfig `json:"config"`

	// State
	State *AppChainState `json:"state"`
	// contains filtered or unexported fields
}

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

type AppChainConfig struct {
	AppChainID ids.ID `json:"appChainId"`
	Name       string `json:"name"`
	Owner      []byte `json:"owner"`

	// Encryption settings
	EncryptionScheme string `json:"encryptionScheme"` // "aes-gcm", "chacha20-poly1305", "fhe-bfv", "fhe-ckks"
	FHEEnabled       bool   `json:"fheEnabled"`
	FHEScheme        string `json:"fheScheme"` // "bfv", "ckks", "tfhe"

	// CRDT settings
	DefaultCRDTType    CRDTType `json:"defaultCrdtType"`
	ConflictResolution string   `json:"conflictResolution"` // "lww", "merge", "custom"

	// DA layer settings
	DALayerID         ids.ID        `json:"daLayerId"`
	ReplicationFactor uint8         `json:"replicationFactor"`
	RetentionPeriod   time.Duration `json:"retentionPeriod"`

	// Compute settings
	ConfidentialCompute bool `json:"confidentialCompute"`
	TEERequired         bool `json:"teeRequired"`

	// Replication policies
	GeoReplication []string `json:"geoReplication"` // Regions for data replication

	// Anchoring
	AnchorInterval   time.Duration `json:"anchorInterval"`
	MinConfirmations uint32        `json:"minConfirmations"`
}

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

type AppChainState struct {
	AppChainID  ids.ID               `json:"appChainId"`
	Documents   map[string]*Document `json:"documents"`   // docHash -> Document
	Collections map[string][]string  `json:"collections"` // collection -> docIDs

	// State commitment
	StateRoot       [32]byte `json:"stateRoot"`
	LastBatchID     ids.ID   `json:"lastBatchId"`
	LastBlockHeight uint64   `json:"lastBlockHeight"`

	// Metrics
	TotalDocuments  uint64 `json:"totalDocuments"`
	TotalOperations uint64 `json:"totalOperations"`
	StorageUsed     uint64 `json:"storageUsed"`
}

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

type AptosBlock struct {
	Version         uint64   `json:"version"` // Transaction version (not block number)
	BlockHeight     uint64   `json:"blockHeight"`
	Epoch           uint64   `json:"epoch"`
	Round           uint64   `json:"round"`
	Timestamp       uint64   `json:"timestamp"`
	Hash            [32]byte `json:"hash"`
	StateRoot       [32]byte `json:"stateRoot"`
	EventRoot       [32]byte `json:"eventRoot"`
	AccumulatorRoot [32]byte `json:"accumulatorRoot"` // Transaction accumulator
	QuorumCert      []byte   `json:"quorumCert"`      // HotStuff QC
}

type AptosValidator struct {
	Address     [32]byte `json:"address"`
	PublicKey   [32]byte `json:"publicKey"` // Ed25519
	VotingPower uint64   `json:"votingPower"`
}

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

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

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

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

type BitcoinCheckpoint struct {
	Height    uint64   `json:"height"`
	Hash      [32]byte `json:"hash"`
	Timestamp uint32   `json:"timestamp"`
}

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

type BitcoinHeader struct {
	Version    int32    `json:"version"`
	PrevBlock  [32]byte `json:"prevBlock"`
	MerkleRoot [32]byte `json:"merkleRoot"`
	Timestamp  uint32   `json:"timestamp"`
	Bits       uint32   `json:"bits"` // Difficulty target
	Nonce      uint32   `json:"nonce"`

	// Computed fields
	Hash      [32]byte `json:"hash"`
	Height    uint64   `json:"height"`
	ChainWork *big.Int `json:"chainWork"`
}

type Blob struct {
	ID         [32]byte  `json:"id"`
	Data       []byte    `json:"data"`
	Commitment [32]byte  `json:"commitment"`
	Size       uint64    `json:"size"`
	CreatedAt  time.Time `json:"createdAt"`
	ExpiresAt  time.Time `json:"expiresAt"`
	Encrypted  bool      `json:"encrypted"`

	// Chunking for large blobs
	ChunkCount  uint32     `json:"chunkCount"`
	ChunkSize   uint32     `json:"chunkSize"`
	ChunkHashes [][32]byte `json:"chunkHashes,omitempty"`

	// Erasure coding
	DataShards   int `json:"dataShards"`
	ParityShards int `json:"parityShards"`

	// Replication
	Regions      []string `json:"regions"`
	ReplicaCount int      `json:"replicaCount"`
}

type BlockHeader struct {
	ChainID     ChainID  `json:"chainId"`
	BlockNumber uint64   `json:"blockNumber"`
	BlockHash   [32]byte `json:"blockHash"`
	ParentHash  [32]byte `json:"parentHash"`
	StateRoot   [32]byte `json:"stateRoot"`
	TxRoot      [32]byte `json:"txRoot"`
	ReceiptRoot [32]byte `json:"receiptRoot"`
	Timestamp   int64    `json:"timestamp"`

	// Chain-specific fields stored as raw bytes
	ExtraData []byte `json:"extraData"`

	// Proof of finality (varies by chain)
	FinalityProof []byte `json:"finalityProof"`
}

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

type BridgeMetrics struct {
	TotalPending     int                      `json:"totalPending"`
	TotalCompleted   int                      `json:"totalCompleted"`
	PendingByChain   map[ChainID]int          `json:"pendingByChain"`
	CompletedByRoute map[string]int           `json:"completedByRoute"` // "source->dest" format
	AverageTime      map[string]time.Duration `json:"averageTime"`
}

type BridgeRequest struct {
	// Request identification
	ID        ids.ID    `json:"id"`
	Nonce     uint64    `json:"nonce"`
	CreatedAt time.Time `json:"createdAt"`

	// Chain routing
	SourceChain ChainID `json:"sourceChain"`
	DestChain   ChainID `json:"destChain"`

	// Transfer details
	Sender    []byte `json:"sender"`
	Recipient []byte `json:"recipient"`
	Asset     ids.ID `json:"asset"`
	Amount    []byte `json:"amount"` // Big-endian encoded

	// Source chain proof
	SourceTxHash [32]byte          `json:"sourceTxHash"`
	SourceBlock  uint64            `json:"sourceBlock"`
	SourceProof  *TxInclusionProof `json:"sourceProof,omitempty"`

	// Status tracking
	Status        BridgeStatus `json:"status"`
	Confirmations uint32       `json:"confirmations"`

	// MPC signature
	Signature []byte    `json:"signature,omitempty"`
	SignedAt  time.Time `json:"signedAt,omitempty"`

	// Destination chain completion
	DestTxHash  [32]byte  `json:"destTxHash,omitempty"`
	DestBlock   uint64    `json:"destBlock,omitempty"`
	CompletedAt time.Time `json:"completedAt,omitempty"`
}

type BridgeRoute struct {
	SourceChain   ChainID       `json:"sourceChain"`
	DestChain     ChainID       `json:"destChain"`
	SourceConfig  *ChainConfig  `json:"sourceConfig"`
	DestConfig    *ChainConfig  `json:"destConfig"`
	MinAmount     []byte        `json:"minAmount"`
	MaxAmount     []byte        `json:"maxAmount"`
	EstimatedTime time.Duration `json:"estimatedTime"`
	BridgeFee     uint64        `json:"bridgeFee"` // In basis points (1/100 of 1%)
	Enabled       bool          `json:"enabled"`
}

type BridgeStatus uint8

type BridgeTransfer struct {
	ID          ids.ID  `json:"id"`
	SourceChain ChainID `json:"sourceChain"`
	DestChain   ChainID `json:"destChain"`
	Sender      []byte  `json:"sender"`
	Recipient   []byte  `json:"recipient"`
	Asset       ids.ID  `json:"asset"`
	Amount      []byte  `json:"amount"` // Big-endian encoded
	Data        []byte  `json:"data"`
	RawTxBytes  []byte  `json:"rawTxBytes"`
}

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

type CRDTOpType uint8

type CRDTType uint8

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

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

type CardanoBlock struct {
	Slot        uint64   `json:"slot"`
	Epoch       uint64   `json:"epoch"`
	BlockHash   [32]byte `json:"blockHash"`
	PrevHash    [32]byte `json:"prevHash"`
	PoolID      [28]byte `json:"poolId"`   // Stake pool that minted
	VRFVKey     [32]byte `json:"vrfVKey"`  // VRF verification key
	BlockVRF    [64]byte `json:"blockVrf"` // VRF proof for slot leader
	OpCert      []byte   `json:"opCert"`   // Operational certificate
	ProtocolVer uint32   `json:"protocolVer"`
}

type CardanoPool struct {
	PoolID        [28]byte `json:"poolId"`
	VRFKeyHash    [32]byte `json:"vrfKeyHash"`
	Pledge        uint64   `json:"pledge"`
	Cost          uint64   `json:"cost"`
	Margin        float64  `json:"margin"`
	RelativeStake float64  `json:"relativeStake"` // Stake relative to total
}

type ChainAdapter interface {
	// ChainID returns the chain identifier
	ChainID() ChainID

	// ChainName returns the human-readable chain name
	ChainName() string

	// VerificationMode returns the primary verification mode for this chain
	VerificationMode() VerificationMode

	// VerifyBlockHeader verifies a block header from this chain
	VerifyBlockHeader(ctx context.Context, header *BlockHeader) error

	// VerifyTransaction verifies a transaction inclusion proof
	VerifyTransaction(ctx context.Context, proof *TxInclusionProof) error

	// VerifyMessage verifies a cross-chain message from this chain
	VerifyMessage(ctx context.Context, msg *CrossChainMessage) error

	// VerifyEvent verifies an event/log from this chain
	VerifyEvent(ctx context.Context, event *ChainEvent) error

	// GetLatestFinalizedBlock returns the latest finalized block number
	GetLatestFinalizedBlock(ctx context.Context) (uint64, error)

	// GetRequiredConfirmations returns required confirmations for finality
	GetRequiredConfirmations() uint64

	// GetBlockTime returns the average block time
	GetBlockTime() time.Duration

	// IsFinalized checks if a block is considered finalized
	IsFinalized(ctx context.Context, blockNumber uint64) (bool, error)

	// GetValidatorSet returns the current validator set (if applicable)
	GetValidatorSet(ctx context.Context) (*ValidatorSet, error)

	// Initialize initializes the adapter with configuration
	Initialize(config *ChainConfig) error

	// Close cleans up adapter resources
	Close() error
}

type ChainCategory string

type ChainConfig struct {
	ChainID        ChainID       `json:"chainId"`
	Name           string        `json:"name"`
	NetworkID      uint64        `json:"networkId"`      // Internal network identifier
	EVMChainID     uint64        `json:"evmChainId"`     // EVM chain ID (0 for non-EVM)
	NativeSymbol   string        `json:"nativeSymbol"`   // e.g., "ETH", "BTC", "SOL"
	NativeDecimals uint8         `json:"nativeDecimals"` // e.g., 18 for ETH, 8 for BTC
	IsEVM          bool          `json:"isEvm"`          // True for EVM-compatible chains
	ChainType      ChainType     `json:"chainType"`      // Fundamental architecture type
	AddressFormat  AddressFormat `json:"addressFormat"`  // Address encoding format
	AddressPrefix  string        `json:"addressPrefix"`  // Address prefix (0x, bc1, cosmos1, etc.)
	RPCEndpoints   []string      `json:"rpcEndpoints"`
	WSEndpoints    []string      `json:"wsEndpoints,omitempty"`
	ExplorerURL    string        `json:"explorerUrl,omitempty"`

	// Finality parameters
	RequiredConfirmations uint64        `json:"requiredConfirmations"`
	FinalityMode          string        `json:"finalityMode"` // "probabilistic", "instant", "epoch"
	BlockTime             time.Duration `json:"blockTime"`

	// Verification parameters
	TrustThreshold     float64       `json:"trustThreshold"` // e.g., 0.67 for 2/3
	MaxClockDrift      time.Duration `json:"maxClockDrift"`
	StalenessThreshold time.Duration `json:"stalenessThreshold"`

	// MPC/Bridge parameters
	SupportsMPC            bool   `json:"supportsMpc"`    // Supports MPC/TSS signing
	MPCCurve               string `json:"mpcCurve"`       // secp256k1, ed25519, sr25519, bls12381
	NativeMultisig         bool   `json:"nativeMultisig"` // Has native multisig support
	SupportsSmartContracts bool   `json:"supportsSmartContracts"`

	// Chain-specific config stored as raw bytes
	ExtraConfig []byte `json:"extraConfig,omitempty"`
}

type ChainEvent struct {
	ChainID     ChainID  `json:"chainId"`
	BlockNumber uint64   `json:"blockNumber"`
	TxHash      [32]byte `json:"txHash"`
	LogIndex    uint32   `json:"logIndex"`

	// Event identifier (e.g., topic0 for Ethereum)
	EventID [32]byte `json:"eventId"`

	// Event data
	Address []byte   `json:"address"`
	Topics  [][]byte `json:"topics"`
	Data    []byte   `json:"data"`

	// Proof of inclusion
	Proof []byte `json:"proof"`
}

type ChainID uint32

type ChainKeySet struct {
	ChainID    ChainID      `json:"chainId"`
	ChainType  ChainType    `json:"chainType"`
	Curve      SigningCurve `json:"curve"`
	PublicKey  []byte       `json:"publicKey"` // Derived public key for this chain
	Address    string       `json:"address"`   // Chain-specific address
	MPCShare   *MPCKeyShare `json:"mpcShare,omitempty"`
	DerivePath string       `json:"derivePath"` // BIP44/derivation path
}

type ChainMetrics struct {
	ChainID                 ChainID
	LastVerifiedBlock       uint64
	TotalVerifications      uint64
	SuccessfulVerifications uint64
	FailedVerifications     uint64
	AverageLatency          time.Duration
	LastError               error
	LastErrorTime           time.Time
}

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

type ChainType uint8

type CollectionSchema struct {
	Name       string           `json:"name"`
	Fields     []*FieldSchema   `json:"fields"`
	Indexes    []*IndexSchema   `json:"indexes"`
	PrimaryKey string           `json:"primaryKey"`
	CRDTType   CRDTType         `json:"crdtType"`
	Encrypted  bool             `json:"encrypted"`
	Domain     EncryptionDomain `json:"domain"`
}

type CommitmentScheme uint8

type CommitteeCert struct {
	CommitteeID  ids.ID `json:"committeeId"`
	Threshold    int    `json:"threshold"`
	TotalMembers int    `json:"totalMembers"`

	// Endorsements from committee members
	Endorsements []*Endorsement `json:"endorsements"`

	// Aggregate signature (if using BLS)
	AggregateSignature []byte `json:"aggregateSignature,omitempty"`

	// What is being certified
	RequestID        ids.ID    `json:"requestId"`
	OutputCommitment [32]byte  `json:"outputCommitment"`
	Timestamp        time.Time `json:"timestamp"`
}

type ComputeAnchor struct {
	ResultID   ids.ID `json:"resultId"`
	RequestID  ids.ID `json:"requestId"`
	AppChainID ids.ID `json:"appChainId"`

	// Commitments
	InputCommitment  [32]byte `json:"inputCommitment"`
	OutputCommitment [32]byte `json:"outputCommitment"`
	ProgramHash      [32]byte `json:"programHash"`

	// Attestation summary
	TEEType          TEEType `json:"teeType,omitempty"`
	HasTEEAttest     bool    `json:"hasTeeAttest"`
	HasZKProof       bool    `json:"hasZkProof"`
	HasCommitteeCert bool    `json:"hasCommitteeCert"`

	// DA reference for full attestation
	AttestationDAPointer *DAPointer `json:"attestationDaPointer"`

	// Block anchoring
	BlockHeight uint64    `json:"blockHeight"`
	BlockHash   [32]byte  `json:"blockHash"`
	TxIndex     uint32    `json:"txIndex"`
	Timestamp   time.Time `json:"timestamp"`
}

type ComputeCommittee struct {
	ID         ids.ID
	Members    [][]byte
	Threshold  int
	PublicKeys [][]byte
}

type ComputeMode uint8

type ComputeProof struct {
	ProofSystem  string   `json:"proofSystem"` // "groth16", "plonk", "stark"
	Proof        []byte   `json:"proof"`
	PublicInputs [][]byte `json:"publicInputs"`
	VerifyingKey []byte   `json:"verifyingKey"`

	// Commitments
	InputCommitment  [32]byte `json:"inputCommitment"`
	OutputCommitment [32]byte `json:"outputCommitment"`
	ProgramHash      [32]byte `json:"programHash"`
}

type ComputeRequest struct {
	ID         ids.ID `json:"id"`
	AppChainID ids.ID `json:"appChainId"`
	Requester  []byte `json:"requester"`

	// Input specification
	InputRefs       []DataRef `json:"inputRefs"` // References to encrypted input data
	InputCommitment [32]byte  `json:"inputCommitment"`

	// Computation specification
	ComputeMode ComputeMode `json:"computeMode"`
	Program     []byte      `json:"program"` // WASM, bytecode, or program hash
	ProgramHash [32]byte    `json:"programHash"`
	Parameters  []byte      `json:"parameters"`

	// Output specification
	OutputDomain     EncryptionDomain `json:"outputDomain"`
	OutputRecipients [][]byte         `json:"outputRecipients"`

	// Attestation requirements
	RequireTEE   bool      `json:"requireTee"`
	AcceptedTEEs []TEEType `json:"acceptedTees"`
	RequireProof bool      `json:"requireProof"`

	// Timing
	Deadline time.Time `json:"deadline"`
	MaxGas   uint64    `json:"maxGas"`
}

type ComputeResult struct {
	RequestID ids.ID        `json:"requestId"`
	Status    ComputeStatus `json:"status"`

	// Output
	OutputData       []byte     `json:"outputData"` // Encrypted
	OutputCommitment [32]byte   `json:"outputCommitment"`
	OutputDAPointer  *DAPointer `json:"outputDaPointer,omitempty"`

	// Attestation
	Attestation   *TEEAttestation `json:"attestation,omitempty"`
	Proof         *ComputeProof   `json:"proof,omitempty"`
	CommitteeCert *CommitteeCert  `json:"committeeCert,omitempty"`

	// Timing
	ComputedAt time.Time `json:"computedAt"`
	GasUsed    uint64    `json:"gasUsed"`
}

type ComputeSession struct {
	Request      *ComputeRequest
	Status       ComputeStatus
	StartedAt    time.Time
	Endorsements []*Endorsement
}

type ComputeStatus uint8

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

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

type CosmosHeader struct {
	Height             uint64   `json:"height"`
	Time               int64    `json:"time"`
	ChainID            string   `json:"chainId"`
	LastBlockHash      [32]byte `json:"lastBlockHash"`
	DataHash           [32]byte `json:"dataHash"`
	ValidatorsHash     [32]byte `json:"validatorsHash"`
	NextValidatorsHash [32]byte `json:"nextValidatorsHash"`
	ConsensusHash      [32]byte `json:"consensusHash"`
	AppHash            [32]byte `json:"appHash"`
	LastResultsHash    [32]byte `json:"lastResultsHash"`
	EvidenceHash       [32]byte `json:"evidenceHash"`
	ProposerAddress    [20]byte `json:"proposerAddress"`

	// Computed
	Hash      [32]byte `json:"hash"`
	Finalized bool     `json:"finalized"`
}

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

type CosmosSDKBlock struct {
	Height         uint64   `json:"height"`
	Hash           [32]byte `json:"hash"`
	AppHash        [32]byte `json:"appHash"`
	ValidatorsHash [32]byte `json:"validatorsHash"`
	Timestamp      uint64   `json:"timestamp"`
	Signatures     [][]byte `json:"signatures"`
}

type CosmosSDKValidator struct {
	Address     [20]byte `json:"address"`
	PubKey      []byte   `json:"pubKey"`
	VotingPower int64    `json:"votingPower"`
}

type CrossChainAsset struct {
	AssetID          ids.ID             `json:"assetId"`
	Name             string             `json:"name"`
	Symbol           string             `json:"symbol"`
	Decimals         uint8              `json:"decimals"`
	NativeChain      ChainID            `json:"nativeChain"`      // Chain where asset is native
	WrappedAddresses map[ChainID][]byte `json:"wrappedAddresses"` // Wrapped addresses on other chains
}

type CrossChainMessage struct {
	ID          ids.ID  `json:"id"`
	SourceChain ChainID `json:"sourceChain"`
	DestChain   ChainID `json:"destChain"`
	Sender      []byte  `json:"sender"`
	Recipient   []byte  `json:"recipient"`
	Nonce       uint64  `json:"nonce"`
	Payload     []byte  `json:"payload"`

	// Source chain proof
	SourceBlock  uint64   `json:"sourceBlock"`
	SourceTxHash [32]byte `json:"sourceTxHash"`
	SourceProof  []byte   `json:"sourceProof"`

	// Timestamp and expiry
	Timestamp  int64 `json:"timestamp"`
	ExpiryTime int64 `json:"expiryTime"`
}

type DAClient interface {
	// Store stores data in the DA layer and returns a pointer
	Store(ctx context.Context, data []byte, commitment [32]byte) (*DAPointer, error)

	// Retrieve retrieves data from the DA layer
	Retrieve(ctx context.Context, pointer *DAPointer) ([]byte, error)

	// GetAvailabilityReceipt gets proof of data availability
	GetAvailabilityReceipt(ctx context.Context, pointer *DAPointer) (*DAReceipt, error)

	// SetReplicationPolicy sets geographic replication policy
	SetReplicationPolicy(ctx context.Context, pointer *DAPointer, regions []string) error

	// Prune removes data that's past retention
	Prune(ctx context.Context, before time.Time) error
}

type DACommitment struct {
	Scheme     CommitmentScheme `json:"scheme"`
	Data       []byte           `json:"data"`
	Proof      []byte           `json:"proof,omitempty"`
	Parameters []byte           `json:"parameters,omitempty"`
}

type DAConfig struct {
	LayerType         DALayerType   `json:"layerType"`
	Endpoints         []string      `json:"endpoints"`
	ReplicationFactor int           `json:"replicationFactor"`
	RetentionPeriod   time.Duration `json:"retentionPeriod"`
	MaxBlobSize       uint64        `json:"maxBlobSize"`
	SamplingEnabled   bool          `json:"samplingEnabled"`
	SamplingRate      int           `json:"samplingRate"` // Samples per blob
}

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

type DAGVertex struct {
	Hash      [32]byte   `json:"hash"`
	Parents   [][32]byte `json:"parents"`
	Timestamp uint64     `json:"timestamp"`
	Round     uint64     `json:"round"`
	Confirmed bool       `json:"confirmed"`
}

type DALayerType uint8

type DAMetrics struct {
	TotalBlobs      int64         `json:"totalBlobs"`
	TotalSize       uint64        `json:"totalSize"`
	CacheHitRate    float64       `json:"cacheHitRate"`
	AvgLatency      time.Duration `json:"avgLatency"`
	NodeCount       int           `json:"nodeCount"`
	HealthyNodes    int           `json:"healthyNodes"`
	ReplicationRate float64       `json:"replicationRate"`
}

type DANode struct {
	ID           []byte    `json:"id"`
	Endpoint     string    `json:"endpoint"`
	Region       string    `json:"region"`
	Stake        uint64    `json:"stake"`
	Reputation   uint64    `json:"reputation"`
	LastSeen     time.Time `json:"lastSeen"`
	StorageUsed  uint64    `json:"storageUsed"`
	StorageLimit uint64    `json:"storageLimit"`
}

type DAPointer struct {
	BlobID        [32]byte  `json:"blobId"`
	ChunkIndex    uint32    `json:"chunkIndex"`
	Size          uint64    `json:"size"`
	AvailableFrom time.Time `json:"availableFrom"`
	ExpiresAt     time.Time `json:"expiresAt"`
	Commitment    [32]byte  `json:"commitment"`
}

type DAReceipt struct {
	Pointer      *DAPointer `json:"pointer"`
	Attestations [][]byte   `json:"attestations"` // From DA nodes
	Timestamp    time.Time  `json:"timestamp"`
	ValidUntil   time.Time  `json:"validUntil"`
	Signature    []byte     `json:"signature"`
}

type DataRef struct {
	DocumentID DocumentID       `json:"documentId"`
	DAPointer  *DAPointer       `json:"daPointer"`
	Commitment [32]byte         `json:"commitment"`
	Domain     EncryptionDomain `json:"domain"`
}

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

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

type Document struct {
	ID        DocumentID       `json:"id"`
	Domain    EncryptionDomain `json:"domain"`
	Seq       uint64           `json:"seq"`     // Monotonic sequence number
	Version   [32]byte         `json:"version"` // Hash of current state
	CreatedAt time.Time        `json:"createdAt"`
	UpdatedAt time.Time        `json:"updatedAt"`

	// Encrypted content (ciphertext)
	EncryptedData []byte `json:"encryptedData"`

	// Commitment to the plaintext (for verification without decryption)
	DataCommitment [32]byte `json:"dataCommitment"`

	// CRDT metadata
	CRDTType    CRDTType          `json:"crdtType"`
	VectorClock map[string]uint64 `json:"vectorClock"`

	// DA layer reference
	DAPointer *DAPointer `json:"daPointer,omitempty"`
}

type DocumentID struct {
	AppChainID ids.ID `json:"appChainId"`
	Collection string `json:"collection"`
	DocID      string `json:"docId"`
}

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

type DomainKeySet struct {
	Domain     EncryptionDomain `json:"domain"`
	Version    uint32           `json:"version"`
	PublicKey  []byte           `json:"publicKey"`
	PrivateKey []byte           `json:"privateKey,omitempty"` // Only if holder has access
	EncryptKey []byte           `json:"encryptKey"`           // Symmetric key for data encryption
	CreatedAt  int64            `json:"createdAt"`
	RotatedAt  int64            `json:"rotatedAt,omitempty"`
}

type EVMHeader struct {
	BlockNumber uint64   `json:"blockNumber"`
	ParentHash  [32]byte `json:"parentHash"`
	StateRoot   [32]byte `json:"stateRoot"`
	TxRoot      [32]byte `json:"txRoot"`
	ReceiptRoot [32]byte `json:"receiptRoot"`
	Hash        [32]byte `json:"hash"`
	Timestamp   uint64   `json:"timestamp"`
}

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

type EncryptionCapability struct {
	PartyID     []byte             `json:"partyId"`
	Domains     []EncryptionDomain `json:"domains"`     // Domains party can access
	Operations  []FHEOperation     `json:"operations"`  // FHE operations allowed
	ReadOnly    bool               `json:"readOnly"`    // Can only decrypt, not encrypt
	ValidUntil  int64              `json:"validUntil"`  // Expiry timestamp
	Delegatable bool               `json:"delegatable"` // Can delegate to others
}

type EncryptionDomain uint8

type Encryptor interface {
	// Encrypt encrypts data for a specific domain
	Encrypt(ctx context.Context, data []byte, domain EncryptionDomain, recipients [][]byte) ([]byte, error)

	// Decrypt decrypts data if the caller has access
	Decrypt(ctx context.Context, ciphertext []byte, domain EncryptionDomain, privateKey []byte) ([]byte, error)

	// EncryptFHE performs FHE encryption for homomorphic operations
	EncryptFHE(ctx context.Context, data []byte, scheme string) ([]byte, error)

	// ComputeFHE performs computation on FHE-encrypted data
	ComputeFHE(ctx context.Context, encrypted []byte, operation string, params []byte) ([]byte, error)

	// DecryptFHE decrypts FHE result
	DecryptFHE(ctx context.Context, encrypted []byte, privateKey []byte) ([]byte, error)

	// GenerateDomainKey generates a new key for an encryption domain
	GenerateDomainKey(domain EncryptionDomain) (publicKey, privateKey []byte, err error)

	// DeriveSharedKey derives a shared key for multi-party access
	DeriveSharedKey(parties [][]byte, threshold int) ([]byte, error)
}

type Endorsement struct {
	MemberID       []byte          `json:"memberId"`
	MemberIndex    int             `json:"memberIndex"`
	Signature      []byte          `json:"signature"`
	TEEAttestation *TEEAttestation `json:"teeAttestation,omitempty"`
}

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