sdk

package

Go to main page

Versions in this module

v0

v0.3.18

Dec 20, 2024

v0.3.17

Dec 16, 2024

Changes in this version

type BrevisApp

+ func NewBrevisAppWithDigestsSetOnlyFromRemote(gatewayUrlOverride ...string) *BrevisApp

v0.3.16

Dec 10, 2024

Changes in this version

type BrevisApp

+ func NewBrevisAppWithDigestsSetOnly(...) *BrevisApp

type GatewayClient

+ func (c *GatewayClient) GetCircuitDummyInput(req *gwproto.CircuitDummyInputRequest) (resp *gwproto.CircuitDummyInputResponse, err error)

v0.3.15

Nov 25, 2024

v0.3.14

Nov 21, 2024

Changes in this version

+ func GetHeaderAndTxHashes(ec *ethclient.Client, ctx context.Context, blkNum *big.Int) (*types.Header, []common.Hash, error)

+ func GetReceiptProof(bk *types.Block, receipts types.Receipts, index int) (nodes [][]byte, keyIndex, leafRlpPrefix []byte, err error)

v0.3.13

Nov 20, 2024

Changes in this version

type Receipt

+ func ConvertReceiptDataToReceipt(r *ReceiptData) Receipt

type StorageSlot

+ func ConvertStorageDataToStorage(data *StorageData) StorageSlot

type Transaction

+ func ConvertTxDataToTransaction(data *TransactionData) Transaction

v0.3.12

Nov 19, 2024

v0.3.11

Nov 16, 2024

v0.3.10

Nov 13, 2024

Changes in this version

+ func CmpHint(_ *big.Int, inputs []*big.Int, results []*big.Int) error

type BrevisApp

+ func (q *BrevisApp) ResetInput()

type Bytes32

+ func ConstFromBigEndianBytes(data []byte) Bytes32

v0.3.9

Nov 6, 2024

v0.3.8

Nov 4, 2024

Changes in this version

+ var P2Bn128WrapCircuitDigestHashForOnly2Leaf = utils.Hex2BigInt("0x1a608b7771b23c7972539bad7f395d7ad5c4a5e5be9dc891960179c1cacd8c78")

+ func GetPlonky2CircuitDigestFromRootNodeSelf(receiptCount, storageCount, transactionCount int) (*pgoldilocks.HashOut256, bool, bool, error)

v0.3.7

Nov 1, 2024

Changes in this version

type BrevisApp

+ func (q *BrevisApp) AddMockReceipt(data ReceiptData, index ...int)

+ func (q *BrevisApp) AddMockStorage(data StorageData, index ...int)

+ func (q *BrevisApp) AddMockTransaction(data TransactionData, index ...int)

+ func (q *BrevisApp) BuildReceipt(t ReceiptData) (Receipt, error)

+ func (q *BrevisApp) GenerateProtoQuery(vk plonk.VerifyingKey, witness witness.Witness, proof []byte, ...) (*gwproto.Query, error)

+ func (q *BrevisApp) SendBatchQuery(queries []*gwproto.Query, batchAPIKey string, queryOption *gwproto.QueryOption) (queryKeys []*gwproto.QueryKey, fee string, err error)

+ type DataPersistence struct

+ Receipts map[string]*ReceiptData

+ Storages map[string]*StorageData

+ Txs map[string]*TransactionData

+ type LogFieldPos struct

+ FieldIndex uint

+ IsTopic bool

+ LogPos uint

+ type ReceiptPos struct

+ Fields []LogFieldPos

+ TxHash common.Hash

+ type StoragePos struct

+ Address common.Address

+ BlockNum *big.Int

+ Slot common.Hash

+ type TransactionPos struct

+ Hash common.Hash

v0.3.6

Oct 29, 2024

v0.3.5

Oct 28, 2024

v0.3.4

Oct 28, 2024

v0.3.3

Oct 25, 2024

Changes in this version

+ var P2AggRecursionMiddleFormMiddleLeafCircuitDigestHash = &pgoldilocks.HashOut256

+ var P2Bn128WrapCircuitDigestHashForOnlyFromLeafRecursion = utils.Hex2BigInt("0x08e1f454d096c46ebf2e1f40ff4858ce8188f86cc9623242ea605b774aee12aa")

+ func DataPointsNextPowerOf2(value int) int

type Plonky2DigestNode

+ IsRecursionOfLeaf bool

+ IsRecursionRecursionOfLeaf bool

v0.3.2

Oct 24, 2024

Changes in this version

type CircuitAPI

+ func (api *CircuitAPI) Keccak256(inputs []Bytes32, inputBitSize []int32) Bytes32

v0.3.1

Oct 22, 2024

Changes in this version

type BrevisApp

+ func (q *BrevisApp) BuildStorageSlot(s StorageData) (StorageSlot, error)

+ func (q *BrevisApp) BuildTx(t TransactionData) (Transaction, error)

type DataInput

+ NumMaxDataPoints int

+ type ProofWriter struct

+ Keys [][]byte

+ Values [][]byte

+ func (p *ProofWriter) Delete(key []byte) error

+ func (p *ProofWriter) Put(key []byte, value []byte) error

v0.3.0

Oct 22, 2024

Changes in this version

+ const Bytes32Type

+ const Int248Type

+ const NumMaxDataPoints

+ const NumMaxLogFields

+ const Uint248Type

+ const Uint32Type

+ const Uint521Type

+ const Uint64Type

+ var AggAllVkHash = "0x078ab850e8148fc412016972abf837fddbc8c7f87d049e337fcdfdc1a47caca2"

+ var MaxBytes32 = ConstUint521(...)

+ var MaxUint248 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 248), big.NewInt(1))

+ var MaxUint32 = new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 32), big.NewInt(1))

+ var MiddleNodeVkHash = utils.Hex2BigInt(MiddleNodeVkHashHex)

+ var MiddleNodeVkHashHex = "0x15dc69eafcfd4546b82fecf468fd5878e2f7cb2270abee4e15abb638c77bbe52"

+ var P2AggRecursionLeafCircuitDigestHash = &pgoldilocks.HashOut256

+ var P2AggRecursionNoLeafCircuitDigestHash = &pgoldilocks.HashOut256

+ var P2Bn128WrapCircuitDigestHash = utils.Hex2BigInt("0x08e1f454d096c46ebf2e1f40ff4858ce8188f86cc9623242ea605b774aee12aa")

+ var ReceiptCircuitDigestHash = &pgoldilocks.HashOut256

+ var ReceiptD = new(big.Int).SetUint64(uint64(1))

+ var ReceiptNode = Hash2HashDigestNode

+ var ReceiptPlonky2Node = Plonky2DigestNode

+ var ReceiptVkHash = utils.Hex2BigInt(ReceiptVkHashHex)

+ var ReceiptVkHashHex = "0x2d7428934e98c37e081f124a9a4e4eba6b41147a8ceba440ca82ccaec2a0af52"

+ var StorageCircuitDigestHash = &pgoldilocks.HashOut256

+ var StorageD = new(big.Int).SetUint64(uint64(2))

+ var StorageNode = Hash2HashDigestNode

+ var StoragePlonky2Node = Plonky2DigestNode

+ var StorageVkHash = utils.Hex2BigInt(StorageVkHashHex)

+ var StorageVkHashHex = "0x19efa435ccc1bf59b4e97281e7dcc612e2eda104987cfa9f6457435a90156297"

+ var TransactionD = new(big.Int).SetUint64(uint64(3))

+ var TransactionNode = Hash2HashDigestNode

+ var TransactionPlonky2Node = Plonky2DigestNode

+ var TransactionVkHash = utils.Hex2BigInt(TransactionVkHashHex)

+ var TransactionVkHashHex = "0x051756e504e16aa2635181222db1d8a9310930599ce44c000414b02101431c89"

+ var TxCircuitDigestHash = &pgoldilocks.HashOut256

+ func AssertEach[T CircuitVariable](ds *DataStream[T], assertFunc AssertFunc[T])

+ func AssertSorted[T CircuitVariable](ds *DataStream[T], sortFunc SortFunc[T])

+ func CalBrevisCircuitDigest(receiptCount, storageCount, transactionCount int, appVk plonk.VerifyingKey) (*big.Int, error)

+ func CalMerkleRoot(gapi frontend.API, datas []frontend.Variable) (frontend.Variable, error)

+ func CalOneHash2HashNodeDigest(left, right Hash2HashDigestNode) (*big.Int, error)

+ func CalOnePlonky2NodeDigest(left, right Plonky2DigestNode) (*pgoldilocks.HashOut256, error)

+ func CalPoseidonBn254MerkleTree(leafs []*big.Int) (*big.Int, error)

+ func CalTogglesHashRoot(toggles []frontend.Variable) (*big.Int, error)

+ func CheckNumberPowerOfTwo(n int) bool

+ func Cmp(api frontend.API, i1, i2 frontend.Variable, nbBits int) frontend.Variable

+ func Compile(app AppCircuit, compileOutDir, srsDir string, ...) (constraint.ConstraintSystem, plonk.ProvingKey, plonk.VerifyingKey, []byte, ...)

+ func CompileOnly(app AppCircuit) (constraint.ConstraintSystem, error)

+ func ComputeVkHash(vk plonk.VerifyingKey) (common.Hash, error)

+ func DoHash(hasher *utils.PoseidonBn254Hasher, packed []*big.Int) (*big.Int, error)

+ func DoHashWithPoseidonBn254(packed []*big.Int) (*big.Int, error)

+ func GetAndCheckLeafCount(receiptCount, storageCount, transactionCount int) (receiptLeafCount int, storageLeafCount int, transactionLeafCount int, ...)

+ func GetHash2HashCircuitDigest(receiptCount, storageCount, transactionCount int) (*big.Int, error)

+ func GetHints() []solver.Hint

+ func GetPlonky2CircuitDigestFromWrapBn128(receiptCount, storageCount, transactionCount int) (*pgoldilocks.HashOut256, error)

+ func GetUnderlying[T CircuitVariable](ds *DataStream[T], index int) T

+ func GroupValuesHint(_ *big.Int, inputs []*big.Int, outputs []*big.Int) error

+ func MaxGeneric[T CircuitVariable](ds *DataStream[T], initialMax T, gt SortFunc[T]) T

+ func MinGeneric[T CircuitVariable](ds *DataStream[T], initialMin T, lt SortFunc[T]) T

+ func NewFullWitness(assign AppCircuit, in CircuitInput) (w, wpub witness.Witness, err error)

+ func PackBitsToInt(bits []uint, bitSize int) []*big.Int

+ func Prove(ccs constraint.ConstraintSystem, pk plonk.ProvingKey, w witness.Witness) (plonk.Proof, error)

+ func QuoRemBigHint(_ *big.Int, in []*big.Int, out []*big.Int) error

+ func QuoRemHint(_ *big.Int, in, out []*big.Int) error

+ func ReadCircuitFrom(path string) (constraint.ConstraintSystem, error)

+ func ReadPkFrom(path string) (plonk.ProvingKey, error)

+ func ReadProofFrom(path string) (plonk.Proof, error)

+ func ReadSetupFrom(compileOutDir string, maxReceipt, maxStorage, numMaxDataPoints int) (constraint.ConstraintSystem, plonk.ProvingKey, plonk.VerifyingKey, []byte, ...)

+ func ReadVkFrom(path string, maxReceipt, maxStorage, numMaxDataPoints int) (plonk.VerifyingKey, []byte, error)

+ func Reduce[T, R CircuitVariable](ds *DataStream[T], initial R, reducer ReduceFunc[T, R]) R

+ func Select[T CircuitVariable](api *CircuitAPI, s Uint248, a, b T) T

+ func Setup(ccs constraint.ConstraintSystem, cacheDir string, ...) (pk plonk.ProvingKey, vk plonk.VerifyingKey, vkHash []byte, err error)

+ func SortHint(_ *big.Int, in, out []*big.Int) error

+ func SqrtHint(_ *big.Int, in, out []*big.Int) error

+ func Verify(vk plonk.VerifyingKey, publicWitness witness.Witness, proof plonk.Proof) error

+ func WriteTo(w io.WriterTo, path string) error

+ type AppCircuit interface

+ Allocate func() (maxReceipts, maxStorage, maxTransactions int)

+ Define func(api *CircuitAPI, in DataInput) error

+ type AssertFunc func(current T) Uint248

+ type BrevisApp struct

+ func NewBrevisApp(srcChainId uint64, gatewayUrlOverride ...string) (*BrevisApp, error)

+ func (q *BrevisApp) AddReceipt(data ReceiptData, index ...int)

+ func (q *BrevisApp) AddStorage(data StorageData, index ...int)

+ func (q *BrevisApp) AddTransaction(data TransactionData, index ...int)

+ func (q *BrevisApp) BuildCircuitInput(app AppCircuit) (CircuitInput, error)

+ func (q *BrevisApp) PrepareRequest(vk plonk.VerifyingKey, witness witness.Witness, srcChainId, dstChainId uint64, ...) (calldata []byte, requestId common.Hash, nonce uint64, feeValue *big.Int, ...)

+ func (q *BrevisApp) SubmitProof(proof plonk.Proof, options ...SubmitProofOption) error

+ func (q *BrevisApp) SubmitProofWithQueryId(queryId string, nonce uint64, dstChainId uint64, proof []byte) error

+ func (q *BrevisApp) WaitFinalProofSubmitted(ctx context.Context) (tx common.Hash, err error)

+ type Bytes32 struct

+ Val [2]frontend.Variable

+ func ConstBytes32(data []byte) Bytes32

+ func (v Bytes32) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Bytes32) NumVars() uint32

+ func (v Bytes32) String() string

+ func (v Bytes32) Values() []frontend.Variable

+ type Bytes32API struct

+ func (api *Bytes32API) AssertIsDifferent(a, b Bytes32)

+ func (api *Bytes32API) AssertIsEqual(a, b Bytes32)

+ func (api *Bytes32API) FromBinary(vs ...Uint248) Bytes32

+ func (api *Bytes32API) FromFV(v frontend.Variable) Bytes32

+ func (api *Bytes32API) IsEqual(a, b Bytes32) Uint248

+ func (api *Bytes32API) IsZero(a Bytes32) Uint248

+ func (api *Bytes32API) Select(s Uint248, a, b Bytes32) Bytes32

+ func (api *Bytes32API) ToBinary(v Bytes32) List[Uint248]

+ type CircuitAPI struct

+ Bytes32 *Bytes32API

+ Int248 *Int248API

+ Uint248 *Uint248API

+ Uint32 *Uint32API

+ Uint521 *Uint521API

+ Uint64 *Uint64API

+ func NewCircuitAPI(gapi frontend.API) *CircuitAPI

+ func (api *CircuitAPI) AssertInputsAreUnique()

+ func (api *CircuitAPI) NewHint(f solver.Hint, nbOutputs int, inputs ...frontend.Variable) ([]frontend.Variable, error)

+ func (api *CircuitAPI) NewMiMC() (mimc.MiMC, error)

+ func (api *CircuitAPI) NewPoseidon() (poseidon.PoseidonCircuit, error)

+ func (api *CircuitAPI) OutputAddress(v Uint248)

+ func (api *CircuitAPI) OutputBool(v Uint248)

+ func (api *CircuitAPI) OutputBytes32(v Bytes32)

+ func (api *CircuitAPI) OutputUint(bitSize int, v Uint248)

+ func (api *CircuitAPI) OutputUint32(bitSize int, v Uint32)

+ func (api *CircuitAPI) OutputUint64(bitSize int, v Uint64)

+ func (api *CircuitAPI) SlotOfArrayElement(arrSlot Bytes32, elementSize int, index, offset Uint248) Bytes32

+ func (api *CircuitAPI) SlotOfStructFieldInMapping(slot, offset int, valueSlot Bytes32, nestedMappingSlots ...Bytes32) Bytes32

+ func (api *CircuitAPI) ToBytes32(i interface{}) Bytes32

+ func (api *CircuitAPI) ToInt248(i interface{}) Int248

+ func (api *CircuitAPI) ToUint248(i interface{}) Uint248

+ func (api *CircuitAPI) ToUint521(i interface{}) Uint521

+ type CircuitInput struct

+ DummyReceiptInputCommitment frontend.Variable

+ DummyStorageInputCommitment frontend.Variable

+ DummyTransactionInputCommitment frontend.Variable

+ InputCommitments []frontend.Variable

+ InputCommitmentsRoot frontend.Variable

+ OutputCommitment OutputCommitment

+ TogglesCommitment frontend.Variable

+ func (in CircuitInput) Clone() CircuitInput

+ func (in CircuitInput) GetAbiPackedOutput() []byte

+ type CircuitVariable interface

+ FromValues func(vs ...frontend.Variable) CircuitVariable

+ NumVars func() uint32

+ String func() string

+ Values func() []frontend.Variable

+ type DataInput struct

+ Receipts DataPoints[Receipt]

+ StorageSlots DataPoints[StorageSlot]

+ Transactions DataPoints[Transaction]

+ func (d DataInput) Toggles() []frontend.Variable

+ type DataPoints struct

+ Raw []T

+ Toggles []frontend.Variable

+ func NewDataPoints[T any](maxCount int, newEmpty func() T) DataPoints[T]

+ func (dp DataPoints[T]) Clone() DataPoints[T]

+ type DataStream struct

+ func Filter[T CircuitVariable](ds *DataStream[T], predicate FilterFunc[T]) *DataStream[T]

+ func GroupBy[T, R CircuitVariable](ds *DataStream[T], reducer ReduceFunc[T, R], reducerInit R, ...) (*DataStream[R], error)

+ func Map[T, R CircuitVariable](ds *DataStream[T], mapFunc MapFunc[T, R]) *DataStream[R]

+ func NewDataStream[T CircuitVariable](api *CircuitAPI, in DataPoints[T]) *DataStream[T]

+ func RangeUnderlying[T CircuitVariable](ds *DataStream[T], start, end int) *DataStream[T]

+ func WindowUnderlying[T CircuitVariable](ds *DataStream[T], size int, step ...int) *DataStream[List[T]]

+ func ZipMap2[T0, T1, R CircuitVariable](a *DataStream[T0], b List[T1], zipFunc ZipMap2Func[T0, T1, R]) *DataStream[R]

+ func ZipMap3[T0, T1, T2, R CircuitVariable](a *DataStream[T0], b List[T1], c List[T2], zipFunc ZipMap3Func[T0, T1, T2, R]) *DataStream[R]

+ func (ds *DataStream[T]) Show()

+ type FilterFunc func(current T) Uint248

+ type GatewayClient struct

+ func NewGatewayClient(url ...string) (*GatewayClient, error)

+ func (c *GatewayClient) GetQueryStatus(req *gwproto.GetQueryStatusRequest) (resp *gwproto.GetQueryStatusResponse, err error)

+ func (c *GatewayClient) PrepareQuery(req *gwproto.PrepareQueryRequest) (resp *gwproto.PrepareQueryResponse, err error)

+ func (c *GatewayClient) SendBatchQueries(req *gwproto.SendBatchQueriesRequest) (resp *gwproto.SendBatchQueriesResponse, err error)

+ func (c *GatewayClient) SubmitProof(req *gwproto.SubmitAppCircuitProofRequest) (resp *gwproto.SubmitAppCircuitProofResponse, err error)

+ type GetValueFunc func(current T) Uint248

+ type Hash2HashDigestNode struct

+ CircuitDigest *big.Int

+ VkHash *big.Int

+ type HostCircuit struct

+ Guest AppCircuit

+ Input CircuitInput

+ func DefaultHostCircuit(app AppCircuit) *HostCircuit

+ func NewHostCircuit(in CircuitInput, guest AppCircuit) *HostCircuit

+ func (c *HostCircuit) Define(gapi frontend.API) error

+ type Int248 struct

+ SignBit frontend.Variable

+ Val frontend.Variable

+ func ConstInt248(v *big.Int) Int248

+ func (v Int248) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Int248) NumVars() uint32

+ func (v Int248) String() string

+ func (v Int248) Values() []frontend.Variable

+ type Int248API struct

+ func (api *Int248API) ABS(a Int248) Uint248

+ func (api *Int248API) AssertIsDifferent(a, b Int248)

+ func (api *Int248API) AssertIsEqual(a, b Int248)

+ func (api *Int248API) FromBinary(vs ...Uint248) Int248

+ func (api *Int248API) IsEqual(a, b Int248) Uint248

+ func (api *Int248API) IsGreaterThan(a, b Int248) Uint248

+ func (api *Int248API) IsLessThan(a, b Int248) Uint248

+ func (api *Int248API) IsZero(a Int248) Uint248

+ func (api *Int248API) Select(s Uint248, a, b Int248) Int248

+ func (api *Int248API) ToBinary(v Int248) List[Uint248]

+ type List []T

+ func (l List[T]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (l List[T]) NumVars() uint32

+ func (l List[T]) String() string

+ func (l List[T]) Values() []frontend.Variable

+ type LogField struct

+ Contract Uint248

+ EventID Uint248

+ Index Uint248

+ IsTopic Uint248

+ LogPos Uint32

+ Value Bytes32

+ func BuildLogFields(fs [NumMaxLogFields]LogFieldData) (fields [NumMaxLogFields]LogField)

+ func (f LogField) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (f LogField) NumVars() uint32

+ func (f LogField) String() string

+ func (f LogField) Values() []frontend.Variable

+ type LogFieldData struct

+ Contract common.Address

+ EventID common.Hash

+ FieldIndex uint

+ IsTopic bool

+ LogPos uint

+ Value common.Hash

+ type MapFunc func(current T) R

+ type OutputCommitment [2]frontend.Variable

+ func (c OutputCommitment) Hash() common.Hash

+ type Plonky2DigestNode struct

+ CurCircuitDigest *pgoldilocks.HashOut256

+ IsLeafNode bool

+ PubCircuitDigest *pgoldilocks.HashOut256

+ func GetPlonky2CircuitDigest(receiptCount, storageCount, transactionCount int) (*Plonky2DigestNode, error)

+ type Receipt struct

+ BlockBaseFee Uint248

+ BlockNum Uint32

+ Fields [NumMaxLogFields]LogField

+ MptKeyPath Uint32

+ func DefaultReceipt() Receipt

+ func (r Receipt) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (r Receipt) GoPack() []*big.Int

+ func (r Receipt) NumVars() uint32

+ func (r Receipt) Pack(api frontend.API) []frontend.Variable

+ func (r Receipt) String() string

+ func (r Receipt) Values() []frontend.Variable

+ type ReceiptData struct

+ BlockBaseFee *big.Int

+ BlockNum *big.Int

+ Fields [NumMaxLogFields]LogFieldData

+ MptKeyPath *big.Int

+ TxHash common.Hash

+ type ReduceFunc func(accumulator R, current T) (newAccumulator R)

+ type SortFunc func(a, b T) Uint248

+ type StorageData struct

+ Address common.Address

+ BlockBaseFee *big.Int

+ BlockNum *big.Int

+ Slot common.Hash

+ Value common.Hash

+ type StorageSlot struct

+ BlockBaseFee Uint248

+ BlockNum Uint32

+ Contract Uint248

+ Slot Bytes32

+ Value Bytes32

+ func BuildStorageSlot(s StorageData) StorageSlot

+ func (s StorageSlot) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (s StorageSlot) GoPack() []*big.Int

+ func (s StorageSlot) NumVars() uint32

+ func (s StorageSlot) Pack(api frontend.API) []frontend.Variable

+ func (s StorageSlot) String() string

+ func (s StorageSlot) Values() []frontend.Variable

+ type SubmitProofOption func(option submitProofOptions)

+ func WithContext(ctx context.Context) SubmitProofOption

+ func WithFinalProofSubmittedCallback(onSubmitted func(txHash common.Hash), onError func(err error)) SubmitProofOption

+ type Transaction struct

+ BlockBaseFee Uint248

+ BlockNum Uint32

+ LeafHash Bytes32

+ MptKeyPath Uint32

+ func BuildTx(t TransactionData) Transaction

+ func (t Transaction) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Transaction) GoPack() []*big.Int

+ func (t Transaction) NumVars() uint32

+ func (t Transaction) Pack(api frontend.API) []frontend.Variable

+ func (t Transaction) String() string

+ func (t Transaction) Values() []frontend.Variable

+ type TransactionData struct

+ BlockBaseFee *big.Int

+ BlockNum *big.Int

+ ChainId *big.Int

+ From common.Address

+ GasFeeCap *big.Int

+ GasLimit uint64

+ GasTipCapOrGasPrice *big.Int

+ Hash common.Hash

+ LeafHash common.Hash

+ MptKeyPath *big.Int

+ Nonce uint64

+ To common.Address

+ Value *big.Int

+ type Tuple2 struct

+ F0 F0

+ F1 F1

+ func (t Tuple2[F0, F1]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple2[F0, F1]) NumVars() uint32

+ func (t Tuple2[F0, F1]) String() string

+ func (t Tuple2[F0, F1]) Values() []frontend.Variable

+ type Tuple3 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ func (t Tuple3[F0, F1, F2]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple3[F0, F1, F2]) NumVars() uint32

+ func (t Tuple3[F0, F1, F2]) String() string

+ func (t Tuple3[F0, F1, F2]) Values() []frontend.Variable

+ type Tuple4 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ F3 F3

+ func (t Tuple4[F0, F1, F2, F3]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple4[F0, F1, F2, F3]) NumVars() uint32

+ func (t Tuple4[F0, F1, F2, F3]) String() string

+ func (t Tuple4[F0, F1, F2, F3]) Values() []frontend.Variable

+ type Tuple5 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ F3 F3

+ F4 F4

+ func (t Tuple5[F0, F1, F2, F3, F4]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple5[F0, F1, F2, F3, F4]) NumVars() uint32

+ func (t Tuple5[F0, F1, F2, F3, F4]) String() string

+ func (t Tuple5[F0, F1, F2, F3, F4]) Values() []frontend.Variable

+ type Tuple6 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ F3 F3

+ F4 F4

+ F5 F5

+ func (t Tuple6[F0, F1, F2, F3, F4, F5]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple6[F0, F1, F2, F3, F4, F5]) NumVars() uint32

+ func (t Tuple6[F0, F1, F2, F3, F4, F5]) String() string

+ func (t Tuple6[F0, F1, F2, F3, F4, F5]) Values() []frontend.Variable

+ type Tuple7 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ F3 F3

+ F4 F4

+ F5 F5

+ F6 F6

+ func (t Tuple7[F0, F1, F2, F3, F4, F5, F6]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple7[F0, F1, F2, F3, F4, F5, F6]) NumVars() uint32

+ func (t Tuple7[F0, F1, F2, F3, F4, F5, F6]) String() string

+ func (t Tuple7[F0, F1, F2, F3, F4, F5, F6]) Values() []frontend.Variable

+ type Tuple8 struct

+ F0 F0

+ F1 F1

+ F2 F2

+ F3 F3

+ F4 F4

+ F5 F5

+ F6 F6

+ F7 F7

+ func (t Tuple8[F0, F1, F2, F3, F4, F5, F6, F7]) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (t Tuple8[F0, F1, F2, F3, F4, F5, F6, F7]) NumVars() uint32

+ func (t Tuple8[F0, F1, F2, F3, F4, F5, F6, F7]) String() string

+ func (t Tuple8[F0, F1, F2, F3, F4, F5, F6, F7]) Values() []frontend.Variable

+ type Uint248 struct

+ Val frontend.Variable

+ func ConstUint248(i interface{}) Uint248

+ func Count[T CircuitVariable](ds *DataStream[T]) Uint248

+ func IsSorted[T CircuitVariable](ds *DataStream[T], sortFunc SortFunc[T]) Uint248

+ func Max(ds *DataStream[Uint248]) Uint248

+ func Mean(ds *DataStream[Uint248]) Uint248

+ func Min(ds *DataStream[Uint248]) Uint248

+ func ParseEventID(b []byte) Uint248

+ func Sum(ds *DataStream[Uint248]) Uint248

+ func (v Uint248) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Uint248) NumVars() uint32

+ func (v Uint248) String() string

+ func (v Uint248) Values() []frontend.Variable

+ type Uint248API struct

+ func (api *Uint248API) Add(a, b Uint248, other ...Uint248) Uint248

+ func (api *Uint248API) And(a, b Uint248, other ...Uint248) Uint248

+ func (api *Uint248API) AssertIsDifferent(a, b Uint248)

+ func (api *Uint248API) AssertIsEqual(a, b Uint248)

+ func (api *Uint248API) AssertIsLessOrEqual(a, b Uint248)

+ func (api *Uint248API) Div(a, b Uint248) (quotient, remainder Uint248)

+ func (api *Uint248API) FromBinary(vs ...Uint248) Uint248

+ func (api *Uint248API) IsEqual(a, b Uint248) Uint248

+ func (api *Uint248API) IsGreaterThan(a, b Uint248) Uint248

+ func (api *Uint248API) IsLessThan(a, b Uint248) Uint248

+ func (api *Uint248API) IsZero(a Uint248) Uint248

+ func (api *Uint248API) Mul(a, b Uint248) Uint248

+ func (api *Uint248API) Not(a Uint248) Uint248

+ func (api *Uint248API) Or(a, b Uint248, other ...Uint248) Uint248

+ func (api *Uint248API) Select(s Uint248, a, b Uint248) Uint248

+ func (api *Uint248API) Sqrt(a Uint248) Uint248

+ func (api *Uint248API) Sub(a, b Uint248) Uint248

+ func (api *Uint248API) ToBinary(v Uint248, n int) List[Uint248]

+ type Uint32 struct

+ Val frontend.Variable

+ func ConstUint32(i interface{}) Uint32

+ func (v Uint32) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Uint32) NumVars() uint32

+ func (v Uint32) String() string

+ func (v Uint32) Values() []frontend.Variable

+ type Uint32API struct

+ func (api *Uint32API) Add(a, b Uint32, other ...Uint32) Uint32

+ func (api *Uint32API) And(a, b Uint32, other ...Uint32) Uint32

+ func (api *Uint32API) AssertIsDifferent(a, b Uint32)

+ func (api *Uint32API) AssertIsEqual(a, b Uint32)

+ func (api *Uint32API) Div(a, b Uint32) (quotient, remainder Uint32)

+ func (api *Uint32API) FromBinary(vs ...Uint32) Uint32

+ func (api *Uint32API) IsEqual(a, b Uint32) Uint32

+ func (api *Uint32API) IsGreaterThan(a, b Uint32) Uint32

+ func (api *Uint32API) IsLessThan(a, b Uint32) Uint32

+ func (api *Uint32API) IsZero(a Uint32) Uint32

+ func (api *Uint32API) Mul(a, b Uint32) Uint32

+ func (api *Uint32API) Not(a Uint32) Uint32

+ func (api *Uint32API) Or(a, b Uint32, other ...Uint32) Uint32

+ func (api *Uint32API) Select(s Uint32, a, b Uint32) Uint32

+ func (api *Uint32API) Sqrt(a Uint32) Uint32

+ func (api *Uint32API) Sub(a, b Uint32) Uint32

+ func (api *Uint32API) ToBinary(v Uint32, n int) List[Uint32]

+ type Uint521 struct

+ func ConstUint521(i interface{}) Uint521

+ func (v Uint521) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Uint521) NumVars() uint32

+ func (v Uint521) String() string

+ func (v Uint521) Values() []frontend.Variable

+ type Uint521API struct

+ func (api *Uint521API) Add(a, b Uint521) Uint521

+ func (api *Uint521API) AssertIsEqual(a, b Uint521)

+ func (api *Uint521API) AssertIsLessOrEqual(a, b Uint521)

+ func (api *Uint521API) Div(a, b Uint521) (quotient, remainder Uint521)

+ func (api *Uint521API) FromBinary(vs ...Uint248) Uint521

+ func (api *Uint521API) IsEqual(a, b Uint521) Uint248

+ func (api *Uint521API) Mul(a, b Uint521) Uint521

+ func (api *Uint521API) Select(s Uint248, a, b Uint521) Uint521

+ func (api *Uint521API) Sub(a, b Uint521) Uint521

+ func (api *Uint521API) ToBinary(v Uint521, n int) List[Uint248]

+ type Uint521Field struct

+ func (f Uint521Field) BitsPerLimb() uint

+ func (f Uint521Field) IsPrime() bool

+ func (f Uint521Field) Modulus() *big.Int

+ func (f Uint521Field) NbLimbs() uint

+ type Uint64 struct

+ Val frontend.Variable

+ func ConstUint64(i interface{}) Uint64

+ func (v Uint64) FromValues(vs ...frontend.Variable) CircuitVariable

+ func (v Uint64) NumVars() uint32

+ func (v Uint64) String() string

+ func (v Uint64) Values() []frontend.Variable

+ type Uint64API struct

+ func (api *Uint64API) Add(a, b Uint64, other ...Uint64) Uint64

+ func (api *Uint64API) And(a, b Uint64, other ...Uint64) Uint64

+ func (api *Uint64API) AssertIsDifferent(a, b Uint64)

+ func (api *Uint64API) AssertIsEqual(a, b Uint64)

+ func (api *Uint64API) Div(a, b Uint64) (quotient, remainder Uint64)

+ func (api *Uint64API) FromBinary(vs ...Uint64) Uint64

+ func (api *Uint64API) IsEqual(a, b Uint64) Uint64

+ func (api *Uint64API) IsGreaterThan(a, b Uint64) Uint64

+ func (api *Uint64API) IsLessThan(a, b Uint64) Uint64

+ func (api *Uint64API) IsZero(a Uint64) Uint64

+ func (api *Uint64API) Mul(a, b Uint64) Uint64

+ func (api *Uint64API) Not(a Uint64) Uint64

+ func (api *Uint64API) Or(a, b Uint64, other ...Uint64) Uint64

+ func (api *Uint64API) Select(s Uint64, a, b Uint64) Uint64

+ func (api *Uint64API) Sqrt(a Uint64) Uint64

+ func (api *Uint64API) Sub(a, b Uint64) Uint64

+ func (api *Uint64API) ToBinary(v Uint64, n int) List[Uint64]

+ type ZipMap2Func func(a T0, b T1) R

+ type ZipMap3Func func(a T0, b T1, c T2) R

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL