precompiles

type CrossChainZKVerifier ¶

type CrossChainZKVerifier struct {
	ZChainID ids.ID
}

CrossChainZKVerifier routes ZK verification from any EVM chain to Z-Chain.

Input format:

verifier_type (1 byte)
proof_data    (remaining bytes — forwarded to Z-Chain verifier)

The routing works via Warp messaging:

1. Caller on C-Chain (or any subnet EVM) invokes this precompile
2. Precompile constructs a Warp message addressed to Z-Chain
3. Z-Chain receives the message and invokes the appropriate verifier
4. Result is returned via Warp response

Gas: base 100K (includes Warp relay overhead).

func (v *CrossChainZKVerifier) RequiredGas(input []byte) uint64

func (v *CrossChainZKVerifier) Run(input []byte) ([]byte, error)

type Groth16Verifier ¶

type Groth16Verifier struct{}

Groth16Verifier verifies Groth16 proofs on Z-Chain using bn254 pairings.

Input format (all points uncompressed):

vk_len     (4 bytes, big-endian)
vk         (vk_len bytes): Alpha(64) | Beta(128) | Gamma(128) | Delta(128) | numK(4) | K[](64*numK)
proof      (256 bytes):    Ar(64) | Bs(128) | Krs(64)
num_inputs (4 bytes, big-endian)
inputs     (32 * num_inputs bytes): field elements

Output: 0x01 if valid, 0x00 if invalid.

func (v *Groth16Verifier) RequiredGas(input []byte) uint64

func (v *Groth16Verifier) Run(input []byte) ([]byte, error)

type Halo2Verifier ¶

type Halo2Verifier struct{}

Halo2Verifier will verify Halo2 proofs with IPA commitments. Currently returns an error indicating the verifier is not yet available.

func (v *Halo2Verifier) RequiredGas(input []byte) uint64

func (v *Halo2Verifier) Run(input []byte) ([]byte, error)

type MapRegistry ¶

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

MapRegistry is a simple map-based precompile registry for testing.

func NewMapRegistry() *MapRegistry

func (r *MapRegistry) Get(addr byte) (PrecompiledContract, error)

func (r *MapRegistry) Register(addr byte, contract PrecompiledContract)

type NovaVerifier ¶

type NovaVerifier struct{}

NovaVerifier will verify Nova IVC proofs. Currently returns an error indicating the verifier is not yet available.

func (v *NovaVerifier) RequiredGas(input []byte) uint64

func (v *NovaVerifier) Run(input []byte) ([]byte, error)

type PLONKVerifier ¶

type PLONKVerifier struct{}

PLONKVerifier verifies PLONK proofs using KZG polynomial commitments on bn254.

Input format:

vk_len     (4 bytes)
vk         (vk_len bytes)
proof_len  (4 bytes)
proof      (proof_len bytes)
num_inputs (4 bytes)
inputs     (32 * num_inputs bytes)

Output: 0x01 if valid, 0x00 if invalid.

func (v *PLONKVerifier) RequiredGas(input []byte) uint64

func (v *PLONKVerifier) Run(input []byte) ([]byte, error)

type PrecompileRegistry ¶

type PrecompileRegistry interface {
	Register(addr byte, contract PrecompiledContract)
}

PrecompileRegistry allows registering precompiled contracts at fixed addresses.

type PrecompiledContract ¶

type PrecompiledContract interface {
	RequiredGas(input []byte) uint64
	Run(input []byte) ([]byte, error)
}

PrecompiledContract is the interface that EVM precompiles must satisfy.

type STARKVerifier ¶

type STARKVerifier struct{}

STARKVerifier will verify STARK proofs. Currently returns an error indicating the verifier is not yet available.

func (v *STARKVerifier) RequiredGas(input []byte) uint64

func (v *STARKVerifier) Run(input []byte) ([]byte, error)