adapters

type AccessKey struct {
	Nonce      uint64
	Permission Permission
}

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

type AccountStatus byte

type ActionType byte

type AdapterFactory struct{}

type AddKeyAction struct {
	PublicKey PublicKey
	AccessKey AccessKey
}

type AddressType byte

type AssetName string

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

type BitcoinNetwork int

type CallArg interface {
	Type() CallArgType
}

type CallArgType byte

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 CeloAccessListEntry struct {
	Address     [20]byte
	StorageKeys [][32]byte
}

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

type CeloLegacyTransaction struct {
	Nonce               uint64
	GasPrice            *big.Int
	GasLimit            uint64
	FeeCurrency         *[20]byte // Celo-specific
	GatewayFeeRecipient *[20]byte // Celo-specific
	GatewayFee          *big.Int  // Celo-specific
	To                  *[20]byte
	Value               *big.Int
	Data                []byte
}

type CeloTransaction struct {
	ChainID              *big.Int
	Nonce                uint64
	MaxPriorityFeePerGas *big.Int
	MaxFeePerGas         *big.Int
	GatewayFeeRecipient  *[20]byte // Celo-specific
	GatewayFee           *big.Int  // Celo-specific
	FeeCurrency          *[20]byte // Celo-specific: address of token to pay fees in
	GasLimit             uint64
	To                   *[20]byte
	Value                *big.Int
	Data                 []byte
	AccessList           []CeloAccessListEntry
}

type Certificate interface {
	Type() CertificateType
}

type CertificateType byte

type ChainConfig struct {
	ChainID         *big.Int
	Name            string
	Symbol          string
	ExplorerURL     string
	RPCURL          string
	IsL2            bool
	SupportsEIP1559 bool
	SupportsBlobTx  bool
}

type Command interface {
	Type() CommandType
}

type CommandType byte

type DeployContractAction struct {
	Code []byte
}

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

type DilithiumBenchmark struct {
	DKGTime          int64 // microseconds
	SigningTime      int64 // microseconds
	VerificationTime int64 // microseconds
	SignatureSize    int   // bytes
	PublicKeySize    int   // bytes
}

type DilithiumExtensions struct {
	// NIST security level (2, 3, or 5)
	SecurityLevel int // Maps to ML-DSA-44, ML-DSA-65, ML-DSA-87

	// Lattice parameters (auto-configured based on security level)
	K int // Vector dimension
	L int // Matrix dimension

	// Public seed for deterministic key generation
	PublicSeed []byte
}

type DilithiumFullSig struct {
	Z    [][]int32 // Response vector
	H    []byte    // Hint
	C    []int32   // Challenge
	Size int       // Total size in bytes
}

type DilithiumParams struct {
	SecurityLevel int    // NIST security level (2, 3, or 5)
	Name          string // ML-DSA-44, ML-DSA-65, ML-DSA-87

	// Lattice parameters
	N      int   // Polynomial degree (256)
	Q      int64 // Modulus (8380417)
	D      int   // Dropped bits from t
	K      int   // Number of polynomials in vector
	L      int   // Number of polynomials in matrix
	Eta    int   // Secret key range
	Beta   int   // Tau bound
	Gamma1 int   // y coefficient range
	Gamma2 int   // Low-order rounding range
	Omega  int   // Number of ±1 in c
	Tau    int   // Number of ±1 in c (threshold)

	// Signature parameters
	SignatureSize int // Signature size in bytes
	PublicKeySize int // Public key size in bytes
	SecretKeySize int // Secret key size in bytes
}

type DilithiumPartialSig struct {
	PartyID   party.ID
	Z         [][]int32 // Masked response
	H         []byte    // Hint for signature reconstruction
	Challenge []int32   // Challenge polynomial c
}

type DilithiumPublicKey struct {
	Seed   []byte    // Public seed ρ
	T1     [][]int32 // High-order bits of t = As + e
	Params *DilithiumParams
}

type DilithiumSecretShare struct {
	PartyID party.ID
	S       [][]int32 // Secret polynomials
	E       [][]int32 // Error polynomials
	T       [][]int32 // Target polynomials
	Index   int
}

type DilithiumState struct {
	Generation uint64
	Threshold  int
	Parties    []party.ID
	PublicKey  *DilithiumPublicKey
	Shares     map[party.ID]*DilithiumSecretShare
}

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 EVMAdapter struct {
	// contains filtered or unexported fields
}

type EVMChain string

type EVMTransaction struct {
	Type                 byte
	ChainID              *big.Int
	Nonce                uint64
	GasPrice             *big.Int // Legacy
	MaxPriorityFeePerGas *big.Int // EIP-1559
	MaxFeePerGas         *big.Int // EIP-1559
	GasLimit             uint64
	To                   *[20]byte
	Value                *big.Int
	Data                 []byte
	AccessList           []AccessListEntry
	BlobVersionedHashes  [][32]byte // EIP-4844
	MaxFeePerBlobGas     *big.Int   // EIP-4844
}

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 F int64

type FullAccessPermission struct{}

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

type FunctionCallAction struct {
	MethodName string
	Args       []byte
	Gas        uint64
	Deposit    NEARAmount
}

type FunctionCallPermissionData struct {
	Allowance   *NEARAmount
	ReceiverID  string
	MethodNames []string
}

type GasPayment struct {
	Objects []ObjectRef
	Owner   SuiAddress
	Price   uint64
	Budget  uint64
}

type Hints struct {
	Idx [][]int // Per-row positions where HighBits differ
}

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

type KeyType 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 MLDSAParams struct {
	Name          string // ML-DSA-44, ML-DSA-65, ML-DSA-87
	SecurityLevel int    // NIST level: 2, 3, or 5

	// Core parameters
	Q        int64 // 8380417 (prime modulus)
	N        int   // 256 (polynomial degree)
	K        int   // Vector dimension
	L        int   // Matrix dimension
	D        int   // Dropped bits
	Tau      int   // Challenge weight
	Eta      int   // Secret key range
	Beta     int   // Rejection bound
	Gamma1   int   // y coefficient range
	Gamma2   int   // Low-order rounding range
	Alpha2G2 int   // 2*Gamma2 for HighBits
	Omega    int   // Max hints per row

	// Sizes
	SignatureSize int
	PublicKeySize int
	SecretKeySize int
}

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

type MPCEngine interface {
	Add(a, b []F) []F
	Sub(a, b []F) []F
	MulConst(a []F, c F) []F
	HighBitsVec(v []SecretPoly, alpha int) ([]SecretPoly, error)
	Open(s []SecretPoly) ([]Poly, error)
	OpenAtZero(s []SecretPoly, subset []party.ID, lambda map[party.ID]F) ([]Poly, error)
	EqZero(a []F) (bool, error)
	LongOverflow(v []SecretPoly, bound int) (bool, error)
}

type NEARAction interface {
	Type() ActionType
}

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

type NEARAmount struct {
	Amount [16]byte // 128-bit integer
}

type NEARTransaction struct {
	SignerID   string
	PublicKey  PublicKey
	Nonce      uint64
	ReceiverID string
	BlockHash  [32]byte
	Actions    []NEARAction
}

type NativeScript interface {
	Type() NativeScriptType
}

type NativeScriptType byte

type ObjectDigest [32]byte

type ObjectID [32]byte

type ObjectRef struct {
	ObjectID ObjectID
	Version  uint64
	Digest   ObjectDigest
}

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 Permission interface {
	Type() PermissionType
}

type PermissionType byte

type PolicyID [28]byte

type Poly [256]F

type Precomp struct {
	Y  []SecretPoly // Secret-shared masking polynomials
	W  []SecretPoly // Secret W = A*Y
	WH []Poly       // Public HighBits(W)
}

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 PubOps interface {
	VecMulByPublicPoly(v []SecretPoly, p Poly) []SecretPoly
	LiftPublicPoly(p Poly) SecretPoly
	MatrixVectorMul(A [][]Poly, v []SecretPoly) []SecretPoly
}

type PublicKey struct {
	KeyType KeyType
	Data    [32]byte
}

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 SecretPoly struct {
	Coeffs []F // Secret-shared coefficients
}

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 Sig struct {
	C Poly   // Challenge polynomial
	Z []Poly // Response vector
	H Hints  // Hint positions
}

type SigHashType uint32

type SignParams struct {
	Params  MLDSAParams
	Omega   int
	DeriveC func(mu []byte, wH []Poly) (Poly, error)
	PubMul  func(a, b Poly) Poly
}

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 StakeAction struct {
	Stake     NEARAmount
	PublicKey PublicKey
}

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

type SuiAddress [32]byte

type SuiProgrammableTransaction struct {
	Inputs   []CallArg
	Commands []Command
}

type SuiTransaction struct {
	Kind       TransactionKind
	Sender     SuiAddress
	GasPayment *GasPayment
	GasPrice   uint64
	GasBudget  uint64
	Expiration *TransactionExpiration
}

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 ThresholdConfig struct {
	Subset []party.ID     // Active signers (m >= t)
	Alpha  map[party.ID]F // Shamir x-coordinates (non-zero)
	T      int            // Threshold
	N      int            // Total parties
	Q      F              // Field modulus
}

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 TransactionExpiration struct {
	Epoch uint64
}

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

type TransactionKind interface {
	Type() TransactionType
}

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 TransactionType byte

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

type TransferAction struct {
	Deposit NEARAmount
}

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
	DilithiumConfig *DilithiumExtensions

	// 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
}