UInt64

A 64 bit unsigned integer with values ranging from 0 to 18,446,744,073,709,551,615.

Extends​

• CircuitValue

Constructors​

new UInt64()​

new UInt64(x:   | string  | number  | bigint  | FieldVar  | UInt64  | UInt32): UInt64

Create a UInt64. The max value of a UInt64 is 2^64 - 1 = UInt64.MAXINT().

Warning: Cannot overflow, an error is thrown if the result is greater than UInt64.MAXINT()

Parameters​

x: | string | number | bigint | FieldVar | UInt64 | UInt32

Returns​

UInt64

Overrides​

CircuitValue.constructor

Source​

lib/provable/int.ts:38

Properties​

value​

value: Field;

Source​

lib/provable/int.ts:29

NUM_BITS​

static NUM_BITS: number = 64;

Source​

lib/provable/int.ts:30

Unsafe​

static Unsafe: {  "fromField": UInt64;};

fromField()​

Create a UInt64 from a Field without constraining its range.

Warning: This is unsafe, because it does not prove that the input Field actually fits in 64 bits.\ Only use this if you know what you are doing, otherwise use the safe UInt64.from.

Returns​

UInt64

Source​

lib/provable/int.ts:46

Accessors​

one​

get static one(): UInt64

Static method to create a UInt64 with value 1.

Returns​

UInt64

Source​

lib/provable/int.ts:67

zero​

get static zero(): UInt64

Static method to create a UInt64 with value 0.

Returns​

UInt64

Source​

lib/provable/int.ts:61

Methods​

add(y: number | UInt64): UInt64

Parameters​

y: number | UInt64

Returns​

UInt64

Source​

lib/provable/int.ts:232

and()​

and(x: UInt64): UInt64

Bitwise AND gadget on UInt64 elements. Equivalent to the bitwise AND & operator in JavaScript. The AND gate works by comparing two bits and returning 1 if both bits are 1, and 0 otherwise.

It can be checked by a double generic gate that verifies the following relationship between the values below.

The generic gate verifies:\ a + b = sum and the conjunction equation 2 * and = sum - xor\ Where:\ a + b = sum\ a ^ b = xor\ a & b = and

You can find more details about the implementation in the Mina book

Returns​

UInt64

Example​

let a = UInt64.from(3);    // ... 000011let b = UInt64.from(5);    // ... 000101let c = a.and(b);    // ... 000001c.assertEquals(1);

Source​

lib/provable/int.ts:402

assertEquals()​

assertEquals(x: this): void

Parameters​

x: this

Returns​

void

Inherited from​

CircuitValue.assertEquals

Source​

lib/provable/types/circuit-value.ts:130

assertGreaterThan()​

assertGreaterThan(y: UInt64, message?: string): void

Asserts that a UInt64 is greater than another one.

Parameters​

message?: string

Returns​

void

Source​

lib/provable/int.ts:473

assertGreaterThanOrEqual()​

assertGreaterThanOrEqual(y: UInt64, message?: string): void

Asserts that a UInt64 is greater than or equal to another one.

Parameters​

message?: string

Returns​

void

Source​

lib/provable/int.ts:487

assertLessThan()​

assertLessThan(y: UInt64, message?: string): void

Asserts that a UInt64 is less than another one.

Parameters​

message?: string

Returns​

void

Source​

lib/provable/int.ts:450

assertLessThanOrEqual()​

assertLessThanOrEqual(y: UInt64, message?: string): void

Asserts that a UInt64 is less than or equal to another one.

Parameters​

message?: string

Returns​

void

Source​

lib/provable/int.ts:421

div()​

div(y: number | UInt64): UInt64

Integer division.

x.div(y) returns the floor of x / y, that is, the greatest z such that z * y <= x.

Parameters​

y: number | UInt64

Returns​

UInt64

Source​

lib/provable/int.ts:206

divMod()​

divMod(y: string | number | UInt64): {  "quotient": UInt64;  "rest": UInt64;}

Integer division with remainder.

x.divMod(y) returns the quotient and the remainder.

Parameters​

y: string | number | UInt64

Returns​

{  "quotient": UInt64;  "rest": UInt64;}
quotient​
quotient: UInt64;
rest​
rest: UInt64;

Source​

lib/provable/int.ts:163

equals()​

equals(x: this): Bool

Parameters​

x: this

Returns​

Bool

Inherited from​

CircuitValue.equals

Source​

lib/provable/types/circuit-value.ts:126

greaterThan()​

greaterThan(y: UInt64): Bool

Checks if a UInt64 is greater than another one.

Returns​

Bool

Source​

lib/provable/int.ts:466

greaterThanOrEqual()​

greaterThanOrEqual(y: UInt64): Bool

Checks if a UInt64 is greater than or equal to another one.

Returns​

Bool

Source​

lib/provable/int.ts:480

isConstant()​

isConstant(): boolean

Returns​

boolean

Inherited from​

CircuitValue.isConstant

Source​

lib/provable/types/circuit-value.ts:134

leftShift()​

leftShift(bits: number): UInt64

Performs a left shift operation on the provided UInt64 element. This operation is similar to the << shift operation in JavaScript, where bits are shifted to the left, and the overflowing bits are discarded.

It’s important to note that these operations are performed considering the big-endian 64-bit representation of the number, where the most significant (64th) bit is on the left end and the least significant bit is on the right end.

Parameters​

bits: number

Amount of bits to shift the UInt64 element to the left. The amount should be between 0 and 64 (or else the shift will fail).

Returns​

UInt64

Example​

const x = UInt64.from(0b001100); // 12 in binaryconst y = x.leftShift(2); // left shift by 2 bitsy.assertEquals(0b110000); // 48 in binary

Source​

lib/provable/int.ts:352

lessThan()​

lessThan(y: UInt64): Bool

Checks if a UInt64 is less than another one.

Returns​

Bool

Source​

lib/provable/int.ts:438

lessThanOrEqual()​

lessThanOrEqual(y: UInt64): Bool

Checks if a UInt64 is less than or equal to another one.

Returns​

Bool

Source​

lib/provable/int.ts:409

mod()​

mod(y: number | UInt64): UInt64

Integer remainder.

x.mod(y) returns the value z such that 0 <= z < y and x - z is divisible by y.

Parameters​

y: number | UInt64

Returns​

UInt64

Source​

lib/provable/int.ts:216

mul()​

mul(y: number | UInt64): UInt64

Multiplication with overflow checking.

Parameters​

y: number | UInt64

Returns​

UInt64

Source​

lib/provable/int.ts:223

not()​

not(): UInt64

Bitwise NOT gate on Field elements. Similar to the [bitwise NOT ~ operator in JavaScript](https://developer.mozilla.org/en-US/docs/ Web/JavaScript/Reference/Operators/Bitwise_NOT).

Note: The NOT gate operates over 64 bit for UInt64 types.

A NOT gate works by returning 1 in each bit position if the corresponding bit of the operand is 0, and returning 0 if the corresponding bit of the operand is 1.

NOT is implemented as a subtraction of the input from the all one bitmask

You can find more details about the implementation in the Mina book

Returns​

UInt64

Example​

// NOTing 4 bits with the unchecked versionlet a = UInt64.from(0b0101);let b = a.not(false);console.log(b.toBigInt().toString(2));// 1111111111111111111111111111111111111111111111111111111111111010

Source​

lib/provable/int.ts:299

rightShift()​

rightShift(bits: number): UInt64

Performs a right shift operation on the provided UInt64 element. This operation is similar to the >> shift operation in JavaScript, where bits are shifted to the right, and the overflowing bits are discarded.

It’s important to note that these operations are performed considering the big-endian 64-bit representation of the number, where the most significant (64th) bit is on the left end and the least significant bit is on the right end.

Parameters​

bits: number

Amount of bits to shift the UInt64 element to the right. The amount should be between 0 and 64 (or else the shift will fail).

Returns​

UInt64

Example​

const x = UInt64.from(0b001100); // 12 in binaryconst y = x.rightShift(2); // right shift by 2 bitsy.assertEquals(0b000011); // 3 in binary

Source​

lib/provable/int.ts:373

rotate()​

rotate(bits: number, direction: "left" | "right"): UInt64

A (left and right) rotation operates similarly to the shift operation (<< for left and >> for right) in JavaScript, with the distinction that the bits are circulated to the opposite end of a 64-bit representation rather than being discarded. For a left rotation, this means that bits shifted off the left end reappear at the right end. Conversely, for a right rotation, bits shifted off the right end reappear at the left end.

It’s important to note that these operations are performed considering the big-endian 64-bit representation of the number, where the most significant (64th) bit is on the left end and the least significant bit is on the right end. The direction parameter is a string that accepts either 'left' or 'right', determining the direction of the rotation.

To safely use rotate(), you need to make sure that the value passed in is range-checked to 64 bits; for example, using Gadgets.rangeCheck64.

You can find more details about the implementation in the Mina book

Parameters​

bits: number

amount of bits to rotate this UInt64 element with.

direction: "left" | "right"= 'left'

left or right rotation direction.

Returns​

UInt64

Example​

const x = UInt64.from(0b001100);const y = x.rotate(2, 'left');const z = x.rotate(2, 'right'); // right rotation by 2 bitsy.assertEquals(0b110000);z.assertEquals(0b000011);

Source​

lib/provable/int.ts:331

sub()​

sub(y: number | UInt64): UInt64

Subtraction with underflow checking.

Parameters​

y: number | UInt64

Returns​

UInt64

Source​

lib/provable/int.ts:241

toBigInt()​

toBigInt(): bigint

Turns the UInt64 into a BigInt.

Returns​

bigint

Source​

lib/provable/int.ts:81

toConstant()​

toConstant(): this

Returns​

this

Inherited from​

CircuitValue.toConstant

Source​

lib/provable/types/circuit-value.ts:122

toFields()​

toFields(): Field[]

Inherited from​

CircuitValue.toFields

Source​

lib/provable/types/circuit-value.ts:85

toJSON()​

toJSON(): any

Returns​

any

Inherited from​

CircuitValue.toJSON

Source​

lib/provable/types/circuit-value.ts:118

toString()​

toString(): string

Turns the UInt64 into a string.

Returns​

string

Source​

lib/provable/int.ts:74

toUInt32()​

toUInt32(): UInt32

Turns the UInt64 into a UInt32, asserting that it fits in 32 bits.

Returns​

UInt32

Source​

lib/provable/int.ts:88

toUInt32Clamped()​

toUInt32Clamped(): UInt32

Turns the UInt64 into a UInt32, clamping to the 32 bits range if it's too large.

UInt64.from(4294967296).toUInt32Clamped().toString(); // "4294967295"

Returns​

UInt32

Source​

lib/provable/int.ts:100

xor()​

xor(x: UInt64): UInt64

Bitwise XOR gadget on Field elements. Equivalent to the bitwise XOR ^ operator in JavaScript. A XOR gate works by comparing two bits and returning 1 if two bits differ, and 0 if two bits are equal.

This gadget builds a chain of XOR gates recursively.

You can find more details about the implementation in the Mina book

Parameters​

UInt64 element to XOR.

Returns​

UInt64

Example​

let a = UInt64.from(0b0101);let b = UInt64.from(0b0011);let c = a.xor(b);c.assertEquals(0b0110);

Source​

lib/provable/int.ts:266

MAXINT()​

static MAXINT(): UInt64

Creates a UInt64 with a value of 18,446,744,073,709,551,615.

Returns​

UInt64

Source​

lib/provable/int.ts:154

check()​

static check(x: UInt64): void

Returns​

void

Overrides​

CircuitValue.check

Source​

lib/provable/int.ts:110

empty()​

static empty<T>(): InstanceType<T>

Type parameters​

T extends AnyConstructor

Returns​

InstanceType\<T>

Inherited from​

CircuitValue.empty

Source​

lib/provable/types/circuit-value.ts:218

from()​

static from(x:   | string  | number  | bigint  | UInt64  | UInt32): UInt64

Creates a new UInt64.

Parameters​

x: | string | number | bigint | UInt64 | UInt32

Returns​

UInt64

Source​

lib/provable/int.ts:146

fromFields()​

static fromFields<T>(this: T, xs: Field[]): InstanceType<T>

Type parameters​

T extends AnyConstructor

Parameters​

this: T

xs: Field[]

Returns​

InstanceType\<T>

Inherited from​

CircuitValue.fromFields

Source​

lib/provable/types/circuit-value.ts:138

fromJSON()​

static fromJSON<T>(x: string): InstanceType<T>

Decodes a JSON-like object into this structure.

Type parameters​

T extends AnyConstructor

Parameters​

x: string

Returns​

InstanceType\<T>

Overrides​

CircuitValue.fromJSON

Source​

lib/provable/int.ts:128

fromObject()​

static fromObject<T>(this: T, value: NonMethods<InstanceType<T>>): InstanceType<T>

Type parameters​

T extends AnyConstructor

Parameters​

this: T

value: NonMethods\<InstanceType\<T>>

Returns​

InstanceType\<T>

Inherited from​

CircuitValue.fromObject

Source​

lib/provable/types/circuit-value.ts:30

fromValue()​

static fromValue<T>(x: bigint | UInt64): InstanceType<T>

Type parameters​

T extends AnyConstructor

Parameters​

x: bigint | UInt64

Returns​

InstanceType\<T>

Overrides​

CircuitValue.fromValue

Source​

lib/provable/int.ts:495

sizeInFields()​

static sizeInFields(): number

Returns​

number

Inherited from​

CircuitValue.sizeInFields

Source​

lib/provable/types/circuit-value.ts:37

toAuxiliary()​

static toAuxiliary(): []

[]

Inherited from​

CircuitValue.toAuxiliary

Source​

lib/provable/types/circuit-value.ts:59

toConstant()​

static toConstant<T>(this: T, t: InstanceType<T>): InstanceType<T>

Type parameters​

T extends AnyConstructor

Parameters​

this: T

t: InstanceType\<T>

Returns​

InstanceType\<T>

Inherited from​

CircuitValue.toConstant

Source​

lib/provable/types/circuit-value.ts:177

toFields()​

static toFields<T>(this: T, v: InstanceType<T>): Field[]

Type parameters​

T extends AnyConstructor

Parameters​

this: T

v: InstanceType\<T>

Inherited from​

CircuitValue.toFields

Source​

lib/provable/types/circuit-value.ts:42

toInput()​

static toInput(x: UInt64): HashInput

Returns​

HashInput

Overrides​

CircuitValue.toInput

Source​

lib/provable/int.ts:114

toJSON()​

static toJSON(x: UInt64): string

Encodes this structure into a JSON-like object.

Returns​

string

Overrides​

CircuitValue.toJSON

Source​

lib/provable/int.ts:121

toValue()​

static toValue(x: UInt64): bigint

Returns​

bigint

Overrides​

CircuitValue.toValue

Source​

lib/provable/int.ts:491