createProvableBigInt
function createProvableBigInt(modulus: bigint, config?: BigIntParameter): typeof ProvableBigInt_
Defined in: index.ts:166
Creates a class representing a ProvableBigInt with modular arithmetic capabilities. This is particularly useful for implementing prime fields that don't fit into the native field.
const BigInt521 = createProvableBigInt(2n ** 521n - 1n); // creates a class for 521-bit integers
createProvableBigInt(modulus, config?)
takes two parameters:
modulus
: The modulus of the field (must be a prime)config
: Optional configuration for custom limb size and numbers
The returned class supports comprehensive arithmetic operations including:
- Basic operations: addition, double, subtraction, multiplication, square, division
- Advanced operations: inverse, negate, sqrt, power
- Comparison operations: equals, assertEquals, greaterThan, lessthan, greaterThanOrEqual, lessThanOrEqual
- Conversion methods: fromBigInt, toBigInt, fromFields, toFields, fromBits, toBits
Implementation details:
Internally, a ProvableBigInt is represented as an array of Field elements (limbs), where each limb holds 116 bits as default. The total size is determined by the configuration, with preset options supporting different bit lengths:
- 348 bits (3 limbs)
- 464 bits (4 limbs)
- 580 bits (5 limbs)
- 1044 bits (9 limbs)
- 2088 bits (18 limbs)
- 4176 bits (36 limbs)
Each arithmetic operation ensures the result is a valid element of the prime field.
Parameters
modulus
bigint
The modulus for the big integer arithmetic (must be prime)
config?
BigIntParameter
Optional configuration specifying a custom limb size and number
Returns
typeof ProvableBigInt_
A class representing ProvableBigInts with the specified modulus
Example
// Create a Provable BigInt class with modulus 2^521 - 1
const BigInt521 = createProvableBigInt(2n ** 521n - 1n);
// Create instances
const a = BigInt521.fromBigInt(123n);
const b = BigInt521.fromBigInt(456n);
const c = BigInt521.fromBigInt(1024n);
// Perform operations
const sum = a.add(b);
const double = a.double();
const diff = a.sub(b);
const product = a.mul(b);
const square = a.square();
const quotient = a.div(b);
const inverse = a.inverse();
const negation = a.negate();
const power = a.pow(b);
const sqrt = c.sqrt();
The class automatically handles modular reduction after arithmetic operations to maintain valid representations. All operations are designed to be provable and optimised for less constraints.
Throws
If the modulus is zero, negative, or exceeds the maximum supported size