rollup

Documentation

Index

• Variables
• func Deserialize(res *Account, data []byte) error
• type Account
  • func (ac *Account) Reset()
  • func (ac *Account) Serialize() []byte
• type AccountCircuit
• type Operator
  • func NewOperator(nbAccounts int, h hash.Hash) Operator
• type Queue
  • func NewQueue(batchSize int) Queue
  • func (q *Queue) Pop() Transfer
  • func (q *Queue) Push(t Transfer)
• type Transfer
  • func NewTransfer(amount uint64, from, to eddsa.PublicKey, nonce uint64) Transfer
  • func (t *Transfer) Sign(priv eddsa.PrivateKey, h hash.Hash) (eddsa.Signature, error)
  • func (t *Transfer) Verify(h hash.Hash) (bool, error)
• type TransferCircuit

Variables

var (
	// ErrSizeByteSlice memory checking
	ErrSizeByteSlice = errors.New("Byte slice size is inconsistant with Account size")

	// ErrNonExistingAccount account not in the database
	ErrNonExistingAccount = errors.New("The account is not in the rollup database")

	// ErrNonConsistantAccount account not in the database
	ErrNonConsistantAccount = errors.New("The account provided exists but is inconsistant with what's in the database")

	// ErrWrongSignature wrong signature
	ErrWrongSignature = errors.New("Invalid signature")

	// ErrAmountTooHigh the amount is bigger than the balance
	ErrAmountTooHigh = errors.New("Amount is bigger than balance")

	// ErrNonce inconsistant nonce between transfer and account
	ErrNonce = errors.New("Incorrect nonce")
)

var BatchSize = 10

BatchSize size of a batch of transactions to put in a snark

var (
	// SizeAccount byte size of a serialized account (5*32bytes)
	// index || nonce || balance || pubkeyX || pubkeyY, each chunk is 32 bytes
	SizeAccount = 160
)

Functions

func Deserialize

func Deserialize(res *Account, data []byte) error

Deserialize deserializes a stream of byte in an account

Types

type Account

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

Account describes a rollup account

func (*Account) Reset

func (ac *Account) Reset()

Reset resets an account

func (*Account) Serialize

func (ac *Account) Serialize() []byte

Serialize serializes the account as a concatenation of 5 chunks of 256 bits one chunk per field (pubKey has 2 chunks), except index and nonce that are concatenated in a single 256 bits chunk index || nonce || balance || pubkeyX || pubkeyY, each chunk is 256 bits

type AccountCircuit

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

AccountCircuit accounts encoded as constraints

type Operator

type Operator struct {
	State      []byte            // list of accounts: index || nonce || balance || pubkeyX || pubkeyY, each chunk is 256 bits
	HashState  []byte            // Hashed version of the state, each chunk is 256bits: ... || H(index || nonce || balance || pubkeyX || pubkeyY)) || ...
	AccountMap map[string]uint64 // hashmap of all available accounts (the key is the account.pubkey.X), the value is the index of the account in the state
	// contains filtered or unexported fields
}

Operator represents a rollup operator

func NewOperator

func NewOperator(nbAccounts int, h hash.Hash) Operator

NewOperator creates a new operator. nbAccounts is the number of accounts managed by this operator, h is the hash function for the merkle proofs

type Queue

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

Queue queue for storing the transfers (fixed size queue)

func NewQueue

func NewQueue(batchSize int) Queue

NewQueue creates a new queue, batchSize is the capaciy

func (*Queue) Pop

func (q *Queue) Pop() Transfer

Pop dequeues an element from the queue

func (*Queue) Push

func (q *Queue) Push(t Transfer)

Push queues up t in the queue

type Transfer

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

Transfer describe a rollup transfer

func NewTransfer

func NewTransfer(amount uint64, from, to eddsa.PublicKey, nonce uint64) Transfer

NewTransfer creates a new transfer (to be signed)

func (*Transfer) Sign

func (t *Transfer) Sign(priv eddsa.PrivateKey, h hash.Hash) (eddsa.Signature, error)

Sign signs a transaction

func (*Transfer) Verify

func (t *Transfer) Verify(h hash.Hash) (bool, error)

Verify verifies the signature of the transfer. The message to sign is the hash (o.h) of the account.

type TransferCircuit

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

TransferCircuit transfer encoded as constraints