Skip to main content


function Struct<A, T, V, J, Pure>(type: A): (value: T) => T & {
"_isStruct": true;
} & Pure extends true ? ProvablePure<T, V> : Provable<T, V> & {
"empty": () => T;
"fromJSON": (x: J) => T;
"fromValue": (value: From<A>) => T;
"toInput": (x: T) => {
"fields": Field[];
"packed": [Field, number][];
"toJSON": (x: T) => J;

Struct lets you declare composite types for use in o1js circuits.

These composite types can be passed in as arguments to smart contract methods, used for on-chain state variables or as event / action types.

Here's an example of creating a "Voter" struct, which holds a public key and a collection of votes on 3 different proposals:

let Vote = { hasVoted: Bool, inFavor: Bool };

class Voter extends Struct({
publicKey: PublicKey,
votes: [Vote, Vote, Vote]
}) {}

// use Voter as SmartContract input:
class VoterContract extends SmartContract {
\@method register(voter: Voter) {
// ...

In this example, there are no instance methods on the class. This makes Voter type-compatible with an anonymous object of the form { publicKey: PublicKey, votes: Vote[] }. This mean you don't have to create instances by using new Voter(...), you can operate with plain objects:

voterContract.register({ publicKey, votes });

On the other hand, you can also add your own methods:

class Voter extends Struct({
publicKey: PublicKey,
votes: [Vote, Vote, Vote]
}) {
vote(index: number, inFavor: Bool) {
let vote = this.votes[i];
vote.hasVoted = Bool(true);
vote.inFavor = inFavor;

In this case, you'll need the constructor to create instances of Voter. It always takes as input the plain object:

let emptyVote = { hasVoted: Bool(false), inFavor: Bool(false) };
let voter = new Voter({ publicKey, votes: Array(3).fill(emptyVote) });, Bool(true));

In addition to creating types composed of Field elements, you can also include auxiliary data which does not become part of the proof. This, for example, allows you to re-use the same type outside o1js methods, where you might want to store additional metadata.

To declare non-proof values of type string, number, etc, you can use the built-in objects String, Number, etc. Here's how we could add the voter's name (a string) as auxiliary data:

class Voter extends Struct({
publicKey: PublicKey,
votes: [Vote, Vote, Vote],
fullName: String
}) {}

Again, it's important to note that this doesn't enable you to prove anything about the fullName string. From the circuit point of view, it simply doesn't exist!

Type parameters


T extends unknown = InferProvable\<A>

V extends unknown = InferValue\<A>

J extends unknown = InferJson\<A>

Pure extends boolean = IsPure\<A>


type: A

Object specifying the layout of the Struct


(value: T) => T & { "_isStruct": true; } & Pure extends true ? ProvablePure\<T, V> : Provable\<T, V> & { "empty": () => T; "fromJSON": (x: J) => T; "fromValue": (value: From\<A>) => T; "toInput": (x: T) => { "fields": Field[]; "packed": [Field, number][]; }; "toJSON": (x: T) => J; }

Class which you can extend