adapters

type AccessListEntry struct {
	Address     [20]byte
	StorageKeys [][32]byte
}

type AccountStatus byte

type AdapterFactory struct{}

type AddressType byte

type AssetName string

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

type BitcoinNetwork int

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

type CardanoAddress struct {
	Type    AddressType
	Network byte
	Payment [28]byte // Payment credential hash
	Stake   [28]byte // Stake credential hash (optional)
}

type CardanoEra int

type CardanoMetadata struct {
	Labels map[uint64]interface{}
}

type CardanoTransaction struct {
	Body      *TransactionBody
	Witnesses *TransactionWitnessSet
	IsValid   bool
	AuxData   *CardanoMetadata // Optional metadata
}

type Certificate interface {
	Type() CertificateType
}

type CertificateType byte

type ECDSAExtensions struct {
	PaillierKey    interface{} // Paillier secret key
	PedersenParams interface{} // Pedersen parameters
	ChainCode      []byte      // HD wallet chain code
}

type ECDSAFullSig struct {
	R curve.Scalar
	S curve.Scalar
}

type ECDSAPartialSig struct {
	PartyID party.ID
	R       curve.Scalar
	S       curve.Scalar
}

type EIP1559Transaction struct {
	ChainID              *big.Int
	Nonce                uint64
	MaxPriorityFeePerGas *big.Int
	MaxFeePerGas         *big.Int
	GasLimit             uint64
	To                   [20]byte
	Value                *big.Int
	Data                 []byte
	AccessList           []AccessListEntry
}

type EIP4844Transaction struct {
	ChainID              *big.Int
	Nonce                uint64
	MaxPriorityFeePerGas *big.Int
	MaxFeePerGas         *big.Int
	GasLimit             uint64
	To                   [20]byte
	Value                *big.Int
	Data                 []byte
	AccessList           []AccessListEntry
	MaxFeePerBlobGas     *big.Int
	BlobVersionedHashes  [][32]byte
}

type EdDSAExtensions struct {
	AuxRand []byte // Auxiliary randomness for deterministic nonces
}

type EdDSAFullSig struct {
	R curve.Point
	Z curve.Scalar
}

type EdDSAPartialSig struct {
	PartyID party.ID
	R       curve.Point
	Z       curve.Scalar
}

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

type ExecutionUnits struct {
	Memory uint64
	Steps  uint64
}

type FullSig interface {
	Verify(pubKey curve.Point, message []byte) bool
	Serialize() []byte
}

type Input struct {
	PrevTxID  [32]byte
	PrevIndex uint32
	ScriptSig []byte
	Sequence  uint32
	Witness   [][]byte
}

type LegacyBitcoinTx struct {
	Version  uint32
	Inputs   []Input
	Outputs  []Output
	LockTime uint32
	SigHash  SigHashType
}

type LegacyTransaction struct {
	Nonce    uint64
	GasPrice *big.Int
	GasLimit uint64
	To       [20]byte
	Value    *big.Int
	Data     []byte
}

type NativeScript interface {
	Type() NativeScriptType
}

type NativeScriptType byte

type OfflineRound1 struct {
	Commitments [][]byte // Commitments to shares
	Nonces      []int64  // Random nonces
	Timestamp   int64
}

type OfflineRound2 struct {
	MaskedShares []int64  // Masked secret shares
	Proofs       [][]byte // Zero-knowledge proofs
}

type Output struct {
	Value        uint64
	ScriptPubKey []byte
}

type PartialSig interface {
	GetPartyID() party.ID
	Serialize() []byte
}

type PolicyID [28]byte

type ProtocolParameters struct {
	MinFeeA                uint32
	MinFeeB                uint32
	MaxBlockBodySize       uint32
	MaxTxSize              uint32
	MaxBlockHeaderSize     uint32
	KeyDeposit             uint64
	PoolDeposit            uint64
	MinPoolCost            uint64
	PriceMemory            Rational
	PriceSteps             Rational
	MaxTxExecutionUnits    ExecutionUnits
	MaxBlockExecutionUnits ExecutionUnits
	MaxValueSize           uint32
	CollateralPercentage   uint32
	MaxCollateralInputs    uint32
}

type ProtocolUpdate struct {
	Epoch          uint32
	ProtocolParams *ProtocolParameters
}

type Rational struct {
	Numerator   uint64
	Denominator uint64
}

type Redeemer struct {
	Tag     RedeemerTag
	Index   uint32
	Data    []byte
	ExUnits ExecutionUnits
}

type RedeemerTag byte

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

type RingtailBenchmark struct {
	DKGTime           int64 // microseconds
	PreprocessingTime int64 // microseconds per session
	SigningTime       int64 // microseconds (online only)
	VerificationTime  int64 // microseconds
	SignatureSize     int   // bytes
	CommunicationSize int   // total bytes exchanged
}

type RingtailExtensions struct {
	// Lattice parameters
	N             int     // Lattice dimension
	Q             int     // Modulus
	Sigma         float64 // Gaussian parameter
	SecurityLevel int     // 128, 192, or 256 bits

	// Offline preprocessing store
	PreprocessingShares []RingtailPreprocessing

	// Public parameters
	PublicMatrix interface{} // A matrix for LWE
}

type RingtailFullSig struct {
	Signature interface{} // Complete lattice signature
	Size      int         // Signature size in bytes
}

type RingtailOfflineData struct {
	ID         string
	Round1Data *OfflineRound1
	Round2Data *OfflineRound2
	Consumed   bool
}

type RingtailParams struct {
	N             int     // Lattice dimension
	Q             int64   // Modulus
	D             int     // Module rank
	M             int     // Number of samples
	Sigma         float64 // Gaussian parameter
	SecurityLevel int     // 128, 192, or 256 bits
	MaxParties    int     // Maximum number of parties (up to 1024)
	SignatureSize int     // Expected signature size in bytes
}

type RingtailPartialSig struct {
	PartyID party.ID
	Share   interface{} // Lattice element
}

type RingtailPreprocessing struct {
	ID       string
	Round1   interface{} // Offline round 1 data
	Round2   interface{} // Offline round 2 data
	Consumed bool
}

type RingtailPublicKey struct {
	A      [][]int64 // Public matrix A ∈ Z_q^{n×m}
	B      []int64   // Public vector B = As + e
	Params *RingtailParams
}

type RingtailSecretShare struct {
	PartyID party.ID
	S       []int64 // Secret share vector
	E       []int64 // Error share vector
	Index   int
}

type RingtailState struct {
	Generation         uint64
	Threshold          int
	Parties            []party.ID
	PublicKey          *RingtailPublicKey
	PreprocessingStore map[string]*RingtailOfflineData
	ConsumedPreproc    map[string]bool
}

type SchnorrFullSig struct {
	R curve.Point
	S curve.Scalar
}

type SchnorrPartialSig struct {
	PartyID party.ID
	R       curve.Point
	S       curve.Scalar
}

type Script interface {
	Hash() [28]byte
}

type SegwitTx struct {
	Version    uint32
	InputTxID  [32]byte
	InputIndex uint32
	ScriptCode []byte
	Amount     uint64
	Sequence   uint32
	Outputs    []Output
	LockTime   uint32
	SigHash    SigHashType
}

type Share struct {
	ID    party.ID
	Value curve.Scalar
	Index int
}

type SigHashType uint32

type Signature [64]byte

type SignatureType int

type SignerAdapter interface {
	// Digest computes chain-specific message digest
	Digest(tx interface{}) ([]byte, error)

	// SignEC creates a partial signature with a party's share
	SignEC(digest []byte, share Share) (PartialSig, error)

	// AggregateEC combines partial signatures into a full signature
	AggregateEC(parts []PartialSig) (FullSig, error)

	// Encode converts signature to chain-specific wire format
	Encode(full FullSig) ([]byte, error)

	// ValidateConfig checks if configuration is valid for this chain
	ValidateConfig(config *UnifiedConfig) error
}

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

type SolanaConfig struct {
	Cluster         string // mainnet-beta, testnet, devnet
	CommitmentLevel string // processed, confirmed, finalized
	SkipPreflight   bool
	PreflightCommit string
	MaxRetries      int
	MinContextSlot  uint64
}

type SolanaInstruction struct {
	ProgramIDIndex byte
	AccountIndices []byte
	Data           []byte
}

type SolanaMessage struct {
	NumRequiredSignatures       byte
	NumReadonlySignedAccounts   byte
	NumReadonlyUnsignedAccounts byte
	AccountKeys                 [][32]byte
	RecentBlockhash             [32]byte
	Instructions                []*SolanaInstruction
}

type SolanaTransaction struct {
	Signatures []Signature
	Message    *SolanaMessage
}

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

type TONAddress struct {
	Workchain int32
	Hash      [32]byte
}

type TONCurrencyCollection struct {
	Grams           uint64
	ExtraCurrencies map[uint32]uint64
}

type TONMessage struct {
	Info TONMessageInfo
	Init *TONStateInit // Optional
	Body []byte
}

type TONMessageInfo struct {
	IHRDisabled bool
	Bounce      bool
	Bounced     bool
	Source      TONAddress
	Destination TONAddress
	Value       TONCurrencyCollection
	IHRFee      uint64
	FwdFee      uint64
	CreatedLt   uint64
	CreatedAt   uint32
}

type TONStateInit struct {
	Code    []byte
	Data    []byte
	Library []byte
}

type TONTransaction struct {
	Account       TONAddress
	Lt            uint64
	PrevTransHash [32]byte
	PrevTransLt   uint64
	Now           uint32
	OutMsgCount   uint16
	OrigStatus    AccountStatus
	EndStatus     AccountStatus
	InMsg         *TONMessage
	OutMsgs       []*TONMessage
}

type TaprootTx struct {
	SegwitTx
	ScriptPath   bool
	TapScript    []byte
	ControlBlock []byte
	Annex        []byte
}

type TransactionBody struct {
	Inputs           []TransactionInput
	Outputs          []TransactionOutput
	Fee              uint64
	TTL              uint32 // Time to live (slot)
	Certificates     []Certificate
	Withdrawals      map[string]uint64 // Stake address -> amount
	Update           *ProtocolUpdate
	AuxDataHash      [32]byte
	ValidityInterval *ValidityInterval
	Mint             map[PolicyID]map[AssetName]int64
	ScriptDataHash   [32]byte
	Collateral       []TransactionInput
	RequiredSigners  [][28]byte // Key hashes
	NetworkID        byte
	CollateralReturn *TransactionOutput
	TotalCollateral  uint64
	ReferenceInputs  []TransactionInput
}

type TransactionInput struct {
	TxID  [32]byte
	Index uint32
}

type TransactionOutput struct {
	Address   CardanoAddress
	Value     Value
	DatumHash *[32]byte // Optional for smart contracts
	Data      []byte    // Inline datum (Babbage era)
	Script    []byte    // Reference script (Babbage era)
}

type TransactionWitnessSet struct {
	VKeyWitnesses []VKeyWitness
	Scripts       []Script
	PlutusData    [][]byte
	Redeemers     []Redeemer
	NativeScripts []NativeScript
}

type UnifiedConfig struct {
	// Common fields
	ID         party.ID
	Threshold  int
	Generation uint64
	PartyIDs   []party.ID

	// Signature type
	SignatureScheme SignatureType

	// Curve-specific
	Group curve.Curve

	// Shared secrets (works for both EC and PQ)
	SecretShare interface{} // curve.Scalar for EC, lattice element for PQ
	PublicKey   interface{} // curve.Point for EC, lattice public key for PQ

	// Additional scheme-specific data
	ECDSAConfig    *ECDSAExtensions
	EdDSAConfig    *EdDSAExtensions
	RingtailConfig *RingtailExtensions

	// Verification shares for all parties
	VerificationShares map[party.ID]interface{}
}

type VKeyWitness struct {
	VKey      [32]byte // Public key
	Signature [64]byte // Ed25519 signature
}

type ValidityInterval struct {
	InvalidBefore uint32 // Slot
	InvalidAfter  uint32 // Slot
}

type Value struct {
	Coin       uint64
	MultiAsset map[PolicyID]map[AssetName]uint64
}

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

type XRPLHashPrefix [4]byte

type XRPLTransaction struct {
	Account         string
	TransactionType string
	Destination     string
	Amount          string
	Fee             string
	Sequence        uint32
	SigningPubKey   string
	TxnSignature    string
}