Release 0.9.1.

weierstrass, edwards: make points expose typescript x, y
bls: get rid of bigint literals. gh-22
2023-03-31 10:02:05 +02:00 · 2023-03-30 09:20:35 +02:00 · 2023-03-28 19:01:42 +02:00 · 2023-03-28 19:01:00 +02:00 · 2023-03-26 15:54:04 +02:00 · 2023-03-24 11:12:02 +01:00
60 changed files with 840 additions and 6075 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,6 @@
+{
+  "files.exclude": {
+    "*.{js,d.ts,js.map,d.ts.map}": true,
+    "esm/*.{js,d.ts,js.map,d.ts.map}": true
+  }
+}
--- a/README.md
+++ b/README.md
@@ -2,27 +2,20 @@

 Audited & minimal JS implementation of elliptic curve cryptography.

- **noble** family, zero dependencies
 - Short Weierstrass, Edwards, Montgomery curves
 - ECDSA, EdDSA, Schnorr, BLS signature schemes, ECDH key agreement
+- 🔒 [**Audited**](#security) by an independent security firm
 - #️⃣ [hash to curve](#abstracthash-to-curve-hashing-strings-to-curve-points)
  for encoding or hashing an arbitrary string to an elliptic curve point
 - 🧜‍♂️ [Poseidon](https://www.poseidon-hash.info) ZK-friendly hash
 - 🏎 [Ultra-fast](#speed), hand-optimized for caveats of JS engines
- 🔍 Unique tests ensure correctness with Wycheproof vectors and [cryptofuzz](https://github.com/guidovranken/cryptofuzz) differential fuzzing
- 🔻 Tree-shaking-friendly: there is no entry point, which ensures small size of your app
+- 🔍 Unique tests ensure correctness with Wycheproof vectors and
+  [cryptofuzz](https://github.com/guidovranken/cryptofuzz) differential fuzzing
+- 🔻 Tree-shaking-friendly: use only what's necessary, other code won't be included

-Package consists of two parts:
-
-1. [Abstract](#abstract-api), zero-dependency EC algorithms
-2. [Implementations](#implementations), utilizing one dependency `@noble/hashes`, providing ready-to-use:
-   - NIST curves secp256r1/P256, secp384r1/P384, secp521r1/P521
-   - SECG curve secp256k1
-   - ed25519/curve25519/x25519/ristretto255, edwards448/curve448/x448 [RFC7748](https://www.rfc-editor.org/rfc/rfc7748) / [RFC8032](https://www.rfc-editor.org/rfc/rfc8032) / [ZIP215](https://zips.z.cash/zip-0215) stuff
-   - pairing-friendly curves bls12-381, bn254
-
-Check out [Upgrading](#upgrading) if you've previously used single-feature noble packages
-([secp256k1](https://github.com/paulmillr/noble-secp256k1), [ed25519](https://github.com/paulmillr/noble-ed25519)).
+Check out [Upgrading](#upgrading) if you've previously used single-feature noble
+packages ([secp256k1](https://github.com/paulmillr/noble-secp256k1),
+[ed25519](https://github.com/paulmillr/noble-ed25519)).
 See [Resources](#resources) for articles and real-world software that uses curves.

 ### This library belongs to _noble_ crypto
@@ -30,33 +23,50 @@ See [Resources](#resources) for articles and real-world software that uses curve
 > **noble-crypto** — high-security, easily auditable set of contained cryptographic libraries and tools.

 - No dependencies, protection against supply chain attacks
- Easily auditable TypeScript/JS code
+- Auditable TypeScript / JS code
 - Supported in all major browsers and stable node.js versions
 - All releases are signed with PGP keys
 - Check out [homepage](https://paulmillr.com/noble/) & all libraries:
  [curves](https://github.com/paulmillr/noble-curves)
-  ([secp256k1](https://github.com/paulmillr/noble-secp256k1),
+  (4kb versions [secp256k1](https://github.com/paulmillr/noble-secp256k1),
  [ed25519](https://github.com/paulmillr/noble-ed25519)),
  [hashes](https://github.com/paulmillr/noble-hashes)

 ## Usage

-Use NPM for browser / node.js:
+Browser, deno and node.js are supported:

 > npm install @noble/curves

-For [Deno](https://deno.land), use it with [npm specifier](https://deno.land/manual@v1.28.0/node/npm_specifiers). In browser, you could also include the single file from
+For [Deno](https://deno.land), use it with
+[npm specifier](https://deno.land/manual@v1.28.0/node/npm_specifiers).
+In browser, you could also include the single file from
 [GitHub's releases page](https://github.com/paulmillr/noble-curves/releases).

-The library is tree-shaking-friendly and does not expose root entry point as `import * from '@noble/curves'`.
-Instead, you need to import specific primitives. This is done to ensure small size of your apps.
+The library is tree-shaking-friendly and does not expose root entry point as
+`import * from '@noble/curves'`. Instead, you need to import specific primitives.
+This is done to ensure small size of your apps.
+
+Package consists of two parts:
+
+1. [Implementations](#implementations), utilizing one dependency `@noble/hashes`,
+   providing ready-to-use:
+   - NIST curves secp256r1/P256, secp384r1/P384, secp521r1/P521
+   - SECG curve secp256k1
+   - ed25519/curve25519/x25519/ristretto255, edwards448/curve448/x448
+     implementing
+     [RFC7748](https://www.rfc-editor.org/rfc/rfc7748) /
+     [RFC8032](https://www.rfc-editor.org/rfc/rfc8032) /
+     [ZIP215](https://zips.z.cash/zip-0215) standards
+   - pairing-friendly curves bls12-381, bn254
+2. [Abstract](#abstract-api), zero-dependency EC algorithms

 ### Implementations

 Each curve can be used in the following way:

 ```ts
-import { secp256k1 } from '@noble/curves/secp256k1'; // ECMAScript Modules (ESM)
+import { secp256k1 } from '@noble/curves/secp256k1'; // ESM and Common.js
 // import { secp256k1 } from 'npm:@noble/curves@1.2.0/secp256k1'; // Deno
 const priv = secp256k1.utils.randomPrivateKey();
 const pub = secp256k1.getPublicKey(priv);
@@ -64,8 +74,9 @@ const msg = new Uint8Array(32).fill(1);
 const sig = secp256k1.sign(msg, priv);
 secp256k1.verify(sig, msg, pub) === true;

+// hex strings are also supported besides Uint8Arrays:
 const privHex = '46c930bc7bb4db7f55da20798697421b98c4175a52c630294d75a84b9c126236';
-const pub2 = secp256k1.getPublicKey(privHex); // keys & other inputs can be Uint8Array-s or hex strings
+const pub2 = secp256k1.getPublicKey(privHex);
 ```

 All curves:
@@ -78,7 +89,6 @@ import { p256 } from '@noble/curves/p256';
 import { p384 } from '@noble/curves/p384';
 import { p521 } from '@noble/curves/p521';
 import { pallas, vesta } from '@noble/curves/pasta';
-import * as stark from '@noble/curves/stark';
 import { bls12_381 } from '@noble/curves/bls12-381';
 import { bn254 } from '@noble/curves/bn';
 import { jubjub } from '@noble/curves/jubjub';
@@ -91,7 +101,7 @@ Weierstrass curves feature recovering public keys from signatures and ECDH key a
 const sigImprovedSecurity = secp256k1.sign(msg, priv, { extraEntropy: true });
 sig.recoverPublicKey(msg) === pub; // public key recovery
 const someonesPub = secp256k1.getPublicKey(secp256k1.utils.randomPrivateKey());
-const shared = secp256k1.getSharedSecret(priv, someonesPub); // ECDH (elliptic curve diffie-hellman)
+const shared = secp256k1.getSharedSecret(priv, someonesPub); // ECDH
 ```

 secp256k1 has schnorr signature implementation which follows
@@ -104,7 +114,6 @@ const pub = schnorr.getPublicKey(priv);
 const msg = new TextEncoder().encode('hello');
 const sig = schnorr.sign(msg, priv);
 const isValid = schnorr.verify(sig, msg, pub);
-console.log(isValid);
 ```

 ed25519 module has ed25519ctx / ed25519ph variants,
@@ -135,18 +144,27 @@ RistrettoPoint.hashToCurve('Ristretto is traditionally a short shot of espresso
 // also has add(), equals(), multiply(), toRawBytes() methods
 ```

-ed448 module is basically the same:
+ed448 is similar:

 ```ts
 import { ed448, ed448ph, ed448ctx, x448 } from '@noble/curves/ed448';
 import { hashToCurve, encodeToCurve } from '@noble/curves/ed448';
+ed448.getPublicKey(ed448.utils.randomPrivateKey());
+```
+
+Every curve has params:
+
+```ts
+import { secp256k1 } from '@noble/curves/secp256k1'; // ESM and Common.js
+console.log(secp256k1.CURVE.p, secp256k1.CURVE.n, secp256k1.CURVE.a, secp256k1.CURVE.b);
 ```

 BLS12-381 pairing-friendly Barreto-Lynn-Scott elliptic curve construction allows to
 construct [zk-SNARKs](https://z.cash/technology/zksnarks/) at the 128-bit security
 and use aggregated, batch-verifiable
 [threshold signatures](https://medium.com/snigirev.stepan/bls-signatures-better-than-schnorr-5a7fe30ea716),
-using Boneh-Lynn-Shacham signature scheme.
+using Boneh-Lynn-Shacham signature scheme. Compatible with ETH and others,
+just make sure to provide correct DST (domain separation tag argument).

 ```ts
 import { bls12_381 as bls } from '@noble/curves/bls12-381';
@@ -183,10 +201,13 @@ console.log({ publicKeys, signatures3, aggSignature3, isValid3 });

 ## Abstract API

-Abstract API allows to define custom curves. All arithmetics is done with JS bigints over finite fields,
-which is defined from `modular` sub-module. For scalar multiplication, we use [precomputed tables with w-ary non-adjacent form (wNAF)](https://paulmillr.com/posts/noble-secp256k1-fast-ecc/).
-Precomputes are enabled for weierstrass and edwards BASE points of a curve. You could precompute any
-other point (e.g. for ECDH) using `utils.precompute()` method: check out examples.
+Abstract API allows to define custom curves. All arithmetics is done with JS
+bigints over finite fields, which is defined from `modular` sub-module. For
+scalar multiplication, we use
+[precomputed tables with w-ary non-adjacent form (wNAF)](https://paulmillr.com/posts/noble-secp256k1-fast-ecc/).
+Precomputes are enabled for weierstrass and edwards BASE points of a curve. You
+could precompute any other point (e.g. for ECDH) using `utils.precompute()`
+method: check out examples.

 There are following zero-dependency algorithms:

@@ -202,14 +223,36 @@ There are following zero-dependency algorithms:

 ```ts
 import { weierstrass } from '@noble/curves/abstract/weierstrass';
+import { Field } from '@noble/curves/abstract/modular'; // finite field for mod arithmetics
+import { sha256 } from '@noble/hashes/sha256'; // 3rd-party sha256() of type utils.CHash
+import { hmac } from '@noble/hashes/hmac'; // 3rd-party hmac() that will accept sha256()
+import { concatBytes, randomBytes } from '@noble/hashes/utils'; // 3rd-party utilities
+const secq256k1 = weierstrass({
+  // secq256k1: cycle of secp256k1 with Fp/N flipped.
+  // https://personaelabs.org/posts/spartan-ecdsa
+  // https://zcash.github.io/halo2/background/curves.html#cycles-of-curves
+  a: 0n,
+  b: 7n,
+  Fp: Field(2n ** 256n - 432420386565659656852420866394968145599n),
+  n: 2n ** 256n - 2n ** 32n - 2n ** 9n - 2n ** 8n - 2n ** 7n - 2n ** 6n - 2n ** 4n - 1n,
+  Gx: 55066263022277343669578718895168534326250603453777594175500187360389116729240n,
+  Gy: 32670510020758816978083085130507043184471273380659243275938904335757337482424n,
+  hash: sha256,
+  hmac: (key: Uint8Array, ...msgs: Uint8Array[]) => hmac(sha256, key, concatBytes(...msgs)),
+  randomBytes,
+});
+
+// weierstrassPoints can also be used if you don't need ECDSA, hash, hmac, randomBytes
 ```

-Short Weierstrass curve's formula is `y² = x³ + ax + b`. `weierstrass` expects arguments `a`, `b`, field `Fp`, curve order `n`, cofactor `h`
+Short Weierstrass curve's formula is `y² = x³ + ax + b`. `weierstrass`
+expects arguments `a`, `b`, field `Fp`, curve order `n`, cofactor `h`
 and coordinates `Gx`, `Gy` of generator point.

-**`k` generation** is done deterministically, following [RFC6979](https://www.rfc-editor.org/rfc/rfc6979).
-For this you will need `hmac` & `hash`, which in our implementations is provided by noble-hashes.
-If you're using different hashing library, make sure to wrap it in the following interface:
+**`k` generation** is done deterministically, following
+[RFC6979](https://www.rfc-editor.org/rfc/rfc6979). For this you will need
+`hmac` & `hash`, which in our implementations is provided by noble-hashes. If
+you're using different hashing library, make sure to wrap it in the following interface:

 ```ts
 type CHash = {
@@ -225,11 +268,36 @@ type CHash = {
 1. Exported as `ProjectivePoint`
 2. Represented in projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)
 3. Use complete exception-free formulas for addition and doubling
-4. Can be decoded/encoded from/to Uint8Array / hex strings using `ProjectivePoint.fromHex` and `ProjectivePoint#toRawBytes()`
+4. Can be decoded/encoded from/to Uint8Array / hex strings using
+   `ProjectivePoint.fromHex` and `ProjectivePoint#toRawBytes()`
 5. Have `assertValidity()` which checks for being on-curve
 6. Have `toAffine()` and `x` / `y` getters which convert to 2d xy affine coordinates

 ```ts
+// `weierstrassPoints()` returns `CURVE` and `ProjectivePoint`
+// `weierstrass()` returns `CurveFn`
+type SignOpts = { lowS?: boolean; prehash?: boolean; extraEntropy: boolean | Uint8Array };
+type CurveFn = {
+  CURVE: ReturnType<typeof validateOpts>;
+  getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
+  getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;
+  sign: (msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => SignatureType;
+  verify: (
+    signature: Hex | SignatureType,
+    msgHash: Hex,
+    publicKey: Hex,
+    opts?: { lowS?: boolean; prehash?: boolean }
+  ) => boolean;
+  ProjectivePoint: ProjectivePointConstructor;
+  Signature: SignatureConstructor;
+  utils: {
+    normPrivateKeyToScalar: (key: PrivKey) => bigint;
+    isValidPrivateKey(key: PrivKey): boolean;
+    randomPrivateKey: () => Uint8Array;
+    precompute: (windowSize?: number, point?: ProjPointType<bigint>) => ProjPointType<bigint>;
+  };
+};
+
 // T is usually bigint, but can be something else like complex numbers in BLS curves
 interface ProjPointType<T> extends Group<ProjPointType<T>> {
  readonly px: T;
@@ -255,7 +323,8 @@ interface ProjConstructor<T> extends GroupConstructor<ProjPointType<T>> {
 }
 ```

-**ECDSA signatures** are represented by `Signature` instances and can be described by the interface:
+**ECDSA signatures** are represented by `Signature` instances and can be
+described by the interface:

 ```ts
 interface SignatureType {
@@ -280,28 +349,9 @@ type SignatureConstructor = {
 };
 ```

-Example implementing [secq256k1](https://personaelabs.org/posts/spartan-ecdsa) (NOT secp256k1)
-[cycle](https://zcash.github.io/halo2/background/curves.html#cycles-of-curves) of secp256k1 with Fp/N flipped.
+More examples:

 ```typescript
-import { weierstrass } from '@noble/curves/abstract/weierstrass';
-import { Field } from '@noble/curves/abstract/modular'; // finite field, mod arithmetics done over it
-import { sha256 } from '@noble/hashes/sha256'; // 3rd-party sha256() of type utils.CHash, with blockLen/outputLen
-import { hmac } from '@noble/hashes/hmac'; // 3rd-party hmac() that will accept sha256()
-import { concatBytes, randomBytes } from '@noble/hashes/utils'; // 3rd-party utilities
-const secq256k1 = weierstrass({
-  // secq256k1: cycle of secp256k1 with Fp/N flipped.
-  a: 0n,
-  b: 7n,
-  Fp: Field(2n ** 256n - 432420386565659656852420866394968145599n),
-  n: 2n ** 256n - 2n ** 32n - 2n ** 9n - 2n ** 8n - 2n ** 7n - 2n ** 6n - 2n ** 4n - 1n,
-  Gx: 55066263022277343669578718895168534326250603453777594175500187360389116729240n,
-  Gy: 32670510020758816978083085130507043184471273380659243275938904335757337482424n,
-  hash: sha256,
-  hmac: (key: Uint8Array, ...msgs: Uint8Array[]) => hmac(sha256, key, concatBytes(...msgs)),
-  randomBytes,
-});
-
 // All curves expose same generic interface.
 const priv = secq256k1.utils.randomPrivateKey();
 secq256k1.getPublicKey(priv); // Convert private key to public.
@@ -319,6 +369,7 @@ point.assertValidity(); // Checks for being on-curve
 point.toAffine(); // Converts to 2d affine xy coordinates

 secq256k1.CURVE.n;
+secq256k1.CURVE.p;
 secq256k1.CURVE.Fp.mod();
 secq256k1.CURVE.hash();

@@ -327,33 +378,34 @@ const fast = secq256k1.utils.precompute(8, Point.fromHex(someonesPubKey));
 fast.multiply(privKey); // much faster ECDH now
 ```

-`weierstrass()` returns `CurveFn`:
+### abstract/edwards: Twisted Edwards curve

 ```ts
-type SignOpts = { lowS?: boolean; prehash?: boolean; extraEntropy: boolean | Uint8Array };
-type CurveFn = {
-  CURVE: ReturnType<typeof validateOpts>;
-  getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
-  getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;
-  sign: (msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => SignatureType;
-  verify: (
-    signature: Hex | SignatureType,
-    msgHash: Hex,
-    publicKey: Hex,
-    opts?: { lowS?: boolean; prehash?: boolean }
-  ) => boolean;
-  ProjectivePoint: ProjectivePointConstructor;
-  Signature: SignatureConstructor;
-  utils: {
-    normPrivateKeyToScalar: (key: PrivKey) => bigint;
-    isValidPrivateKey(key: PrivKey): boolean;
-    randomPrivateKey: () => Uint8Array;
-    precompute: (windowSize?: number, point?: ProjPointType<bigint>) => ProjPointType<bigint>;
-  };
-};
-```
+import { twistedEdwards } from '@noble/curves/abstract/edwards';
+import { Field } from '@noble/curves/abstract/modular';
+import { sha512 } from '@noble/hashes/sha512';
+import { randomBytes } from '@noble/hashes/utils';

-### abstract/edwards: Twisted Edwards curve
+const Fp = Field(2n ** 255n - 19n);
+const ed25519 = twistedEdwards({
+  a: -1n,
+  d: Fp.div(-121665n, 121666n), // -121665n/121666n mod p
+  Fp: Fp,
+  n: 2n ** 252n + 27742317777372353535851937790883648493n,
+  h: 8n,
+  Gx: 15112221349535400772501151409588531511454012693041857206046113283949847762202n,
+  Gy: 46316835694926478169428394003475163141307993866256225615783033603165251855960n,
+  hash: sha512,
+  randomBytes,
+  adjustScalarBytes(bytes) {
+    // optional; but mandatory in ed25519
+    bytes[0] &= 248;
+    bytes[31] &= 127;
+    bytes[31] |= 64;
+    return bytes;
+  },
+} as const);
+```

 Twisted Edwards curve's formula is `ax² + y² = 1 + dx²y²`. You must specify `a`, `d`, field `Fp`, order `n`, cofactor `h`
 and coordinates `Gx`, `Gy` of generator point.
@@ -371,6 +423,25 @@ For EdDSA signatures, `hash` param required. `adjustScalarBytes` which instructs
 7. Have `isTorsionFree()`, `clearCofactor()` and `isSmallOrder()` utilities to handle torsions

 ```ts
+// `twistedEdwards()` returns `CurveFn` of following type:
+type CurveFn = {
+  CURVE: ReturnType<typeof validateOpts>;
+  getPublicKey: (privateKey: Hex) => Uint8Array;
+  sign: (message: Hex, privateKey: Hex, context?: Hex) => Uint8Array;
+  verify: (sig: SigType, message: Hex, publicKey: Hex, context?: Hex) => boolean;
+  ExtendedPoint: ExtPointConstructor;
+  utils: {
+    randomPrivateKey: () => Uint8Array;
+    getExtendedPublicKey: (key: PrivKey) => {
+      head: Uint8Array;
+      prefix: Uint8Array;
+      scalar: bigint;
+      point: PointType;
+      pointBytes: Uint8Array;
+    };
+  };
+};
+
 interface ExtPointType extends Group<ExtPointType> {
  readonly ex: bigint;
  readonly ey: bigint;
@@ -393,69 +464,16 @@ interface ExtPointConstructor extends GroupConstructor<ExtPointType> {
 }
 ```

-Example implementing edwards25519:
-
-```ts
-import { twistedEdwards } from '@noble/curves/abstract/edwards';
-import { Field, div } from '@noble/curves/abstract/modular';
-import { sha512 } from '@noble/hashes/sha512';
-
-const Fp = Field(2n ** 255n - 19n);
-const ed25519 = twistedEdwards({
-  a: -1n,
-  d: Fp.div(-121665n, 121666n), // -121665n/121666n mod p
-  Fp,
-  n: 2n ** 252n + 27742317777372353535851937790883648493n,
-  h: 8n,
-  Gx: 15112221349535400772501151409588531511454012693041857206046113283949847762202n,
-  Gy: 46316835694926478169428394003475163141307993866256225615783033603165251855960n,
-  hash: sha512,
-  randomBytes,
-  adjustScalarBytes(bytes) {
-    // optional; but mandatory in ed25519
-    bytes[0] &= 248;
-    bytes[31] &= 127;
-    bytes[31] |= 64;
-    return bytes;
-  },
-} as const);
-```
-
-`twistedEdwards()` returns `CurveFn` of following type:
-
-```ts
-type CurveFn = {
-  CURVE: ReturnType<typeof validateOpts>;
-  getPublicKey: (privateKey: Hex) => Uint8Array;
-  sign: (message: Hex, privateKey: Hex, context?: Hex) => Uint8Array;
-  verify: (sig: SigType, message: Hex, publicKey: Hex, context?: Hex) => boolean;
-  ExtendedPoint: ExtPointConstructor;
-  utils: {
-    randomPrivateKey: () => Uint8Array;
-    getExtendedPublicKey: (key: PrivKey) => {
-      head: Uint8Array;
-      prefix: Uint8Array;
-      scalar: bigint;
-      point: PointType;
-      pointBytes: Uint8Array;
-    };
-  };
-};
-```
-
 ### abstract/montgomery: Montgomery curve

-The module contains methods for x-only ECDH on Curve25519 / Curve448 from RFC7748. Proper Elliptic Curve Points are not implemented yet.
-
-You must specify curve params `Fp`, `a`, `Gu` coordinate of u, `montgomeryBits` and `nByteLength`.
-
 ```typescript
 import { montgomery } from '@noble/curves/abstract/montgomery';
+import { Field } from '@noble/curves/abstract/modular';

 const x25519 = montgomery({
-  Fp: Field(2n ** 255n - 19n),
  a: 486662n,
  Gu: 9n,
+  Fp: Field(2n ** 255n - 19n),
  montgomeryBits: 255,
  nByteLength: 32,
  // Optional param
@@ -468,6 +486,11 @@ const x25519 = montgomery({
 });
 ```

+The module contains methods for x-only ECDH on Curve25519 / Curve448 from RFC7748.
+Proper Elliptic Curve Points are not implemented yet.
+
+You must specify curve params `Fp`, `a`, `Gu` coordinate of u, `montgomeryBits` and `nByteLength`.
+
 ### abstract/hash-to-curve: Hashing strings to curve points

 The module allows to hash arbitrary strings to elliptic curve points. Implements [hash-to-curve v16](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-16).
@@ -508,19 +531,37 @@ function expand_message_xof(
 ): Uint8Array;
 ```

-`hash_to_field(msg, count, options)` [(spec)](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-5.3)
+`hash_to_field(msg, count, options)`
+[(spec)](https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-5.3)
 hashes arbitrary-length byte strings to a list of one or more elements of a finite field F.

- `msg` a byte string containing the message to hash
- `count` the number of elements of F to output
- `options` `{DST: string, p: bigint, m: number, k: number, expand: 'xmd' | 'xof', hash: H}`.
-  - `p` is field prime, m=field extension (1 for prime fields)
-  - `k` is security target in bits (e.g. 128).
-  - `expand` should be `xmd` for SHA2, SHA3, BLAKE; `xof` for SHAKE, BLAKE-XOF
-  - `hash` conforming to `utils.CHash` interface, with `outputLen` / `blockLen` props
- Returns `[u_0, ..., u_(count - 1)]`, a list of field elements.
-
 ```ts
+/**
+ * * `DST` is a domain separation tag, defined in section 2.2.5
+ * * `p` characteristic of F, where F is a finite field of characteristic p and order q = p^m
+ * * `m` is extension degree (1 for prime fields)
+ * * `k` is the target security target in bits (e.g. 128), from section 5.1
+ * * `expand` is `xmd` (SHA2, SHA3, BLAKE) or `xof` (SHAKE, BLAKE-XOF)
+ * * `hash` conforming to `utils.CHash` interface, with `outputLen` / `blockLen` props
+ */
+type UnicodeOrBytes = string | Uint8Array;
+type Opts = {
+    DST: UnicodeOrBytes;
+    p: bigint;
+    m: number;
+    k: number;
+    expand?: 'xmd' | 'xof';
+    hash: CHash;
+};
+
+/**
+ * Hashes arbitrary-length byte strings to a list of one or more elements of a finite field F
+ * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-5.3
+ * @param msg a byte string containing the message to hash
+ * @param count the number of elements of F to output
+ * @param options `{DST: string, p: bigint, m: number, k: number, expand: 'xmd' | 'xof', hash: H}`, see above
+ * @returns [u_0, ..., u_(count - 1)], a list of field elements.
+ */
 function hash_to_field(msg: Uint8Array, count: number, options: Opts): bigint[][];
 ```

@@ -530,7 +571,7 @@ Implements [Poseidon](https://www.poseidon-hash.info) ZK-friendly hash.

 There are many poseidon variants with different constants.
 We don't provide them: you should construct them manually.
-The only variant provided resides in `stark` module: inspect it for proper usage.
+Check out [micro-starknet](https://github.com/paulmillr/micro-starknet) package for a proper example.

 ```ts
 import { poseidon } from '@noble/curves/abstract/poseidon';
@@ -541,7 +582,7 @@ type PoseidonOpts = {
  roundsFull: number;
  roundsPartial: number;
  sboxPower?: number;
-  reversePartialPowIdx?: boolean; // Hack for stark
+  reversePartialPowIdx?: boolean;
  mds: bigint[][];
  roundConstants: bigint[][];
 };
@@ -612,9 +653,11 @@ utils.equalBytes(Uint8Array.from([0xde]), Uint8Array.from([0xde]));

 ## Security

-The library had no prior security audit. The library has been fuzzed by [Guido Vranken's cryptofuzz](https://github.com/guidovranken/cryptofuzz): you can run the fuzzer by yourself to check it.
-
-[Timing attack](https://en.wikipedia.org/wiki/Timing_attack) considerations: we are using non-CT bigints. However, _JIT-compiler_ and _Garbage Collector_ make "constant time" extremely hard to achieve in a scripting language. Which means _any other JS library can't have constant-timeness_. Even statically typed Rust, a language without GC, [makes it harder to achieve constant-time](https://www.chosenplaintext.ca/open-source/rust-timing-shield/security) for some cases. If your goal is absolute security, don't use any JS lib — including bindings to native ones. Use low-level libraries & languages. Nonetheless we're targetting algorithmic constant time.
+1. The library has been audited during Jan-Feb 2023 by an independent security firm [Trail of Bits](https://www.trailofbits.com):
+[PDF](https://github.com/trailofbits/publications/blob/master/reviews/2023-01-ryanshea-noblecurveslibrary-securityreview.pdf).
+The audit has been funded by Ryan Shea. Audit scope was abstract modules `curve`, `hash-to-curve`, `modular`, `poseidon`, `utils`, `weierstrass`, and top-level modules `_shortw_utils` and `secp256k1`. See [changes since audit](https://github.com/paulmillr/noble-curves/compare/0.7.3..main).
+2. The library has been fuzzed by [Guido Vranken's cryptofuzz](https://github.com/guidovranken/cryptofuzz). You can run the fuzzer by yourself to check it.
+3. [Timing attack](https://en.wikipedia.org/wiki/Timing_attack) considerations: _JIT-compiler_ and _Garbage Collector_ make "constant time" extremely hard to achieve in a scripting language. Which means _any other JS library can't have constant-timeness_. Even statically typed Rust, a language without GC, [makes it harder to achieve constant-time](https://www.chosenplaintext.ca/open-source/rust-timing-shield/security) for some cases. If your goal is absolute security, don't use any JS lib — including bindings to native ones. Use low-level libraries & languages. Nonetheless we're targetting algorithmic constant time.

 We consider infrastructure attacks like rogue NPM modules very important; that's why it's crucial to minimize the amount of 3rd-party dependencies & native bindings. If your app uses 500 dependencies, any dep could get hacked and you'll be downloading malware with every `npm install`. Our goal is to minimize this attack vector. As for devDependencies used by the library:

@@ -670,12 +713,6 @@ getPublicKey x 3,363 ops/sec @ 297μs/op
 sign x 1,615 ops/sec @ 619μs/op
 verify x 319 ops/sec @ 3ms/op

-stark
-init x 35 ops/sec @ 28ms/op
-pedersen x 884 ops/sec @ 1ms/op
-poseidon x 8,598 ops/sec @ 116μs/op
-verify x 528 ops/sec @ 1ms/op
-
 ecdh
 ├─x25519 x 1,337 ops/sec @ 747μs/op
 ├─secp256k1 x 461 ops/sec @ 2ms/op
@@ -709,12 +746,17 @@ hashToCurve
 └─ed448 x 1,045 ops/sec @ 956μs/op
 ```

+## Contributing & testing
+
+1. Clone the repository
+2. `npm install` to install build dependencies like TypeScript
+3. `npm run build` to compile TypeScript code
+4. `npm run test` will execute all main tests
+
 ## Resources

 Article about some of library's features: [Learning fast elliptic-curve cryptography](https://paulmillr.com/posts/noble-secp256k1-fast-ecc/)

-Demo: Elliptic curve calculator [paulmillr.com/ecc](https://paulmillr.com/ecc).
-
 Projects using the library:

 - secp256k1
@@ -725,44 +767,53 @@ Projects using the library:
  - Check out `bls12-381.ts` for articles about the curve
  - Threshold sigs demo [genthresh.com](https://genthresh.com)
  - BBS signatures [github.com/Wind4Greg/BBS-Draft-Checks](https://github.com/Wind4Greg/BBS-Draft-Checks) following [draft-irtf-cfrg-bbs-signatures-latest](https://identity.foundation/bbs-signature/draft-irtf-cfrg-bbs-signatures.html)
+- Others
+  - All curves demo: Elliptic curve calculator [paulmillr.com/noble](https://paulmillr.com/noble)
+  - [micro-starknet](https://github.com/paulmillr/micro-starknet) for stark-friendly elliptic curve.

 ## Upgrading

-If you're coming from single-feature noble packages, the following changes need to be kept in mind:
+Previously, the library was split into single-feature packages
+noble-secp256k1 and noble-ed25519. curves can be thought as a continuation of their
+original work. The libraries now changed their direction towards providing
+minimal 4kb implementations of cryptography and are not as feature-complete.

- 2d affine (x, y) points have been removed to reduce complexity and improve speed
- Removed `number` support as a type for private keys, `bigint` is still supported
- `mod`, `invert` are no longer present in `utils`: use `@noble/curves/abstract/modular`
+Upgrading from [@noble/secp256k1](https://github.com/paulmillr/noble-secp256k1) 1.7:

-Upgrading from @noble/secp256k1 1.7:
+- `getPublicKey`
+    - now produce 33-byte compressed signatures by default
+    - to use old behavior, which produced 65-byte uncompressed keys, set
+      argument `isCompressed` to `false`: `getPublicKey(priv, false)`
+- `sign`
+    - is now sync; use `signAsync` for async version
+    - now returns `Signature` instance with `{ r, s, recovery }` properties
+    - `canonical` option was renamed to `lowS`
+    - `recovered` option has been removed because recovery bit is always returned now
+    - `der` option has been removed. There are 2 options:
+        1. Use compact encoding: `fromCompact`, `toCompactRawBytes`, `toCompactHex`.
+           Compact encoding is simply a concatenation of 32-byte r and 32-byte s.
+        2. If you must use DER encoding, switch to noble-curves (see above).
+- `verify`
+    - `strict` option was renamed to `lowS`
+- `getSharedSecret`
+    - now produce 33-byte compressed signatures by default
+    - to use old behavior, which produced 65-byte uncompressed keys, set
+      argument `isCompressed` to `false`: `getSharedSecret(a, b, false)`
+- `recoverPublicKey(msg, sig, rec)` was changed to `sig.recoverPublicKey(msg)`
+- `number` type for private keys have been removed: use `bigint` instead
+- `Point` (2d xy) has been changed to `ProjectivePoint` (3d xyz)
+- `utils` were split into `utils` (same api as in noble-curves) and
+  `etc` (`hmacSha256Sync` and others)

- Compressed (33-byte) public keys are now returned by default, instead of uncompressed
- Methods are now synchronous. Setting `secp.utils.hmacSha256` is no longer required
- `sign()`
-  - `der`, `recovered` options were removed
-  - `canonical` was renamed to `lowS`
-  - Return type is now `{ r: bigint, s: bigint, recovery: number }` instance of `Signature`
- `verify()`
-  - `strict` was renamed to `lowS`
- `recoverPublicKey()`: moved to sig instance `Signature#recoverPublicKey(msgHash)`
- `Point` was removed: use `ProjectivePoint` in xyz coordinates
- `utils`: Many methods were removed, others were moved to `schnorr` namespace
+Upgrading from [@noble/ed25519](https://github.com/paulmillr/noble-ed25519) 1.7:

-Upgrading from @noble/ed25519 1.7:
-
- Methods are now synchronous. Setting `secp.utils.hmacSha256` is no longer required
- ed25519ph, ed25519ctx
- `Point` was removed: use `ExtendedPoint` in xyzt coordinates
- `Signature` was removed
- `getSharedSecret` was removed: use separate x25519 sub-module
+- Methods are now sync by default
 - `bigint` is no longer allowed in `getPublicKey`, `sign`, `verify`. Reason: ed25519 is LE, can lead to bugs
-
-## Contributing & testing
-
-1. Clone the repository
-2. `npm install` to install build dependencies like TypeScript
-3. `npm run build` to compile TypeScript code
-4. `npm run test` will execute all main tests
+- `Point` (2d xy) has been changed to `ExtendedPoint` (xyzt)
+- `Signature` was removed: just use raw bytes or hex now
+- `utils` were split into `utils` (same api as in noble-curves) and
+  `etc` (`sha512Sync` and others)
+- `getSharedSecret` was moved to `x25519` module

 ## License

--- a/audit/2023-01-trailofbits-audit-curves.pdf
+++ b/audit/2023-01-trailofbits-audit-curves.pdf
--- a/audit/README.md
+++ b/audit/README.md
@@ -0,0 +1,11 @@
+# Audit
+
+The library has been audited during Jan-Feb 2023 by an independent security firm [Trail of Bits](https://www.trailofbits.com):
+[PDF](https://github.com/trailofbits/publications/blob/master/reviews/2023-01-ryanshea-noblecurveslibrary-securityreview.pdf).
+The audit has been funded by Ryan Shea. Audit scope was abstract modules `curve`, `hash-to-curve`, `modular`, `poseidon`, `utils`, `weierstrass`, and top-level modules `_shortw_utils` and `secp256k1`. See [changes since audit](https://github.com/paulmillr/noble-curves/compare/0.7.3..main).
+
+File in the directory was saved from
+[github.com/trailofbits/publications](https://github.com/trailofbits/publications).
+Check out their repo and verify checksums to ensure the PDF in this directory has not been altered.
+
+See information about fuzzing in root [README](../README.md).
--- a/benchmark/modular.js
+++ b/benchmark/modular.js
@@ -1,6 +1,6 @@
 import { run, mark } from 'micro-bmark';
 import { secp256k1 } from '../secp256k1.js';
-import { Fp } from '../abstract/modular.js';
+import { Field as Fp  } from '../abstract/modular.js';

 run(async () => {
  console.log(`\x1b[36mmodular, secp256k1 field\x1b[0m`);
--- a/benchmark/package.json
+++ b/benchmark/package.json
@@ -16,7 +16,6 @@
  },
  "dependencies": {
    "@noble/hashes": "^1.1.5",
-    "@starkware-industries/starkware-crypto-utils": "^0.0.2",
    "elliptic": "^6.5.4"
  }
 }
--- a/benchmark/stark.js
+++ b/benchmark/stark.js
@@ -1,56 +0,0 @@
-import { run, mark, compare, utils } from 'micro-bmark';
-import * as starkwareCrypto from '@starkware-industries/starkware-crypto-utils';
-import * as stark from '../stark.js';
-
-run(async () => {
-  const RAM = false;
-  if (RAM) utils.logMem();
-  console.log(`\x1b[36mstark\x1b[0m`);
-  await mark('init', 1, () => stark.utils.precompute(8));
-  const d = (() => {
-    const priv = '2dccce1da22003777062ee0870e9881b460a8b7eca276870f57c601f182136c';
-    const msg = 'c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47';
-    const pub = stark.getPublicKey(priv);
-    const sig = stark.sign(msg, priv);
-
-    const privateKey = '2dccce1da22003777062ee0870e9881b460a8b7eca276870f57c601f182136c';
-    const msgHash = 'c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47';
-    const keyPair = starkwareCrypto.default.ec.keyFromPrivate(privateKey, 'hex');
-    const publicKeyStark = starkwareCrypto.default.ec.keyFromPublic(
-      keyPair.getPublic(true, 'hex'),
-      'hex'
-    );
-    return { priv, sig, msg, pub, publicKeyStark, msgHash, keyPair };
-  })();
-  await compare('pedersen', 500, {
-    old: () => {
-      return starkwareCrypto.default.pedersen([
-        '3d937c035c878245caf64531a5756109c53068da139362728feb561405371cb',
-        '208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a',
-      ]);
-    },
-    noble: () => {
-      return stark.pedersen(
-        '3d937c035c878245caf64531a5756109c53068da139362728feb561405371cb',
-        '208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a'
-      );
-    },
-  });
-  await mark('poseidon', 10000, () => stark.poseidonHash(
-    0x3d937c035c878245caf64531a5756109c53068da139362728feb561405371cbn,
-    0x208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31an
-  ));
-  await compare('verify', 500, {
-    old: () => {
-      return starkwareCrypto.default.verify(
-        d.publicKeyStark,
-        d.msgHash,
-        starkwareCrypto.default.sign(d.keyPair, d.msgHash)
-      );
-    },
-    noble: () => {
-      return stark.verify(stark.sign(d.msg, d.priv), d.msg, d.pub);
-    },
-  });
-  if (RAM) utils.logMem();
-});
--- a/esm/package.json
+++ b/esm/package.json
@@ -2,6 +2,6 @@
  "type": "module",
  "browser": {
    "crypto": false,
-    "./crypto": "./esm/cryptoBrowser.js"
+    "./crypto": "./esm/crypto.js"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
  "name": "@noble/curves",
-  "version": "0.8.0",
+  "version": "0.9.1",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@noble/curves",
-      "version": "0.8.0",
+      "version": "0.9.1",
      "funding": [
        {
          "type": "individual",
@@ -15,35 +15,38 @@
      ],
      "license": "MIT",
      "dependencies": {
-        "@noble/hashes": "1.2.0"
+        "@noble/hashes": "1.3.0"
      },
      "devDependencies": {
-        "@scure/bip32": "~1.1.5",
-        "@scure/bip39": "~1.1.1",
-        "@types/node": "18.11.3",
+        "@scure/bip32": "~1.2.0",
+        "@scure/bip39": "~1.2.0",
+        "@types/node": "18.11.18",
        "fast-check": "3.0.0",
        "micro-bmark": "0.3.1",
        "micro-should": "0.4.0",
-        "prettier": "2.8.3",
-        "typescript": "4.7.3"
+        "prettier": "2.8.4",
+        "typescript": "5.0.2"
      }
    },
-    "node_modules/@noble/hashes": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.2.0.tgz",
-      "integrity": "sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==",
+    "node_modules/@noble/curves": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-0.8.3.tgz",
+      "integrity": "sha512-OqaOf4RWDaCRuBKJLDURrgVxjLmneGsiCXGuzYB5y95YithZMA6w4uk34DHSm0rKMrrYiaeZj48/81EvaAScLQ==",
+      "dev": true,
      "funding": [
        {
          "type": "individual",
          "url": "https://paulmillr.com/funding/"
        }
-      ]
+      ],
+      "dependencies": {
+        "@noble/hashes": "1.3.0"
+      }
    },
-    "node_modules/@noble/secp256k1": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz",
-      "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==",
-      "dev": true,
+    "node_modules/@noble/hashes": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.0.tgz",
+      "integrity": "sha512-ilHEACi9DwqJB0pw7kv+Apvh50jiiSyR/cQ3y4W7lOR5mhvn/50FLUfsnfJz0BDZtl/RR16kXvptiv6q1msYZg==",
      "funding": [
        {
          "type": "individual",
@@ -64,9 +67,9 @@
      ]
    },
    "node_modules/@scure/bip32": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.5.tgz",
-      "integrity": "sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.2.0.tgz",
+      "integrity": "sha512-O+vT/hBVk+ag2i6j2CDemwd1E1MtGt+7O1KzrPNsaNvSsiEK55MyPIxJIMI2PS8Ijj464B2VbQlpRoQXxw1uHg==",
      "dev": true,
      "funding": [
        {
@@ -75,15 +78,15 @@
        }
      ],
      "dependencies": {
-        "@noble/hashes": "~1.2.0",
-        "@noble/secp256k1": "~1.7.0",
+        "@noble/curves": "~0.8.3",
+        "@noble/hashes": "~1.3.0",
        "@scure/base": "~1.1.0"
      }
    },
    "node_modules/@scure/bip39": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz",
-      "integrity": "sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.2.0.tgz",
+      "integrity": "sha512-SX/uKq52cuxm4YFXWFaVByaSHJh2w3BnokVSeUJVCv6K7WulT9u2BuNRBhuFl8vAuYnzx9bEu9WgpcNYTrYieg==",
      "dev": true,
      "funding": [
        {
@@ -92,14 +95,14 @@
        }
      ],
      "dependencies": {
-        "@noble/hashes": "~1.2.0",
+        "@noble/hashes": "~1.3.0",
        "@scure/base": "~1.1.0"
      }
    },
    "node_modules/@types/node": {
-      "version": "18.11.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.3.tgz",
-      "integrity": "sha512-fNjDQzzOsZeKZu5NATgXUPsaFaTxeRgFXoosrHivTl8RGeV733OLawXsGfEk9a8/tySyZUyiZ6E8LcjPFZ2y1A==",
+      "version": "18.11.18",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.18.tgz",
+      "integrity": "sha512-DHQpWGjyQKSHj3ebjFI/wRKcqQcdR+MoFBygntYOZytCqNfkd2ZC4ARDJ2DQqhjH5p85Nnd3jhUJIXrszFX/JA==",
      "dev": true
    },
    "node_modules/fast-check": {
@@ -131,9 +134,9 @@
      "dev": true
    },
    "node_modules/prettier": {
-      "version": "2.8.3",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.3.tgz",
-      "integrity": "sha512-tJ/oJ4amDihPoufT5sM0Z1SKEuKay8LfVAMlbbhnnkvt6BUserZylqo2PN+p9KeljLr0OHa2rXHU1T8reeoTrw==",
+      "version": "2.8.4",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.4.tgz",
+      "integrity": "sha512-vIS4Rlc2FNh0BySk3Wkd6xmwxB0FpOndW5fisM5H8hsZSxU2VWVB5CWIkIjWvrHjIhxk2g3bfMKM87zNTrZddw==",
      "dev": true,
      "bin": {
        "prettier": "bin-prettier.js"
@@ -162,16 +165,16 @@
      ]
    },
    "node_modules/typescript": {
-      "version": "4.7.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.7.3.tgz",
-      "integrity": "sha512-WOkT3XYvrpXx4vMMqlD+8R8R37fZkjyLGlxavMc4iB8lrl8L0DeTcHbYgw/v0N/z9wAFsgBhcsF0ruoySS22mA==",
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
+      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
      "dev": true,
      "bin": {
        "tsc": "bin/tsc",
        "tsserver": "bin/tsserver"
      },
      "engines": {
-        "node": ">=4.2.0"
+        "node": ">=12.20"
      }
    }
  }
--- a/package.json
+++ b/package.json
@@ -1,9 +1,10 @@
 {
  "name": "@noble/curves",
-  "version": "0.8.0",
-  "description": "Minimal, auditable JS implementation of elliptic curve cryptography",
+  "version": "0.9.1",
+  "description": "Audited & minimal JS implementation of elliptic curve cryptography",
  "files": [
    "abstract",
+    "esm",
    "src",
    "*.js",
    "*.js.map",
@@ -11,10 +12,10 @@
    "*.d.ts.map"
  ],
  "scripts": {
-    "bench": "cd benchmark; node secp256k1.js; node curves.js; node ecdh.js; node stark.js; node bls.js",
-    "build": "tsc",
-    "build:clean": "rm *.{js,d.ts,js.map} esm/*.{js,js.map} 2> /dev/null",
+    "bench": "cd benchmark; node secp256k1.js; node curves.js; node ecdh.js; node hash-to-curve.js; node modular.js; node bls.js",
+    "build": "tsc && tsc -p tsconfig.esm.json",
    "build:release": "rollup -c rollup.config.js",
+    "build:clean": "rm *.{js,d.ts,d.ts.map,js.map} esm/*.{js,d.ts,d.ts.map,js.map} 2> /dev/null",
    "lint": "prettier --check 'src/**/*.{js,ts}' 'test/*.js'",
    "format": "prettier --write 'src/**/*.{js,ts}' 'test/*.js'",
    "test": "node test/index.test.js"
@@ -27,112 +28,129 @@
  },
  "license": "MIT",
  "dependencies": {
-    "@noble/hashes": "1.2.0"
+    "@noble/hashes": "1.3.0"
  },
  "devDependencies": {
-    "@scure/bip32": "~1.1.5",
-    "@scure/bip39": "~1.1.1",
-    "@types/node": "18.11.3",
+    "@scure/bip32": "~1.2.0",
+    "@scure/bip39": "~1.2.0",
+    "@types/node": "18.11.18",
    "fast-check": "3.0.0",
    "micro-bmark": "0.3.1",
    "micro-should": "0.4.0",
-    "prettier": "2.8.3",
-    "typescript": "4.7.3"
+    "prettier": "2.8.4",
+    "typescript": "5.0.2"
  },
  "main": "index.js",
-  "type": "module",
  "exports": {
    ".": {
      "types": "./index.d.ts",
+      "import": "./esm/index.js",
      "default": "./index.js"
    },
    "./abstract/edwards": {
      "types": "./abstract/edwards.d.ts",
+      "import": "./esm/abstract/edwards.js",
      "default": "./abstract/edwards.js"
    },
    "./abstract/modular": {
      "types": "./abstract/modular.d.ts",
+      "import": "./esm/abstract/modular.js",
      "default": "./abstract/modular.js"
    },
    "./abstract/montgomery": {
      "types": "./abstract/montgomery.d.ts",
+      "import": "./esm/abstract/montgomery.js",
      "default": "./abstract/montgomery.js"
    },
    "./abstract/weierstrass": {
      "types": "./abstract/weierstrass.d.ts",
+      "import": "./esm/abstract/weierstrass.js",
      "default": "./abstract/weierstrass.js"
    },
    "./abstract/bls": {
      "types": "./abstract/bls.d.ts",
+      "import": "./esm/abstract/bls.js",
      "default": "./abstract/bls.js"
    },
    "./abstract/hash-to-curve": {
      "types": "./abstract/hash-to-curve.d.ts",
+      "import": "./esm/abstract/hash-to-curve.js",
      "default": "./abstract/hash-to-curve.js"
    },
    "./abstract/curve": {
      "types": "./abstract/curve.d.ts",
+      "import": "./esm/abstract/curve.js",
      "default": "./abstract/curve.js"
    },
    "./abstract/utils": {
      "types": "./abstract/utils.d.ts",
+      "import": "./esm/abstract/utils.js",
      "default": "./abstract/utils.js"
    },
    "./abstract/poseidon": {
      "types": "./abstract/poseidon.d.ts",
+      "import": "./esm/abstract/poseidon.js",
      "default": "./abstract/poseidon.js"
    },
    "./_shortw_utils": {
      "types": "./_shortw_utils.d.ts",
+      "import": "./esm/_shortw_utils.js",
      "default": "./_shortw_utils.js"
    },
    "./bls12-381": {
      "types": "./bls12-381.d.ts",
+      "import": "./esm/bls12-381.js",
      "default": "./bls12-381.js"
    },
    "./bn": {
      "types": "./bn.d.ts",
+      "import": "./esm/bn.js",
      "default": "./bn.js"
    },
    "./ed25519": {
      "types": "./ed25519.d.ts",
+      "import": "./esm/ed25519.js",
      "default": "./ed25519.js"
    },
    "./ed448": {
      "types": "./ed448.d.ts",
+      "import": "./esm/ed448.js",
      "default": "./ed448.js"
    },
    "./index": {
      "types": "./index.d.ts",
+      "import": "./esm/index.js",
      "default": "./index.js"
    },
    "./jubjub": {
      "types": "./jubjub.d.ts",
+      "import": "./esm/jubjub.js",
      "default": "./jubjub.js"
    },
    "./p256": {
      "types": "./p256.d.ts",
+      "import": "./esm/p256.js",
      "default": "./p256.js"
    },
    "./p384": {
      "types": "./p384.d.ts",
+      "import": "./esm/p384.js",
      "default": "./p384.js"
    },
    "./p521": {
      "types": "./p521.d.ts",
+      "import": "./esm/p521.js",
      "default": "./p521.js"
    },
    "./pasta": {
      "types": "./pasta.d.ts",
+      "import": "./esm/pasta.js",
      "default": "./pasta.js"
    },
    "./secp256k1": {
      "types": "./secp256k1.d.ts",
+      "import": "./esm/secp256k1.js",
      "default": "./secp256k1.js"
-    },
-    "./stark": {
-      "types": "./stark.d.ts",
-      "default": "./stark.js"
    }
  },
  "keywords": [
@@ -153,7 +171,7 @@
    "bn254",
    "pasta",
    "bls",
-    "nist",
+    "noble",
    "ecc",
    "ecdsa",
    "eddsa",
--- a/src/abstract/bls.ts
+++ b/src/abstract/bls.ts
@@ -12,7 +12,7 @@
 * Some projects may prefer to swap this relation, it is not supported for now.
 */
 import { AffinePoint } from './curve.js';
-import { Field, hashToPrivateScalar } from './modular.js';
+import { IField, hashToPrivateScalar } from './modular.js';
 import { Hex, PrivKey, CHash, bitLen, bitGet, ensureBytes } from './utils.js';
 import * as htf from './hash-to-curve.js';
 import {
@@ -41,15 +41,15 @@ export type CurveType<Fp, Fp2, Fp6, Fp12> = {
    htfDefaults: htf.Opts;
  };
  x: bigint;
-  Fp: Field<Fp>;
-  Fr: Field<bigint>;
-  Fp2: Field<Fp2> & {
+  Fp: IField<Fp>;
+  Fr: IField<bigint>;
+  Fp2: IField<Fp2> & {
    reim: (num: Fp2) => { re: bigint; im: bigint };
    multiplyByB: (num: Fp2) => Fp2;
    frobeniusMap(num: Fp2, power: number): Fp2;
  };
-  Fp6: Field<Fp6>;
-  Fp12: Field<Fp12> & {
+  Fp6: IField<Fp6>;
+  Fp12: IField<Fp12> & {
    frobeniusMap(num: Fp12, power: number): Fp12;
    multiplyBy014(num: Fp12, o0: Fp2, o1: Fp2, o4: Fp2): Fp12;
    conjugate(num: Fp12): Fp12;
@@ -62,11 +62,11 @@ export type CurveType<Fp, Fp2, Fp6, Fp12> = {

 export type CurveFn<Fp, Fp2, Fp6, Fp12> = {
  CURVE: CurveType<Fp, Fp2, Fp6, Fp12>;
-  Fr: Field<bigint>;
-  Fp: Field<Fp>;
-  Fp2: Field<Fp2>;
-  Fp6: Field<Fp6>;
-  Fp12: Field<Fp12>;
+  Fr: IField<bigint>;
+  Fp: IField<Fp>;
+  Fp2: IField<Fp2>;
+  Fp6: IField<Fp6>;
+  Fp12: IField<Fp12>;
  G1: CurvePointsRes<Fp> & ReturnType<typeof htf.createHasher<Fp>>;
  G2: CurvePointsRes<Fp2> & ReturnType<typeof htf.createHasher<Fp2>>;
  Signature: SignatureCoder<Fp2>;
--- a/src/abstract/curve.ts
+++ b/src/abstract/curve.ts
@@ -1,6 +1,6 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 // Abelian group utilities
-import { Field, validateField, nLength } from './modular.js';
+import { IField, validateField, nLength } from './modular.js';
 import { validateObject } from './utils.js';
 const _0n = BigInt(0);
 const _1n = BigInt(1);
@@ -168,7 +168,7 @@ export function wNAF<T extends Group<T>>(c: GroupConstructor<T>, bits: number) {
 // Generic BasicCurve interface: works even for polynomial fields (BLS): P, n, h would be ok.
 // Though generator can be different (Fp2 / Fp6 for BLS).
 export type BasicCurve<T> = {
-  Fp: Field<T>; // Field over which we'll do calculations (Fp)
+  Fp: IField<T>; // Field over which we'll do calculations (Fp)
  n: bigint; // Curve order, total count of valid points in the field
  nBitLength?: number; // bit length of curve order
  nByteLength?: number; // byte length of curve order
@@ -195,5 +195,9 @@ export function validateBasic<FP, T>(curve: BasicCurve<FP> & T) {
    }
  );
  // Set defaults
-  return Object.freeze({ ...nLength(curve.n, curve.nBitLength), ...curve } as const);
+  return Object.freeze({
+    ...nLength(curve.n, curve.nBitLength),
+    ...curve,
+    ...{ p: curve.Fp.ORDER },
+  } as const);
 }
--- a/src/abstract/edwards.ts
+++ b/src/abstract/edwards.ts
@@ -5,11 +5,9 @@ import * as ut from './utils.js';
 import { ensureBytes, FHash, Hex } from './utils.js';
 import { Group, GroupConstructor, wNAF, BasicCurve, validateBasic, AffinePoint } from './curve.js';

-// Be friendly to bad ECMAScript parsers by not using bigint literals like 123n
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _8n = BigInt(8);
+// Be friendly to bad ECMAScript parsers by not using bigint literals
+// prettier-ignore
+const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _8n = BigInt(8);

 // Edwards curves must declare params a & d.
 export type CurveType = BasicCurve<bigint> & {
@@ -51,6 +49,8 @@ export interface ExtPointType extends Group<ExtPointType> {
  readonly ey: bigint;
  readonly ez: bigint;
  readonly et: bigint;
+  get x(): bigint;
+  get y(): bigint;
  assertValidity(): void;
  multiply(scalar: bigint): ExtPointType;
  multiplyUnsafe(scalar: bigint): ExtPointType;
@@ -58,6 +58,8 @@ export interface ExtPointType extends Group<ExtPointType> {
  isTorsionFree(): boolean;
  clearCofactor(): ExtPointType;
  toAffine(iz?: bigint): AffinePoint<bigint>;
+  toRawBytes(isCompressed?: boolean): Uint8Array;
+  toHex(isCompressed?: boolean): string;
 }
 // Static methods of Extended Point with coordinates in X, Y, Z, T
 export interface ExtPointConstructor extends GroupConstructor<ExtPointType> {
@@ -109,7 +111,7 @@ export function twistedEdwards(curveDef: CurveType): CurveFn {
      if (ctx.length || phflag) throw new Error('Contexts/pre-hash are not supported');
      return data;
    }); // NOOP
-  const inBig = (n: bigint) => typeof n === 'bigint' && 0n < n; // n in [1..]
+  const inBig = (n: bigint) => typeof n === 'bigint' && _0n < n; // n in [1..]
  const inRange = (n: bigint, max: bigint) => inBig(n) && inBig(max) && n < max; // n in [1..max-1]
  const in0MaskRange = (n: bigint) => n === _0n || inRange(n, MASK); // n in [0..MASK-1]
  function assertInRange(n: bigint, max: bigint) {
@@ -297,8 +299,9 @@ export function twistedEdwards(curveDef: CurveType): CurveFn {
    // Non-constant-time multiplication. Uses double-and-add algorithm.
    // It's faster, but should only be used when you don't care about
    // an exposed private key e.g. sig verification.
+    // Does NOT allow scalars higher than CURVE.n.
    multiplyUnsafe(scalar: bigint): Point {
-      let n = assertGE0(scalar);
+      let n = assertGE0(scalar); // 0 <= scalar < CURVE.n
      if (n === _0n) return I;
      if (this.equals(I) || n === _1n) return this;
      if (this.equals(G)) return this.wNAF(n).p;
@@ -440,8 +443,8 @@ export function twistedEdwards(curveDef: CurveType): CurveFn {
    if (preHash) msg = preHash(msg); // for ed25519ph, etc
    const A = Point.fromHex(publicKey, false); // Check for s bounds, hex validity
    const R = Point.fromHex(sig.slice(0, len), false); // 0 <= R < 2^256: ZIP215 R can be >= P
-    const s = ut.bytesToNumberLE(sig.slice(len, 2 * len)); // 0 <= s < l
-    const SB = G.multiplyUnsafe(s);
+    const s = ut.bytesToNumberLE(sig.slice(len, 2 * len));
+    const SB = G.multiplyUnsafe(s); // 0 <= s < l is done inside
    const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
    const RkA = R.add(A.multiplyUnsafe(k));
    // [8][S]B = [8]R + [8][k]A'
--- a/src/abstract/hash-to-curve.ts
+++ b/src/abstract/hash-to-curve.ts
@@ -1,6 +1,6 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import type { Group, GroupConstructor, AffinePoint } from './curve.js';
-import { mod, Field } from './modular.js';
+import { mod, IField } from './modular.js';
 import { bytesToNumberBE, CHash, concatBytes, utf8ToBytes, validateObject } from './utils.js';

 /**
@@ -163,7 +163,7 @@ export function hash_to_field(msg: Uint8Array, count: number, options: Opts): bi
  return u;
 }

-export function isogenyMap<T, F extends Field<T>>(field: F, map: [T[], T[], T[], T[]]) {
+export function isogenyMap<T, F extends IField<T>>(field: F, map: [T[], T[], T[], T[]]) {
  // Make same order as in spec
  const COEFF = map.map((i) => Array.from(i).reverse());
  return (x: T, y: T) => {
--- a/src/abstract/modular.ts
+++ b/src/abstract/modular.ts
@@ -97,7 +97,7 @@ export function tonelliShanks(P: bigint) {
  // Fast-path
  if (S === 1) {
    const p1div4 = (P + _1n) / _4n;
-    return function tonelliFast<T>(Fp: Field<T>, n: T) {
+    return function tonelliFast<T>(Fp: IField<T>, n: T) {
      const root = Fp.pow(n, p1div4);
      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
      return root;
@@ -106,7 +106,7 @@ export function tonelliShanks(P: bigint) {

  // Slow-path
  const Q1div2 = (Q + _1n) / _2n;
-  return function tonelliSlow<T>(Fp: Field<T>, n: T): T {
+  return function tonelliSlow<T>(Fp: IField<T>, n: T): T {
    // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1
    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE)) throw new Error('Cannot find square root');
    let r = S;
@@ -146,7 +146,7 @@ export function FpSqrt(P: bigint) {
    //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;
    // const NUM = 72057594037927816n;
    const p1div4 = (P + _1n) / _4n;
-    return function sqrt3mod4<T>(Fp: Field<T>, n: T) {
+    return function sqrt3mod4<T>(Fp: IField<T>, n: T) {
      const root = Fp.pow(n, p1div4);
      // Throw if root**2 != n
      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');
@@ -157,7 +157,7 @@ export function FpSqrt(P: bigint) {
  // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)
  if (P % _8n === _5n) {
    const c1 = (P - _5n) / _8n;
-    return function sqrt5mod8<T>(Fp: Field<T>, n: T) {
+    return function sqrt5mod8<T>(Fp: IField<T>, n: T) {
      const n2 = Fp.mul(n, _2n);
      const v = Fp.pow(n2, c1);
      const nv = Fp.mul(n, v);
@@ -203,7 +203,7 @@ export const isNegativeLE = (num: bigint, modulo: bigint) => (mod(num, modulo) &
 // - unreadable mess: addition, multiply, square, squareRoot, inversion, divide, power, equals, subtract

 // Field is not always over prime, Fp2 for example has ORDER(q)=p^m
-export interface Field<T> {
+export interface IField<T> {
  ORDER: bigint;
  BYTES: number;
  BITS: number;
@@ -249,7 +249,7 @@ const FIELD_FIELDS = [
  'eql', 'add', 'sub', 'mul', 'pow', 'div',
  'addN', 'subN', 'mulN', 'sqrN'
 ] as const;
-export function validateField<T>(field: Field<T>) {
+export function validateField<T>(field: IField<T>) {
  const initial = {
    ORDER: 'bigint',
    MASK: 'bigint',
@@ -264,7 +264,7 @@ export function validateField<T>(field: Field<T>) {
 }

 // Generic field functions
-export function FpPow<T>(f: Field<T>, num: T, power: bigint): T {
+export function FpPow<T>(f: IField<T>, num: T, power: bigint): T {
  // Should have same speed as pow for bigints
  // TODO: benchmark!
  if (power < _0n) throw new Error('Expected power > 0');
@@ -275,12 +275,13 @@ export function FpPow<T>(f: Field<T>, num: T, power: bigint): T {
  while (power > _0n) {
    if (power & _1n) p = f.mul(p, d);
    d = f.sqr(d);
-    power >>= 1n;
+    power >>= _1n;
  }
  return p;
 }

-export function FpInvertBatch<T>(f: Field<T>, nums: T[]): T[] {
+// 0 is non-invertible: non-batched version will throw on 0
+export function FpInvertBatch<T>(f: IField<T>, nums: T[]): T[] {
  const tmp = new Array(nums.length);
  // Walk from first to last, multiply them by each other MOD p
  const lastMultiplied = nums.reduce((acc, num, i) => {
@@ -299,12 +300,12 @@ export function FpInvertBatch<T>(f: Field<T>, nums: T[]): T[] {
  return tmp;
 }

-export function FpDiv<T>(f: Field<T>, lhs: T, rhs: T | bigint): T {
+export function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T {
  return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));
 }

 // This function returns True whenever the value x is a square in the field F.
-export function FpIsSquare<T>(f: Field<T>) {
+export function FpIsSquare<T>(f: IField<T>) {
  const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic
  return (x: T): boolean => {
    const p = f.pow(x, legendreConst);
@@ -320,16 +321,24 @@ export function nLength(n: bigint, nBitLength?: number) {
  return { nBitLength: _nBitLength, nByteLength };
 }

-// NOTE: very fragile, always bench. Major performance points:
-// - NonNormalized ops
-// - Object.freeze
-// - same shape of object (don't add/remove keys)
-type FpField = Field<bigint> & Required<Pick<Field<bigint>, 'isOdd'>>;
-export function Fp(
+type FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;
+/**
+ * Initializes a galois field over prime. Non-primes are not supported for now.
+ * Do not init in loop: slow. Very fragile: always run a benchmark on change.
+ * Major performance gains:
+ * a) non-normalized operations like mulN instead of mul
+ * b) `Object.freeze`
+ * c) Same object shape: never add or remove keys
+ * @param ORDER prime positive bigint
+ * @param bitLen how many bits the field consumes
+ * @param isLE (def: false) if encoding / decoding should be in little-endian
+ * @param redef optional faster redefinitions of sqrt and other methods
+ */
+export function Field(
  ORDER: bigint,
  bitLen?: number,
  isLE = false,
-  redef: Partial<Field<bigint>> = {}
+  redef: Partial<IField<bigint>> = {}
 ): Readonly<FpField> {
  if (ORDER <= _0n) throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
@@ -382,13 +391,13 @@ export function Fp(
  return Object.freeze(f);
 }

-export function FpSqrtOdd<T>(Fp: Field<T>, elm: T) {
+export function FpSqrtOdd<T>(Fp: IField<T>, elm: T) {
  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);
  const root = Fp.sqrt(elm);
  return Fp.isOdd(root) ? root : Fp.neg(root);
 }

-export function FpSqrtEven<T>(Fp: Field<T>, elm: T) {
+export function FpSqrtEven<T>(Fp: IField<T>, elm: T) {
  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);
  const root = Fp.sqrt(elm);
  return Fp.isOdd(root) ? Fp.neg(root) : root;
--- a/src/abstract/poseidon.ts
+++ b/src/abstract/poseidon.ts
@@ -1,10 +1,10 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 // Poseidon Hash: https://eprint.iacr.org/2019/458.pdf, https://www.poseidon-hash.info
-import { Field, FpPow, validateField } from './modular.js';
+import { IField, FpPow, validateField } from './modular.js';
 // We don't provide any constants, since different implementations use different constants.
 // For reference constants see './test/poseidon.test.js'.
 export type PoseidonOpts = {
-  Fp: Field<bigint>;
+  Fp: IField<bigint>;
  t: number;
  roundsFull: number;
  roundsPartial: number;
--- a/src/abstract/weierstrass.ts
+++ b/src/abstract/weierstrass.ts
@@ -58,6 +58,8 @@ export interface ProjPointType<T> extends Group<ProjPointType<T>> {
  readonly px: T;
  readonly py: T;
  readonly pz: T;
+  get x(): T;
+  get y(): T;
  multiply(scalar: bigint): ProjPointType<T>;
  toAffine(iz?: T): AffinePoint<T>;
  isTorsionFree(): boolean;
@@ -82,8 +84,8 @@ export interface ProjConstructor<T> extends GroupConstructor<ProjPointType<T>> {

 export type CurvePointsType<T> = BasicWCurve<T> & {
  // Bytes
-  fromBytes: (bytes: Uint8Array) => AffinePoint<T>;
-  toBytes: (c: ProjConstructor<T>, point: ProjPointType<T>, compressed: boolean) => Uint8Array;
+  fromBytes?: (bytes: Uint8Array) => AffinePoint<T>;
+  toBytes?: (c: ProjConstructor<T>, point: ProjPointType<T>, isCompressed: boolean) => Uint8Array;
 };

 function validatePointOpts<T>(curve: CurvePointsType<T>) {
@@ -93,8 +95,6 @@ function validatePointOpts<T>(curve: CurvePointsType<T>) {
    {
      a: 'field',
      b: 'field',
-      fromBytes: 'function',
-      toBytes: 'function',
    },
    {
      allowedPrivateKeyLengths: 'array',
@@ -102,6 +102,8 @@ function validatePointOpts<T>(curve: CurvePointsType<T>) {
      isTorsionFree: 'function',
      clearCofactor: 'function',
      allowInfinityPoint: 'boolean',
+      fromBytes: 'function',
+      toBytes: 'function',
    }
  );
  const { endo, Fp, a } = opts;
@@ -176,14 +178,31 @@ const DER = {
  },
 };

-// Be friendly to bad ECMAScript parsers by not using bigint literals like 123n
-const _0n = BigInt(0);
-const _1n = BigInt(1);
+// Be friendly to bad ECMAScript parsers by not using bigint literals
+// prettier-ignore
+const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);

 export function weierstrassPoints<T>(opts: CurvePointsType<T>) {
  const CURVE = validatePointOpts(opts);
  const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ

+  const toBytes =
+    CURVE.toBytes ||
+    ((c: ProjConstructor<T>, point: ProjPointType<T>, isCompressed: boolean) => {
+      const a = point.toAffine();
+      return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+    });
+  const fromBytes =
+    CURVE.fromBytes ||
+    ((bytes: Uint8Array) => {
+      // const head = bytes[0];
+      const tail = bytes.subarray(1);
+      // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');
+      const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+      const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+      return { x, y };
+    });
+
  /**
   * y² = x³ + ax + b: Short weierstrass curve formula
   * @returns y²
@@ -280,7 +299,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>) {
     * @param hex short/long ECDSA hex
     */
    static fromHex(hex: Hex): Point {
-      const P = Point.fromAffine(CURVE.fromBytes(ensureBytes('pointHex', hex)));
+      const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));
      P.assertValidity();
      return P;
    }
@@ -348,7 +367,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>) {
    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
    double() {
      const { a, b } = CURVE;
-      const b3 = Fp.mul(b, 3n);
+      const b3 = Fp.mul(b, _3n);
      const { px: X1, py: Y1, pz: Z1 } = this;
      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
      let t0 = Fp.mul(X1, X1); // step 1
@@ -395,7 +414,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>) {
      const { px: X2, py: Y2, pz: Z2 } = other;
      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
      const a = CURVE.a;
-      const b3 = Fp.mul(CURVE.b, 3n);
+      const b3 = Fp.mul(CURVE.b, _3n);
      let t0 = Fp.mul(X1, X2); // step 1
      let t1 = Fp.mul(Y1, Y2);
      let t2 = Fp.mul(Z1, Z2);
@@ -563,7 +582,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>) {

    toRawBytes(isCompressed = true): Uint8Array {
      this.assertValidity();
-      return CURVE.toBytes(Point, this, isCompressed);
+      return toBytes(Point, this, isCompressed);
    }

    toHex(isCompressed = true): string {
@@ -574,6 +593,7 @@ export function weierstrassPoints<T>(opts: CurvePointsType<T>) {
  const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);

  return {
+    CURVE,
    ProjectivePoint: Point as ProjConstructor<T>,
    normPrivateKeyToScalar,
    weierstrassEquation,
@@ -652,8 +672,7 @@ export type CurveFn = {

 export function weierstrass(curveDef: CurveType): CurveFn {
  const CURVE = validateOpts(curveDef) as ReturnType<typeof validateOpts>;
-  const CURVE_ORDER = CURVE.n;
-  const Fp = CURVE.Fp;
+  const { Fp, n: CURVE_ORDER } = CURVE;
  const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32
  const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32

@@ -1055,22 +1074,21 @@ export function weierstrass(curveDef: CurveType): CurveFn {
 }

 // Implementation of the Shallue and van de Woestijne method for any Weierstrass curve
-
 // TODO: check if there is a way to merge this with uvRatio in Edwards && move to modular?
 // b = True and y = sqrt(u / v) if (u / v) is square in F, and
 // b = False and y = sqrt(Z * (u / v)) otherwise.
-export function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T) {
+export function SWUFpSqrtRatio<T>(Fp: mod.IField<T>, Z: T) {
  // Generic implementation
  const q = Fp.ORDER;
-  let l = 0n;
-  for (let o = q - 1n; o % 2n === 0n; o /= 2n) l += 1n;
+  let l = _0n;
+  for (let o = q - _1n; o % _2n === _0n; o /= _2n) l += _1n;
  const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.
-  const c2 = (q - 1n) / 2n ** c1; // 2. c2 = (q - 1) / (2^c1)        # Integer arithmetic
-  const c3 = (c2 - 1n) / 2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic
-  const c4 = 2n ** c1 - 1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic
-  const c5 = 2n ** (c1 - 1n); // 5. c5 = 2^(c1 - 1)              # Integer arithmetic
+  const c2 = (q - _1n) / _2n ** c1; // 2. c2 = (q - 1) / (2^c1)        # Integer arithmetic
+  const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic
+  const c4 = _2n ** c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic
+  const c5 = _2n ** (c1 - _1n); // 5. c5 = 2^(c1 - 1)              # Integer arithmetic
  const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2
-  const c7 = Fp.pow(Z, (c2 + 1n) / 2n); // 7. c7 = Z^((c2 + 1) / 2)
+  const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)
  let sqrtRatio = (u: T, v: T): { isValid: boolean; value: T } => {
    let tv1 = c6; // 1. tv1 = c6
    let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4
@@ -1090,7 +1108,7 @@ export function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T) {
    tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)
    // 17. for i in (c1, c1 - 1, ..., 2):
    for (let i = c1; i > 1; i--) {
-      let tv5 = 2n ** (i - 2n); // 18.    tv5 = i - 2;    19.    tv5 = 2^tv5
+      let tv5 = _2n ** (i - _2n); // 18.    tv5 = i - 2;    19.    tv5 = 2^tv5
      let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5
      const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1
      tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1
@@ -1101,9 +1119,9 @@ export function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T) {
    }
    return { isValid: isQR, value: tv3 };
  };
-  if (Fp.ORDER % 4n === 3n) {
+  if (Fp.ORDER % _4n === _3n) {
    // sqrt_ratio_3mod4(u, v)
-    const c1 = (Fp.ORDER - 3n) / 4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic
+    const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic
    const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)
    sqrtRatio = (u: T, v: T) => {
      let tv1 = Fp.sqr(v); // 1. tv1 = v^2
@@ -1119,12 +1137,12 @@ export function SWUFpSqrtRatio<T>(Fp: mod.Field<T>, Z: T) {
    };
  }
  // No curves uses that
-  // if (Fp.ORDER % 8n === 5n) // sqrt_ratio_5mod8
+  // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8
  return sqrtRatio;
 }
 // From draft-irtf-cfrg-hash-to-curve-16
 export function mapToCurveSimpleSWU<T>(
-  Fp: mod.Field<T>,
+  Fp: mod.IField<T>,
  opts: {
    A: T;
    B: T;
--- a/src/bls12-381.ts
+++ b/src/bls12-381.ts
@@ -69,16 +69,23 @@ import {
 } from './abstract/weierstrass.js';
 import { isogenyMap } from './abstract/hash-to-curve.js';

+// Be friendly to bad ECMAScript parsers by not using bigint literals
+// prettier-ignore
+const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
+const _8n = BigInt(8),
+  _16n = BigInt(16);
+
 // CURVE FIELDS
 // Finite field over p.
-const Fp =
-  mod.Fp(
-    0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn
-  );
+const Fp = mod.Field(
+  BigInt(
+    '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'
+  )
+);
 type Fp = bigint;
 // Finite field over r.
 // This particular field is not used anywhere in bls12-381, but it is still useful.
-const Fr = mod.Fp(0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n);
+const Fr = mod.Field(BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001'));

 // Fp₂ over complex plane
 type BigintTuple = [bigint, bigint];
@@ -121,10 +128,11 @@ type Fp2Utils = {
 // h2q
 // NOTE: ORDER was wrong!
 const FP2_ORDER =
-  0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn **
-  2n;
+  BigInt(
+    '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'
+  ) ** _2n;

-const Fp2: mod.Field<Fp2> & Fp2Utils = {
+const Fp2: mod.IField<Fp2> & Fp2Utils = {
  ORDER: FP2_ORDER,
  BITS: bitLen(FP2_ORDER),
  BYTES: Math.ceil(bitLen(FP2_ORDER) / 8),
@@ -175,7 +183,7 @@ const Fp2: mod.Field<Fp2> & Fp2Utils = {
    // https://github.com/zkcrypto/bls12_381/blob/080eaa74ec0e394377caa1ba302c8c121df08b07/src/fp2.rs#L250
    // https://github.com/supranational/blst/blob/aae0c7d70b799ac269ff5edf29d8191dbd357876/src/exp2.c#L1
    // Inspired by https://github.com/dalek-cryptography/curve25519-dalek/blob/17698df9d4c834204f83a3574143abacb4fc81a5/src/field.rs#L99
-    const candidateSqrt = Fp2.pow(num, (Fp2.ORDER + 8n) / 16n);
+    const candidateSqrt = Fp2.pow(num, (Fp2.ORDER + _8n) / _16n);
    const check = Fp2.div(Fp2.sqr(candidateSqrt), num); // candidateSqrt.square().div(this);
    const R = FP2_ROOTS_OF_UNITY;
    const divisor = [R[0], R[2], R[4], R[6]].find((r) => Fp2.eql(r, check));
@@ -193,10 +201,10 @@ const Fp2: mod.Field<Fp2> & Fp2Utils = {
  // Same as sgn0_fp2 in draft-irtf-cfrg-hash-to-curve-16
  isOdd: (x: Fp2) => {
    const { re: x0, im: x1 } = Fp2.reim(x);
-    const sign_0 = x0 % 2n;
-    const zero_0 = x0 === 0n;
-    const sign_1 = x1 % 2n;
-    return BigInt(sign_0 || (zero_0 && sign_1)) == 1n;
+    const sign_0 = x0 % _2n;
+    const zero_0 = x0 === _0n;
+    const sign_1 = x1 % _2n;
+    return BigInt(sign_0 || (zero_0 && sign_1)) == _1n;
  },
  // Bytes util
  fromBytes(b: Uint8Array): Fp2 {
@@ -216,8 +224,8 @@ const Fp2: mod.Field<Fp2> & Fp2Utils = {
  // multiply by u + 1
  mulByNonresidue: ({ c0, c1 }) => ({ c0: Fp.sub(c0, c1), c1: Fp.add(c0, c1) }),
  multiplyByB: ({ c0, c1 }) => {
-    let t0 = Fp.mul(c0, 4n); // 4 * c0
-    let t1 = Fp.mul(c1, 4n); // 4 * c1
+    let t0 = Fp.mul(c0, _4n); // 4 * c0
+    let t1 = Fp.mul(c1, _4n); // 4 * c1
    // (T0-T1) + (T0+T1)*i
    return { c0: Fp.sub(t0, t1), c1: Fp.add(t0, t1) };
  },
@@ -234,33 +242,36 @@ const Fp2: mod.Field<Fp2> & Fp2Utils = {
 // Finite extension field over irreducible polynominal.
 // Fp(u) / (u² - β) where β = -1
 const FP2_FROBENIUS_COEFFICIENTS = [
-  0x1n,
-  0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaan,
+  BigInt('0x1'),
+  BigInt(
+    '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaa'
+  ),
 ].map((item) => Fp.create(item));

 // For Fp2 roots of unity.
-const rv1 =
-  0x6af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09n;
+const rv1 = BigInt(
+  '0x6af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09'
+);
 // const ev1 =
-//   0x699be3b8c6870965e5bf892ad5d2cc7b0e85a117402dfd83b7f4a947e02d978498255a2aaec0ac627b5afbdf1bf1c90n;
+//   BigInt('0x699be3b8c6870965e5bf892ad5d2cc7b0e85a117402dfd83b7f4a947e02d978498255a2aaec0ac627b5afbdf1bf1c90');
 // const ev2 =
-//   0x8157cd83046453f5dd0972b6e3949e4288020b5b8a9cc99ca07e27089a2ce2436d965026adad3ef7baba37f2183e9b5n;
+//   BigInt('0x8157cd83046453f5dd0972b6e3949e4288020b5b8a9cc99ca07e27089a2ce2436d965026adad3ef7baba37f2183e9b5');
 // const ev3 =
-//   0xab1c2ffdd6c253ca155231eb3e71ba044fd562f6f72bc5bad5ec46a0b7a3b0247cf08ce6c6317f40edbc653a72dee17n;
+//   BigInt('0xab1c2ffdd6c253ca155231eb3e71ba044fd562f6f72bc5bad5ec46a0b7a3b0247cf08ce6c6317f40edbc653a72dee17');
 // const ev4 =
-//   0xaa404866706722864480885d68ad0ccac1967c7544b447873cc37e0181271e006df72162a3d3e0287bf597fbf7f8fc1n;
+//   BigInt('0xaa404866706722864480885d68ad0ccac1967c7544b447873cc37e0181271e006df72162a3d3e0287bf597fbf7f8fc1');

 // Eighth roots of unity, used for computing square roots in Fp2.
 // To verify or re-calculate:
 // Array(8).fill(new Fp2([1n, 1n])).map((fp2, k) => fp2.pow(Fp2.ORDER * BigInt(k) / 8n))
 const FP2_ROOTS_OF_UNITY = [
-  [1n, 0n],
+  [_1n, _0n],
  [rv1, -rv1],
-  [0n, 1n],
+  [_0n, _1n],
  [rv1, rv1],
-  [-1n, 0n],
+  [-_1n, _0n],
  [-rv1, rv1],
-  [0n, -1n],
+  [_0n, -_1n],
  [-rv1, -rv1],
 ].map((pair) => Fp2.fromBigTuple(pair));
 // eta values, used for computing sqrt(g(X1(t)))
@@ -314,8 +325,8 @@ const Fp6Multiply = ({ c0, c1, c2 }: Fp6, rhs: Fp6 | bigint) => {
 };
 const Fp6Square = ({ c0, c1, c2 }: Fp6) => {
  let t0 = Fp2.sqr(c0); // c0²
-  let t1 = Fp2.mul(Fp2.mul(c0, c1), 2n); // 2 * c0 * c1
-  let t3 = Fp2.mul(Fp2.mul(c1, c2), 2n); // 2 * c1 * c2
+  let t1 = Fp2.mul(Fp2.mul(c0, c1), _2n); // 2 * c0 * c1
+  let t3 = Fp2.mul(Fp2.mul(c1, c2), _2n); // 2 * c1 * c2
  let t4 = Fp2.sqr(c2); // c2²
  return {
    c0: Fp2.add(Fp2.mulByNonresidue(t3), t0), // T3 * (u + 1) + T0
@@ -333,7 +344,7 @@ type Fp6Utils = {
  multiplyByFp2(lhs: Fp6, rhs: Fp2): Fp6;
 };

-const Fp6: mod.Field<Fp6> & Fp6Utils = {
+const Fp6: mod.IField<Fp6> & Fp6Utils = {
  ORDER: Fp2.ORDER, // TODO: unused, but need to verify
  BITS: 3 * Fp2.BITS,
  BYTES: 3 * Fp2.BYTES,
@@ -440,46 +451,64 @@ const Fp6: mod.Field<Fp6> & Fp6Utils = {
 };

 const FP6_FROBENIUS_COEFFICIENTS_1 = [
-  [0x1n, 0x0n],
+  [BigInt('0x1'), BigInt('0x0')],
  [
-    0x0n,
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaacn,
+    BigInt('0x0'),
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac'
+    ),
  ],
  [
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffen,
-    0x0n,
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
+    ),
+    BigInt('0x0'),
  ],
-  [0x0n, 0x1n],
+  [BigInt('0x0'), BigInt('0x1')],
  [
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaacn,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x0n,
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffen,
+    BigInt('0x0'),
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
+    ),
  ],
 ].map((pair) => Fp2.fromBigTuple(pair));
 const FP6_FROBENIUS_COEFFICIENTS_2 = [
-  [0x1n, 0x0n],
+  [BigInt('0x1'), BigInt('0x0')],
  [
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaadn,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaad'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaacn,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaan,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaa'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffen,
-    0x0n,
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffeffffn,
-    0x0n,
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffeffff'
+    ),
+    BigInt('0x0'),
  ],
 ].map((pair) => Fp2.fromBigTuple(pair));

@@ -488,7 +517,7 @@ const FP6_FROBENIUS_COEFFICIENTS_2 = [
 // Fp₆(w) / (w² - γ) where γ = v
 type Fp12 = { c0: Fp6; c1: Fp6 };
 // The BLS parameter x for BLS12-381
-const BLS_X = 0xd201000000010000n;
+const BLS_X = BigInt('0xd201000000010000');
 const BLS_X_LEN = bitLen(BLS_X);

 // prettier-ignore
@@ -545,7 +574,7 @@ type Fp12Utils = {
  _cyclotomicExp(num: Fp12, n: bigint): Fp12;
 };

-const Fp12: mod.Field<Fp12> & Fp12Utils = {
+const Fp12: mod.IField<Fp12> & Fp12Utils = {
  ORDER: Fp2.ORDER, // TODO: unused, but need to verify
  BITS: 2 * Fp2.BITS,
  BYTES: 2 * Fp2.BYTES,
@@ -646,14 +675,14 @@ const Fp12: mod.Field<Fp12> & Fp12Utils = {
    let t9 = Fp2.mulByNonresidue(t8); // T8 * (u + 1)
    return {
      c0: Fp6.create({
-        c0: Fp2.add(Fp2.mul(Fp2.sub(t3, c0c0), 2n), t3), // 2 * (T3 - c0c0)  + T3
-        c1: Fp2.add(Fp2.mul(Fp2.sub(t5, c0c1), 2n), t5), // 2 * (T5 - c0c1)  + T5
-        c2: Fp2.add(Fp2.mul(Fp2.sub(t7, c0c2), 2n), t7),
+        c0: Fp2.add(Fp2.mul(Fp2.sub(t3, c0c0), _2n), t3), // 2 * (T3 - c0c0)  + T3
+        c1: Fp2.add(Fp2.mul(Fp2.sub(t5, c0c1), _2n), t5), // 2 * (T5 - c0c1)  + T5
+        c2: Fp2.add(Fp2.mul(Fp2.sub(t7, c0c2), _2n), t7),
      }), // 2 * (T7 - c0c2)  + T7
      c1: Fp6.create({
-        c0: Fp2.add(Fp2.mul(Fp2.add(t9, c1c0), 2n), t9), // 2 * (T9 + c1c0) + T9
-        c1: Fp2.add(Fp2.mul(Fp2.add(t4, c1c1), 2n), t4), // 2 * (T4 + c1c1) + T4
-        c2: Fp2.add(Fp2.mul(Fp2.add(t6, c1c2), 2n), t6),
+        c0: Fp2.add(Fp2.mul(Fp2.add(t9, c1c0), _2n), t9), // 2 * (T9 + c1c0) + T9
+        c1: Fp2.add(Fp2.mul(Fp2.add(t4, c1c1), _2n), t4), // 2 * (T4 + c1c1) + T4
+        c2: Fp2.add(Fp2.mul(Fp2.add(t6, c1c2), _2n), t6),
      }),
    }; // 2 * (T6 + c1c2) + T6
  },
@@ -688,50 +717,84 @@ const Fp12: mod.Field<Fp12> & Fp12Utils = {
  },
 };
 const FP12_FROBENIUS_COEFFICIENTS = [
-  [0x1n, 0x0n],
+  [BigInt('0x1'), BigInt('0x0')],
  [
-    0x1904d3bf02bb0667c231beb4202c0d1f0fd603fd3cbd5f4f7b2443d784bab9c4f67ea53d63e7813d8d0775ed92235fb8n,
-    0x00fc3e2b36c4e03288e9e902231f9fb854a14787b6c7b36fec0c8ec971f63c5f282d5ac14d6c7ec22cf78a126ddc4af3n,
+    BigInt(
+      '0x1904d3bf02bb0667c231beb4202c0d1f0fd603fd3cbd5f4f7b2443d784bab9c4f67ea53d63e7813d8d0775ed92235fb8'
+    ),
+    BigInt(
+      '0x00fc3e2b36c4e03288e9e902231f9fb854a14787b6c7b36fec0c8ec971f63c5f282d5ac14d6c7ec22cf78a126ddc4af3'
+    ),
  ],
  [
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffeffffn,
-    0x0n,
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffeffff'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2n,
-    0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09n,
+    BigInt(
+      '0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2'
+    ),
+    BigInt(
+      '0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09'
+    ),
  ],
  [
-    0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffen,
-    0x0n,
+    BigInt(
+      '0x00000000000000005f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x144e4211384586c16bd3ad4afa99cc9170df3560e77982d0db45f3536814f0bd5871c1908bd478cd1ee605167ff82995n,
-    0x05b2cfd9013a5fd8df47fa6b48b1e045f39816240c0b8fee8beadf4d8e9c0566c63a3e6e257f87329b18fae980078116n,
+    BigInt(
+      '0x144e4211384586c16bd3ad4afa99cc9170df3560e77982d0db45f3536814f0bd5871c1908bd478cd1ee605167ff82995'
+    ),
+    BigInt(
+      '0x05b2cfd9013a5fd8df47fa6b48b1e045f39816240c0b8fee8beadf4d8e9c0566c63a3e6e257f87329b18fae980078116'
+    ),
  ],
  [
-    0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaan,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaaa'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x00fc3e2b36c4e03288e9e902231f9fb854a14787b6c7b36fec0c8ec971f63c5f282d5ac14d6c7ec22cf78a126ddc4af3n,
-    0x1904d3bf02bb0667c231beb4202c0d1f0fd603fd3cbd5f4f7b2443d784bab9c4f67ea53d63e7813d8d0775ed92235fb8n,
+    BigInt(
+      '0x00fc3e2b36c4e03288e9e902231f9fb854a14787b6c7b36fec0c8ec971f63c5f282d5ac14d6c7ec22cf78a126ddc4af3'
+    ),
+    BigInt(
+      '0x1904d3bf02bb0667c231beb4202c0d1f0fd603fd3cbd5f4f7b2443d784bab9c4f67ea53d63e7813d8d0775ed92235fb8'
+    ),
  ],
  [
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaacn,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09n,
-    0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2n,
+    BigInt(
+      '0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09'
+    ),
+    BigInt(
+      '0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2'
+    ),
  ],
  [
-    0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaadn,
-    0x0n,
+    BigInt(
+      '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaad'
+    ),
+    BigInt('0x0'),
  ],
  [
-    0x05b2cfd9013a5fd8df47fa6b48b1e045f39816240c0b8fee8beadf4d8e9c0566c63a3e6e257f87329b18fae980078116n,
-    0x144e4211384586c16bd3ad4afa99cc9170df3560e77982d0db45f3536814f0bd5871c1908bd478cd1ee605167ff82995n,
+    BigInt(
+      '0x05b2cfd9013a5fd8df47fa6b48b1e045f39816240c0b8fee8beadf4d8e9c0566c63a3e6e257f87329b18fae980078116'
+    ),
+    BigInt(
+      '0x144e4211384586c16bd3ad4afa99cc9170df3560e77982d0db45f3536814f0bd5871c1908bd478cd1ee605167ff82995'
+    ),
  ],
 ].map((n) => Fp2.fromBigTuple(n));
 // END OF CURVE FIELDS
@@ -887,17 +950,21 @@ const isogenyMapG1 = isogenyMap(

 // SWU Map - Fp2 to G2': y² = x³ + 240i * x + 1012 + 1012i
 const G2_SWU = mapToCurveSimpleSWU(Fp2, {
-  A: Fp2.create({ c0: Fp.create(0n), c1: Fp.create(240n) }), // A' = 240 * I
+  A: Fp2.create({ c0: Fp.create(_0n), c1: Fp.create(240n) }), // A' = 240 * I
  B: Fp2.create({ c0: Fp.create(1012n), c1: Fp.create(1012n) }), // B' = 1012 * (1 + I)
  Z: Fp2.create({ c0: Fp.create(-2n), c1: Fp.create(-1n) }), // Z: -(2 + I)
 });
 // Optimized SWU Map - Fp to G1
 const G1_SWU = mapToCurveSimpleSWU(Fp, {
  A: Fp.create(
-    0x144698a3b8e9433d693a02c96d4982b0ea985383ee66a8d8e8981aefd881ac98936f8da0e0f97f5cf428082d584c1dn
+    BigInt(
+      '0x144698a3b8e9433d693a02c96d4982b0ea985383ee66a8d8e8981aefd881ac98936f8da0e0f97f5cf428082d584c1d'
+    )
  ),
  B: Fp.create(
-    0x12e2908d11688030018b12e8753eee3b2016c1f0f24f4070a0b9c14fcef35ef55a23215a316ceaa5d1cc48e98e172be0n
+    BigInt(
+      '0x12e2908d11688030018b12e8753eee3b2016c1f0f24f4070a0b9c14fcef35ef55a23215a316ceaa5d1cc48e98e172be0'
+    )
  ),
  Z: Fp.create(11n),
 });
@@ -922,8 +989,9 @@ function G2psi(c: ProjConstructor<Fp2>, P: ProjPointType<Fp2>) {
 }
 // Ψ²(P) endomorphism
 // 1 / F2(2)^((p-1)/3) in GF(p²)
-const PSI2_C1 =
-  0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaacn;
+const PSI2_C1 = BigInt(
+  '0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac'
+);

 function psi2(x: Fp2, y: Fp2): [Fp2, Fp2] {
  return [Fp2.mul(x, PSI2_C1), Fp2.neg(y)];
@@ -1000,14 +1068,18 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
  G1: {
    Fp,
    // cofactor; (z - 1)²/3
-    h: 0x396c8c005555e1568c00aaab0000aaabn,
+    h: BigInt('0x396c8c005555e1568c00aaab0000aaab'),
    // generator's coordinates
    // x = 3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507
    // y = 1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569
-    Gx: 0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bbn,
-    Gy: 0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1n,
+    Gx: BigInt(
+      '0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb'
+    ),
+    Gy: BigInt(
+      '0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af600db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1'
+    ),
    a: Fp.ZERO,
-    b: 4n,
+    b: _4n,
    htfDefaults: { ...htfDefaults, m: 1 },
    wrapPrivateKey: true,
    allowInfinityPoint: true,
@@ -1017,8 +1089,9 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
    // https://eprint.iacr.org/2021/1130.pdf
    isTorsionFree: (c, point): boolean => {
      // φ endomorphism
-      const cubicRootOfUnityModP =
-        0x5f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffen;
+      const cubicRootOfUnityModP = BigInt(
+        '0x5f19672fdf76ce51ba69c6076a0f77eaddb3a93be6f89688de17d813620a00022e01fffffffefffe'
+      );
      const phi = new c(Fp.mul(point.px, cubicRootOfUnityModP), point.py, point.pz);

      // todo: unroll
@@ -1028,7 +1101,7 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({

      // https://eprint.iacr.org/2019/814.pdf
      // (z² − 1)/3
-      // const c1 = 0x396c8c005555e1560000000055555555n;
+      // const c1 = BigInt('0x396c8c005555e1560000000055555555');
      // const P = this;
      // const S = P.sigma();
      // const Q = S.double();
@@ -1054,13 +1127,13 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        const compressedValue = bytesToNumberBE(bytes);
        const bflag = bitGet(compressedValue, I_BIT_POS);
        // Zero
-        if (bflag === 1n) return { x: 0n, y: 0n };
+        if (bflag === _1n) return { x: _0n, y: _0n };
        const x = Fp.create(compressedValue & Fp.MASK);
-        const right = Fp.add(Fp.pow(x, 3n), Fp.create(bls12_381.CURVE.G1.b)); // y² = x³ + b
+        const right = Fp.add(Fp.pow(x, _3n), Fp.create(bls12_381.CURVE.G1.b)); // y² = x³ + b
        let y = Fp.sqrt(right);
        if (!y) throw new Error('Invalid compressed G1 point');
        const aflag = bitGet(compressedValue, C_BIT_POS);
-        if ((y * 2n) / P !== aflag) y = Fp.neg(y);
+        if ((y * _2n) / P !== aflag) y = Fp.neg(y);
        return { x: Fp.create(x), y: Fp.create(y) };
      } else if (bytes.length === 96) {
        // Check if the infinity flag is set
@@ -1079,7 +1152,7 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        if (isZero) return COMPRESSED_ZERO.slice();
        const P = Fp.ORDER;
        let num;
-        num = bitSet(x, C_BIT_POS, Boolean((y * 2n) / P)); // set aflag
+        num = bitSet(x, C_BIT_POS, Boolean((y * _2n) / P)); // set aflag
        num = bitSet(num, S_BIT_POS, true);
        return numberToBytesBE(num, Fp.BYTES);
      } else {
@@ -1100,21 +1173,33 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
  G2: {
    Fp: Fp2,
    // cofactor
-    h: 0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5n,
+    h: BigInt(
+      '0x5d543a95414e7f1091d50792876a202cd91de4547085abaa68a205b2e5a7ddfa628f1cb4d9e82ef21537e293a6691ae1616ec6e786f0c70cf1c38e31c7238e5'
+    ),
    Gx: Fp2.fromBigTuple([
-      0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8n,
-      0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7en,
+      BigInt(
+        '0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8'
+      ),
+      BigInt(
+        '0x13e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e'
+      ),
    ]),
    // y =
    // 927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582,
    // 1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905
    Gy: Fp2.fromBigTuple([
-      0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801n,
-      0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79ben,
+      BigInt(
+        '0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a76d429a695160d12c923ac9cc3baca289e193548608b82801'
+      ),
+      BigInt(
+        '0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be'
+      ),
    ]),
    a: Fp2.ZERO,
-    b: Fp2.fromBigTuple([4n, 4n]),
-    hEff: 0xbc69f08f2ee75b3584c6a0ea91b352888e2a8e9145ad7689986ff031508ffe1329c2f178731db956d82bf015d1212b02ec0ec69d7477c1ae954cbc06689f6a359894c0adebbf6b4e8020005aaa95551n,
+    b: Fp2.fromBigTuple([4n, _4n]),
+    hEff: BigInt(
+      '0xbc69f08f2ee75b3584c6a0ea91b352888e2a8e9145ad7689986ff031508ffe1329c2f178731db956d82bf015d1212b02ec0ec69d7477c1ae954cbc06689f6a359894c0adebbf6b4e8020005aaa95551'
+    ),
    htfDefaults: { ...htfDefaults },
    wrapPrivateKey: true,
    allowInfinityPoint: true,
@@ -1175,9 +1260,9 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        const x_1 = slc(bytes, 0, L);
        const x_0 = slc(bytes, L, 2 * L);
        const x = Fp2.create({ c0: Fp.create(x_0), c1: Fp.create(x_1) });
-        const right = Fp2.add(Fp2.pow(x, 3n), b); // y² = x³ + 4 * (u+1) = x³ + b
+        const right = Fp2.add(Fp2.pow(x, _3n), b); // y² = x³ + 4 * (u+1) = x³ + b
        let y = Fp2.sqrt(right);
-        const Y_bit = y.c1 === 0n ? (y.c0 * 2n) / P : (y.c1 * 2n) / P ? 1n : 0n;
+        const Y_bit = y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P ? _1n : _0n;
        y = bitS > 0 && Y_bit > 0 ? y : Fp2.neg(y);
        return { x, y };
      } else if (bytes.length === 192 && !bitC) {
@@ -1200,7 +1285,7 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
      if (isCompressed) {
        const P = Fp.ORDER;
        if (isZero) return concatB(COMPRESSED_ZERO, numberToBytesBE(0n, Fp.BYTES));
-        const flag = Boolean(y.c1 === 0n ? (y.c0 * 2n) / P : (y.c1 * 2n) / P);
+        const flag = Boolean(y.c1 === _0n ? (y.c0 * _2n) / P : (y.c1 * _2n) / P);
        // set compressed & sign bits (looks like different offsets than for G1/Fp?)
        let x_1 = bitSet(x.c1, C_BIT_POS, flag);
        x_1 = bitSet(x_1, S_BIT_POS, true);
@@ -1229,12 +1314,12 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        const z2 = bytesToNumberBE(hex.slice(half));
        // Indicates the infinity point
        const bflag1 = bitGet(z1, I_BIT_POS);
-        if (bflag1 === 1n) return bls12_381.G2.ProjectivePoint.ZERO;
+        if (bflag1 === _1n) return bls12_381.G2.ProjectivePoint.ZERO;

        const x1 = Fp.create(z1 & Fp.MASK);
        const x2 = Fp.create(z2);
        const x = Fp2.create({ c0: x2, c1: x1 });
-        const y2 = Fp2.add(Fp2.pow(x, 3n), bls12_381.CURVE.G2.b); // y² = x³ + 4
+        const y2 = Fp2.add(Fp2.pow(x, _3n), bls12_381.CURVE.G2.b); // y² = x³ + 4
        // The slow part
        let y = Fp2.sqrt(y2);
        if (!y) throw new Error('Failed to find a square root');
@@ -1243,8 +1328,8 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        // If y1 happens to be zero, then use the bit of y0
        const { re: y0, im: y1 } = Fp2.reim(y);
        const aflag1 = bitGet(z1, 381);
-        const isGreater = y1 > 0n && (y1 * 2n) / P !== aflag1;
-        const isZero = y1 === 0n && (y0 * 2n) / P !== aflag1;
+        const isGreater = y1 > _0n && (y1 * _2n) / P !== aflag1;
+        const isZero = y1 === _0n && (y0 * _2n) / P !== aflag1;
        if (isGreater || isZero) y = Fp2.neg(y);
        const point = bls12_381.G2.ProjectivePoint.fromAffine({ x, y });
        point.assertValidity();
@@ -1258,8 +1343,8 @@ export const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12> = bls({
        const a = point.toAffine();
        const { re: x0, im: x1 } = Fp2.reim(a.x);
        const { re: y0, im: y1 } = Fp2.reim(a.y);
-        const tmp = y1 > 0n ? y1 * 2n : y0 * 2n;
-        const aflag1 = Boolean((tmp / Fp.ORDER) & 1n);
+        const tmp = y1 > _0n ? y1 * _2n : y0 * _2n;
+        const aflag1 = Boolean((tmp / Fp.ORDER) & _1n);
        const z1 = bitSet(bitSet(x1, 381, aflag1), S_BIT_POS, true);
        const z2 = x0;
        return concatB(numberToBytesBE(z1, Fp.BYTES), numberToBytesBE(z2, Fp.BYTES));
--- a/src/bn.ts
+++ b/src/bn.ts
@@ -2,7 +2,7 @@
 import { sha256 } from '@noble/hashes/sha256';
 import { weierstrass } from './abstract/weierstrass.js';
 import { getHash } from './_shortw_utils.js';
-import { Fp } from './abstract/modular.js';
+import { Field } from './abstract/modular.js';
 /**
 * bn254 pairing-friendly curve.
 * Previously known as alt_bn_128, when it had 128-bit security.
@@ -12,7 +12,7 @@ import { Fp } from './abstract/modular.js';
 export const bn254 = weierstrass({
  a: BigInt(0),
  b: BigInt(3),
-  Fp: Fp(BigInt('0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47')),
+  Fp: Field(BigInt('0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47')),
  n: BigInt('0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001'),
  Gx: BigInt(1),
  Gy: BigInt(2),
--- a/src/ed25519.ts
+++ b/src/ed25519.ts
@@ -3,7 +3,7 @@ import { sha512 } from '@noble/hashes/sha512';
 import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
 import { twistedEdwards, ExtPointType } from './abstract/edwards.js';
 import { montgomery } from './abstract/montgomery.js';
-import { mod, pow2, isNegativeLE, Fp as Field, FpSqrtEven } from './abstract/modular.js';
+import { mod, pow2, isNegativeLE, Field, FpSqrtEven } from './abstract/modular.js';
 import {
  equalBytes,
  bytesToHex,
@@ -204,7 +204,7 @@ function map_to_curve_elligator2_curve25519(u: bigint) {
  let y = Fp.cmov(y2, y1, e3);  //  36.   y = CMOV(y2, y1, e3)    # If e3, y = y1, else y = y2
  let e4 = Fp.isOdd(y);         //  37.  e4 = sgn0(y) == 1        # Fix sign of y
  y = Fp.cmov(y, Fp.neg(y), e3 !== e4); //  38.   y = CMOV(y, -y, e3 XOR e4)
-  return { xMn: xn, xMd: xd, yMn: y, yMd: 1n }; //  39. return (xn, xd, y, 1)
+  return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; //  39. return (xn, xd, y, 1)
 }

 const ELL2_C1_EDWARDS = FpSqrtEven(Fp, Fp.neg(BigInt(486664))); // sgn0(c1) MUST equal 0
--- a/src/ed448.ts
+++ b/src/ed448.ts
@@ -2,7 +2,7 @@
 import { shake256 } from '@noble/hashes/sha3';
 import { concatBytes, randomBytes, utf8ToBytes, wrapConstructor } from '@noble/hashes/utils';
 import { twistedEdwards } from './abstract/edwards.js';
-import { mod, pow2, Fp as Field } from './abstract/modular.js';
+import { mod, pow2, Field } from './abstract/modular.js';
 import { montgomery } from './abstract/montgomery.js';
 import * as htf from './abstract/hash-to-curve.js';

@@ -54,6 +54,7 @@ function adjustScalarBytes(bytes: Uint8Array): Uint8Array {
 }

 const Fp = Field(ed448P, 456, true);
+const _4n = BigInt(4);

 const ED448_DEF = {
  // Param: a
@@ -195,10 +196,10 @@ function map_to_curve_elligator2_edwards448(u: bigint) {
  xEn = Fp.mul(xEn, xd2); // 9.  xEn = xEn * xd2
  xEn = Fp.mul(xEn, yd); // 10. xEn = xEn * yd
  xEn = Fp.mul(xEn, yn); // 11. xEn = xEn * yn
-  xEn = Fp.mul(xEn, 4n); // 12. xEn = xEn * 4
+  xEn = Fp.mul(xEn, _4n); // 12. xEn = xEn * 4
  tv2 = Fp.mul(tv2, xn2); // 13. tv2 = tv2 * xn2
  tv2 = Fp.mul(tv2, yd2); // 14. tv2 = tv2 * yd2
-  let tv3 = Fp.mul(yn2, 4n); // 15. tv3 = 4 * yn2
+  let tv3 = Fp.mul(yn2, _4n); // 15. tv3 = 4 * yn2
  let tv1 = Fp.add(tv3, yd2); // 16. tv1 = tv3 + yd2
  tv1 = Fp.mul(tv1, xd4); // 17. tv1 = tv1 * xd4
  let xEd = Fp.add(tv1, tv2); // 18. xEd = tv1 + tv2
--- a/src/jubjub.ts
+++ b/src/jubjub.ts
@@ -3,7 +3,7 @@ import { sha512 } from '@noble/hashes/sha512';
 import { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';
 import { twistedEdwards } from './abstract/edwards.js';
 import { blake2s } from '@noble/hashes/blake2s';
-import { Fp } from './abstract/modular.js';
+import { Field } from './abstract/modular.js';

 /**
 * jubjub Twisted Edwards curve.
@@ -17,7 +17,7 @@ export const jubjub = twistedEdwards({
  d: BigInt('0x2a9318e74bfa2b48f5fd9207e6bd7fd4292d7f6d37579d2601065fd6d6343eb1'),
  // Finite field 𝔽p over which we'll do calculations
  // Same value as bls12-381 Fr (not Fp)
-  Fp: Fp(BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001')),
+  Fp: Field(BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001')),
  // Subgroup order: how many points curve has
  n: BigInt('0xe7db4ea6533afa906673b0101343b00a6682093ccc81082d0970e5ed6f72cb7'),
  // Cofactor
--- a/src/p256.ts
+++ b/src/p256.ts
@@ -1,7 +1,7 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { createCurve } from './_shortw_utils.js';
 import { sha256 } from '@noble/hashes/sha256';
-import { Fp as Field } from './abstract/modular.js';
+import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 import * as htf from './abstract/hash-to-curve.js';

--- a/src/p384.ts
+++ b/src/p384.ts
@@ -1,7 +1,7 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { createCurve } from './_shortw_utils.js';
 import { sha384 } from '@noble/hashes/sha512';
-import { Fp as Field } from './abstract/modular.js';
+import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 import * as htf from './abstract/hash-to-curve.js';

--- a/src/p521.ts
+++ b/src/p521.ts
@@ -1,7 +1,7 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { createCurve } from './_shortw_utils.js';
 import { sha512 } from '@noble/hashes/sha512';
-import { Fp as Field } from './abstract/modular.js';
+import { Field } from './abstract/modular.js';
 import { mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 import * as htf from './abstract/hash-to-curve.js';

--- a/src/pasta.ts
+++ b/src/pasta.ts
@@ -11,7 +11,7 @@ export const q = BigInt('0x40000000000000000000000000000000224698fc0994a8dd8c46e
 export const pallas = weierstrass({
  a: BigInt(0),
  b: BigInt(5),
-  Fp: mod.Fp(p),
+  Fp: mod.Field(p),
  n: q,
  Gx: mod.mod(BigInt(-1), p),
  Gy: BigInt(2),
@@ -22,7 +22,7 @@ export const pallas = weierstrass({
 export const vesta = weierstrass({
  a: BigInt(0),
  b: BigInt(5),
-  Fp: mod.Fp(q),
+  Fp: mod.Field(q),
  n: p,
  Gx: mod.mod(BigInt(-1), q),
  Gy: BigInt(2),
--- a/src/secp256k1.ts
+++ b/src/secp256k1.ts
@@ -1,7 +1,7 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { sha256 } from '@noble/hashes/sha256';
 import { randomBytes } from '@noble/hashes/utils';
-import { Fp as Field, mod, pow2 } from './abstract/modular.js';
+import { Field, mod, pow2 } from './abstract/modular.js';
 import { ProjPointType as PointType, mapToCurveSimpleSWU } from './abstract/weierstrass.js';
 import type { Hex, PrivKey } from './abstract/utils.js';
 import { bytesToNumberBE, concatBytes, ensureBytes, numberToBytesBE } from './abstract/utils.js';
@@ -43,7 +43,6 @@ function sqrtMod(y: bigint): bigint {
 }

 const Fp = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
-type Fp = bigint;

 export const secp256k1 = createCurve(
  {
@@ -132,7 +131,7 @@ function lift_x(x: bigint): PointType<bigint> {
  const xx = modP(x * x);
  const c = modP(xx * x + BigInt(7)); // Let c = x³ + 7 mod p.
  let y = sqrtMod(c); // Let y = c^(p+1)/4 mod p.
-  if (y % 2n !== 0n) y = modP(-y); // Return the unique point P such that x(P) = x and
+  if (y % _2n !== _0n) y = modP(-y); // Return the unique point P such that x(P) = x and
  const p = new Point(x, y, _1n); // y(P) = y if y mod 2 = 0 or y(P) = p-y otherwise.
  p.assertValidity();
  return p;
@@ -245,7 +244,7 @@ const isoMap = htf.isogenyMap(
      '0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f',
      '0x0000000000000000000000000000000000000000000000000000000000000001', // LAST 1
    ],
-  ].map((i) => i.map((j) => BigInt(j))) as [Fp[], Fp[], Fp[], Fp[]]
+  ].map((i) => i.map((j) => BigInt(j))) as [bigint[], bigint[], bigint[], bigint[]]
 );
 const mapSWU = mapToCurveSimpleSWU(Fp, {
  A: BigInt('0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533'),
--- a/src/stark.ts
+++ b/src/stark.ts
@@ -1,341 +0,0 @@
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { keccak_256 } from '@noble/hashes/sha3';
-import { sha256 } from '@noble/hashes/sha256';
-import { utf8ToBytes } from '@noble/hashes/utils';
-import { Fp, mod, Field, validateField } from './abstract/modular.js';
-import { poseidon } from './abstract/poseidon.js';
-import { weierstrass, ProjPointType, SignatureType } from './abstract/weierstrass.js';
-import * as u from './abstract/utils.js';
-import type { Hex } from './abstract/utils.js';
-import { getHash } from './_shortw_utils.js';
-
-// Stark-friendly elliptic curve
-// https://docs.starkware.co/starkex/stark-curve.html
-
-type ProjectivePoint = ProjPointType<bigint>;
-const CURVE_ORDER = BigInt(
-  '3618502788666131213697322783095070105526743751716087489154079457884512865583'
-);
-const nBitLength = 252;
-function bits2int(bytes: Uint8Array): bigint {
-  while (bytes[0] === 0) bytes = bytes.subarray(1); // strip leading 0s
-  // Copy-pasted from weierstrass.ts
-  const delta = bytes.length * 8 - nBitLength;
-  const num = u.bytesToNumberBE(bytes);
-  return delta > 0 ? num >> BigInt(delta) : num;
-}
-function hex0xToBytes(hex: string): Uint8Array {
-  if (typeof hex === 'string') {
-    hex = strip0x(hex); // allow 0x prefix
-    if (hex.length & 1) hex = '0' + hex; // allow unpadded hex
-  }
-  return u.hexToBytes(hex);
-}
-const curve = weierstrass({
-  a: BigInt(1), // Params: a, b
-  b: BigInt('3141592653589793238462643383279502884197169399375105820974944592307816406665'),
-  // Field over which we'll do calculations; 2n**251n + 17n * 2n**192n + 1n
-  // There is no efficient sqrt for field (P%4==1)
-  Fp: Fp(BigInt('0x800000000000011000000000000000000000000000000000000000000000001')),
-  n: CURVE_ORDER, // Curve order, total count of valid points in the field.
-  nBitLength, // len(bin(N).replace('0b',''))
-  // Base point (x, y) aka generator point
-  Gx: BigInt('874739451078007766457464989774322083649278607533249481151382481072868806602'),
-  Gy: BigInt('152666792071518830868575557812948353041420400780739481342941381225525861407'),
-  h: BigInt(1), // cofactor
-  lowS: false, // Allow high-s signatures
-  ...getHash(sha256),
-  // Custom truncation routines for stark curve
-  bits2int,
-  bits2int_modN: (bytes: Uint8Array): bigint => {
-    // 2102820b232636d200cb21f1d330f20d096cae09d1bf3edb1cc333ddee11318 =>
-    // 2102820b232636d200cb21f1d330f20d096cae09d1bf3edb1cc333ddee113180
-    const hex = u.bytesToNumberBE(bytes).toString(16); // toHex unpadded
-    if (hex.length === 63) bytes = hex0xToBytes(hex + '0'); // append trailing 0
-    return mod(bits2int(bytes), CURVE_ORDER);
-  },
-});
-export const _starkCurve = curve;
-
-function ensureBytes(hex: Hex): Uint8Array {
-  return u.ensureBytes('', typeof hex === 'string' ? hex0xToBytes(hex) : hex);
-}
-
-function normPrivKey(privKey: Hex): string {
-  return u.bytesToHex(ensureBytes(privKey)).padStart(64, '0');
-}
-export function getPublicKey(privKey: Hex, isCompressed = false): Uint8Array {
-  return curve.getPublicKey(normPrivKey(privKey), isCompressed);
-}
-export function getSharedSecret(privKeyA: Hex, pubKeyB: Hex): Uint8Array {
-  return curve.getSharedSecret(normPrivKey(privKeyA), pubKeyB);
-}
-export function sign(msgHash: Hex, privKey: Hex, opts?: any): SignatureType {
-  return curve.sign(ensureBytes(msgHash), normPrivKey(privKey), opts);
-}
-export function verify(signature: SignatureType | Hex, msgHash: Hex, pubKey: Hex) {
-  const sig = signature instanceof Signature ? signature : ensureBytes(signature);
-  return curve.verify(sig, ensureBytes(msgHash), ensureBytes(pubKey));
-}
-
-const { CURVE, ProjectivePoint, Signature, utils } = curve;
-export { CURVE, ProjectivePoint, Signature, utils };
-
-function extractX(bytes: Uint8Array): string {
-  const hex = u.bytesToHex(bytes.subarray(1));
-  const stripped = hex.replace(/^0+/gm, ''); // strip leading 0s
-  return `0x${stripped}`;
-}
-function strip0x(hex: string) {
-  return hex.replace(/^0x/i, '');
-}
-function numberTo0x16(num: bigint) {
-  // can't use utils.numberToHexUnpadded: adds leading 0 for even byte length
-  return `0x${num.toString(16)}`;
-}
-
-// seed generation
-export function grindKey(seed: Hex) {
-  const _seed = ensureBytes(seed);
-  const sha256mask = 2n ** 256n;
-  const limit = sha256mask - mod(sha256mask, CURVE_ORDER);
-  for (let i = 0; ; i++) {
-    const key = sha256Num(u.concatBytes(_seed, u.numberToVarBytesBE(BigInt(i))));
-    if (key < limit) return mod(key, CURVE_ORDER).toString(16); // key should be in [0, limit)
-    if (i === 100000) throw new Error('grindKey is broken: tried 100k vals'); // prevent dos
-  }
-}
-
-export function getStarkKey(privateKey: Hex): string {
-  return extractX(getPublicKey(privateKey, true));
-}
-
-export function ethSigToPrivate(signature: string): string {
-  signature = strip0x(signature);
-  if (signature.length !== 130) throw new Error('Wrong ethereum signature');
-  return grindKey(signature.substring(0, 64));
-}
-
-const MASK_31 = 2n ** 31n - 1n;
-const int31 = (n: bigint) => Number(n & MASK_31);
-export function getAccountPath(
-  layer: string,
-  application: string,
-  ethereumAddress: string,
-  index: number
-): string {
-  const layerNum = int31(sha256Num(layer));
-  const applicationNum = int31(sha256Num(application));
-  const eth = u.hexToNumber(strip0x(ethereumAddress));
-  return `m/2645'/${layerNum}'/${applicationNum}'/${int31(eth)}'/${int31(eth >> 31n)}'/${index}`;
-}
-
-// https://docs.starkware.co/starkex/pedersen-hash-function.html
-const PEDERSEN_POINTS = [
-  new ProjectivePoint(
-    2089986280348253421170679821480865132823066470938446095505822317253594081284n,
-    1713931329540660377023406109199410414810705867260802078187082345529207694986n,
-    1n
-  ),
-  new ProjectivePoint(
-    996781205833008774514500082376783249102396023663454813447423147977397232763n,
-    1668503676786377725805489344771023921079126552019160156920634619255970485781n,
-    1n
-  ),
-  new ProjectivePoint(
-    2251563274489750535117886426533222435294046428347329203627021249169616184184n,
-    1798716007562728905295480679789526322175868328062420237419143593021674992973n,
-    1n
-  ),
-  new ProjectivePoint(
-    2138414695194151160943305727036575959195309218611738193261179310511854807447n,
-    113410276730064486255102093846540133784865286929052426931474106396135072156n,
-    1n
-  ),
-  new ProjectivePoint(
-    2379962749567351885752724891227938183011949129833673362440656643086021394946n,
-    776496453633298175483985398648758586525933812536653089401905292063708816422n,
-    1n
-  ),
-];
-
-function pedersenPrecompute(p1: ProjectivePoint, p2: ProjectivePoint): ProjectivePoint[] {
-  const out: ProjectivePoint[] = [];
-  let p = p1;
-  for (let i = 0; i < 248; i++) {
-    out.push(p);
-    p = p.double();
-  }
-  // NOTE: we cannot use wNAF here, because last 4 bits will require full 248 bits multiplication
-  // We can add support for this to wNAF, but it will complicate wNAF.
-  p = p2;
-  for (let i = 0; i < 4; i++) {
-    out.push(p);
-    p = p.double();
-  }
-  return out;
-}
-const PEDERSEN_POINTS1 = pedersenPrecompute(PEDERSEN_POINTS[1], PEDERSEN_POINTS[2]);
-const PEDERSEN_POINTS2 = pedersenPrecompute(PEDERSEN_POINTS[3], PEDERSEN_POINTS[4]);
-
-type PedersenArg = Hex | bigint | number;
-function pedersenArg(arg: PedersenArg): bigint {
-  let value: bigint;
-  if (typeof arg === 'bigint') {
-    value = arg;
-  } else if (typeof arg === 'number') {
-    if (!Number.isSafeInteger(arg)) throw new Error(`Invalid pedersenArg: ${arg}`);
-    value = BigInt(arg);
-  } else {
-    value = u.bytesToNumberBE(ensureBytes(arg));
-  }
-  if (!(0n <= value && value < curve.CURVE.Fp.ORDER))
-    throw new Error(`PedersenArg should be 0 <= value < CURVE.P: ${value}`); // [0..Fp)
-  return value;
-}
-
-function pedersenSingle(point: ProjectivePoint, value: PedersenArg, constants: ProjectivePoint[]) {
-  let x = pedersenArg(value);
-  for (let j = 0; j < 252; j++) {
-    const pt = constants[j];
-    if (pt.equals(point)) throw new Error('Same point');
-    if ((x & 1n) !== 0n) point = point.add(pt);
-    x >>= 1n;
-  }
-  return point;
-}
-
-// shift_point + x_low * P_0 + x_high * P1 + y_low * P2  + y_high * P3
-export function pedersen(x: PedersenArg, y: PedersenArg): string {
-  let point: ProjectivePoint = PEDERSEN_POINTS[0];
-  point = pedersenSingle(point, x, PEDERSEN_POINTS1);
-  point = pedersenSingle(point, y, PEDERSEN_POINTS2);
-  return extractX(point.toRawBytes(true));
-}
-
-export function hashChain(data: PedersenArg[], fn = pedersen) {
-  if (!Array.isArray(data) || data.length < 1)
-    throw new Error('data should be array of at least 1 element');
-  if (data.length === 1) return numberTo0x16(pedersenArg(data[0]));
-  return Array.from(data)
-    .reverse()
-    .reduce((acc, i) => fn(i, acc));
-}
-// Same as hashChain, but computes hash even for single element and order is not revesed
-export const computeHashOnElements = (data: PedersenArg[], fn = pedersen) =>
-  [0, ...data, data.length].reduce((x, y) => fn(x, y));
-
-const MASK_250 = u.bitMask(250);
-export const keccak = (data: Uint8Array): bigint => u.bytesToNumberBE(keccak_256(data)) & MASK_250;
-const sha256Num = (data: Uint8Array | string): bigint => u.bytesToNumberBE(sha256(data));
-
-// Poseidon hash
-export const Fp253 = Fp(
-  BigInt('14474011154664525231415395255581126252639794253786371766033694892385558855681')
-); // 2^253 + 2^199 + 1
-export const Fp251 = Fp(
-  BigInt('3618502788666131213697322783095070105623107215331596699973092056135872020481')
-); // 2^251 + 17 * 2^192 + 1
-
-function poseidonRoundConstant(Fp: Field<bigint>, name: string, idx: number) {
-  const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
-  return Fp.create(val);
-}
-
-// NOTE: doesn't check eiginvalues and possible can create unsafe matrix. But any filtration here will break compatibility with starknet
-// Please use only if you really know what you doing.
-// https://eprint.iacr.org/2019/458.pdf Section 2.3 (Avoiding Insecure Matrices)
-export function _poseidonMDS(Fp: Field<bigint>, name: string, m: number, attempt = 0) {
-  const x_values: bigint[] = [];
-  const y_values: bigint[] = [];
-  for (let i = 0; i < m; i++) {
-    x_values.push(poseidonRoundConstant(Fp, `${name}x`, attempt * m + i));
-    y_values.push(poseidonRoundConstant(Fp, `${name}y`, attempt * m + i));
-  }
-  if (new Set([...x_values, ...y_values]).size !== 2 * m)
-    throw new Error('X and Y values are not distinct');
-  return x_values.map((x) => y_values.map((y) => Fp.inv(Fp.sub(x, y))));
-}
-
-const MDS_SMALL = [
-  [3, 1, 1],
-  [1, -1, 1],
-  [1, 1, -2],
-].map((i) => i.map(BigInt));
-
-export type PoseidonOpts = {
-  Fp: Field<bigint>;
-  rate: number;
-  capacity: number;
-  roundsFull: number;
-  roundsPartial: number;
-};
-
-export type PoseidonFn = ReturnType<typeof poseidon> & {
-  m: number;
-  rate: number;
-  capacity: number;
-};
-
-export function poseidonBasic(opts: PoseidonOpts, mds: bigint[][]): PoseidonFn {
-  validateField(opts.Fp);
-  if (!Number.isSafeInteger(opts.rate) || !Number.isSafeInteger(opts.capacity))
-    throw new Error(`Wrong poseidon opts: ${opts}`);
-  const m = opts.rate + opts.capacity;
-  const rounds = opts.roundsFull + opts.roundsPartial;
-  const roundConstants = [];
-  for (let i = 0; i < rounds; i++) {
-    const row = [];
-    for (let j = 0; j < m; j++) row.push(poseidonRoundConstant(opts.Fp, 'Hades', m * i + j));
-    roundConstants.push(row);
-  }
-  const res: Partial<PoseidonFn> = poseidon({
-    ...opts,
-    t: m,
-    sboxPower: 3,
-    reversePartialPowIdx: true, // Why?!
-    mds,
-    roundConstants,
-  });
-  res.m = m;
-  res.rate = opts.rate;
-  res.capacity = opts.capacity;
-  return res as PoseidonFn;
-}
-
-export function poseidonCreate(opts: PoseidonOpts, mdsAttempt = 0) {
-  const m = opts.rate + opts.capacity;
-  if (!Number.isSafeInteger(mdsAttempt)) throw new Error(`Wrong mdsAttempt=${mdsAttempt}`);
-  return poseidonBasic(opts, _poseidonMDS(opts.Fp, 'HadesMDS', m, mdsAttempt));
-}
-
-export const poseidonSmall = poseidonBasic(
-  { Fp: Fp251, rate: 2, capacity: 1, roundsFull: 8, roundsPartial: 83 },
-  MDS_SMALL
-);
-
-export function poseidonHash(x: bigint, y: bigint, fn = poseidonSmall): bigint {
-  return fn([x, y, 2n])[0];
-}
-
-export function poseidonHashFunc(x: Uint8Array, y: Uint8Array, fn = poseidonSmall): Uint8Array {
-  return u.numberToVarBytesBE(poseidonHash(u.bytesToNumberBE(x), u.bytesToNumberBE(y), fn));
-}
-
-export function poseidonHashSingle(x: bigint, fn = poseidonSmall): bigint {
-  return fn([x, 0n, 1n])[0];
-}
-
-export function poseidonHashMany(values: bigint[], fn = poseidonSmall): bigint {
-  const { m, rate } = fn;
-  if (!Array.isArray(values)) throw new Error('bigint array expected in values');
-  const padded = Array.from(values); // copy
-  padded.push(1n);
-  while (padded.length % rate !== 0) padded.push(0n);
-  let state: bigint[] = new Array(m).fill(0n);
-  for (let i = 0; i < padded.length; i += rate) {
-    for (let j = 0; j < rate; j++) state[j] += padded[i + j];
-    state = fn(state);
-  }
-  return state[0];
-}
--- a/test/_more-curves.helpers.js
+++ b/test/_more-curves.helpers.js
@@ -1,7 +1,7 @@
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-import { createCurve } from '../_shortw_utils.js';
+import { createCurve } from '../esm/_shortw_utils.js';
 import { sha224, sha256 } from '@noble/hashes/sha256';
-import { Fp } from '../abstract/modular.js';
+import { Field as Fp } from '../esm/abstract/modular.js';

 // NIST secp192r1 aka P192
 // https://www.secg.org/sec2-v2.pdf, https://neuromancer.sk/std/secg/secp192r1
--- a/test/_poseidon.helpers.js
+++ b/test/_poseidon.helpers.js
@@ -0,0 +1,103 @@
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { sha256 } from '@noble/hashes/sha256';
+import { utf8ToBytes } from '@noble/hashes/utils';
+import { Field as Fp, validateField } from '../esm/abstract/modular.js';
+import { poseidon } from '../esm/abstract/poseidon.js';
+import * as u from '../esm/abstract/utils.js';
+
+// Poseidon hash https://docs.starkware.co/starkex/stark-curve.html
+export const Fp253 = Fp(
+  BigInt('14474011154664525231415395255581126252639794253786371766033694892385558855681')
+); // 2^253 + 2^199 + 1
+export const Fp251 = Fp(
+  BigInt('3618502788666131213697322783095070105623107215331596699973092056135872020481')
+); // 2^251 + 17 * 2^192 + 1
+
+function poseidonRoundConstant(Fp, name, idx) {
+  const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
+  return Fp.create(val);
+}
+
+// NOTE: doesn't check eiginvalues and possible can create unsafe matrix. But any filtration here will break compatibility with starknet
+// Please use only if you really know what you doing.
+// https://eprint.iacr.org/2019/458.pdf Section 2.3 (Avoiding Insecure Matrices)
+export function _poseidonMDS(Fp, name, m, attempt = 0) {
+  const x_values = [];
+  const y_values = [];
+  for (let i = 0; i < m; i++) {
+    x_values.push(poseidonRoundConstant(Fp, `${name}x`, attempt * m + i));
+    y_values.push(poseidonRoundConstant(Fp, `${name}y`, attempt * m + i));
+  }
+  if (new Set([...x_values, ...y_values]).size !== 2 * m)
+    throw new Error('X and Y values are not distinct');
+  return x_values.map((x) => y_values.map((y) => Fp.inv(Fp.sub(x, y))));
+}
+
+const MDS_SMALL = [
+  [3, 1, 1],
+  [1, -1, 1],
+  [1, 1, -2],
+].map((i) => i.map(BigInt));
+
+export function poseidonBasic(opts, mds) {
+  validateField(opts.Fp);
+  if (!Number.isSafeInteger(opts.rate) || !Number.isSafeInteger(opts.capacity))
+    throw new Error(`Wrong poseidon opts: ${opts}`);
+  const m = opts.rate + opts.capacity;
+  const rounds = opts.roundsFull + opts.roundsPartial;
+  const roundConstants = [];
+  for (let i = 0; i < rounds; i++) {
+    const row = [];
+    for (let j = 0; j < m; j++) row.push(poseidonRoundConstant(opts.Fp, 'Hades', m * i + j));
+    roundConstants.push(row);
+  }
+  const res = poseidon({
+    ...opts,
+    t: m,
+    sboxPower: 3,
+    reversePartialPowIdx: true, // Why?!
+    mds,
+    roundConstants,
+  });
+  res.m = m;
+  res.rate = opts.rate;
+  res.capacity = opts.capacity;
+  return res;
+}
+
+export function poseidonCreate(opts, mdsAttempt = 0) {
+  const m = opts.rate + opts.capacity;
+  if (!Number.isSafeInteger(mdsAttempt)) throw new Error(`Wrong mdsAttempt=${mdsAttempt}`);
+  return poseidonBasic(opts, _poseidonMDS(opts.Fp, 'HadesMDS', m, mdsAttempt));
+}
+
+export const poseidonSmall = poseidonBasic(
+  { Fp: Fp251, rate: 2, capacity: 1, roundsFull: 8, roundsPartial: 83 },
+  MDS_SMALL
+);
+
+export function poseidonHash(x, y, fn = poseidonSmall) {
+  return fn([x, y, 2n])[0];
+}
+
+export function poseidonHashFunc(x, y, fn = poseidonSmall) {
+  return u.numberToVarBytesBE(poseidonHash(u.bytesToNumberBE(x), u.bytesToNumberBE(y), fn));
+}
+
+export function poseidonHashSingle(x, fn = poseidonSmall) {
+  return fn([x, 0n, 1n])[0];
+}
+
+export function poseidonHashMany(values, fn = poseidonSmall) {
+  const { m, rate } = fn;
+  if (!Array.isArray(values)) throw new Error('bigint array expected in values');
+  const padded = Array.from(values); // copy
+  padded.push(1n);
+  while (padded.length % rate !== 0) padded.push(0n);
+  let state = new Array(m).fill(0n);
+  for (let i = 0; i < padded.length; i += rate) {
+    for (let j = 0; j < rate; j++) state[j] += padded[i + j];
+    state = fn(state);
+  }
+  return state[0];
+}
--- a/test/basic.test.js
+++ b/test/basic.test.js
@@ -1,21 +1,20 @@
 import { deepStrictEqual, throws } from 'assert';
 import { should, describe } from 'micro-should';
 import * as fc from 'fast-check';
-import * as mod from '../abstract/modular.js';
-import { bytesToHex as toHex } from '../abstract/utils.js';
+import * as mod from '../esm/abstract/modular.js';
+import { bytesToHex as toHex } from '../esm/abstract/utils.js';
 // Generic tests for all curves in package
 import { secp192r1, secp224r1 } from './_more-curves.helpers.js';
-import { secp256r1 } from '../p256.js';
-import { secp384r1 } from '../p384.js';
-import { secp521r1 } from '../p521.js';
-import { secp256k1 } from '../secp256k1.js';
-import { ed25519, ed25519ctx, ed25519ph, x25519 } from '../ed25519.js';
-import { ed448, ed448ph } from '../ed448.js';
-import { _starkCurve as starkCurve } from '../stark.js';
-import { pallas, vesta } from '../pasta.js';
-import { bn254 } from '../bn.js';
-import { jubjub } from '../jubjub.js';
-import { bls12_381 } from '../bls12-381.js';
+import { secp256r1 } from '../esm/p256.js';
+import { secp384r1 } from '../esm/p384.js';
+import { secp521r1 } from '../esm/p521.js';
+import { secp256k1 } from '../esm/secp256k1.js';
+import { ed25519, ed25519ctx, ed25519ph, x25519 } from '../esm/ed25519.js';
+import { ed448, ed448ph } from '../esm/ed448.js';
+import { pallas, vesta } from '../esm/pasta.js';
+import { bn254 } from '../esm/bn.js';
+import { jubjub } from '../esm/jubjub.js';
+import { bls12_381 } from '../esm/bls12-381.js';

 // Fields tests
 const FIELDS = {
@@ -24,7 +23,6 @@ const FIELDS = {
  secp256r1: { Fp: [secp256r1.CURVE.Fp] },
  secp521r1: { Fp: [secp521r1.CURVE.Fp] },
  secp256k1: { Fp: [secp256k1.CURVE.Fp] },
-  stark: { Fp: [starkCurve.CURVE.Fp] },
  jubjub: { Fp: [jubjub.CURVE.Fp] },
  ed25519: { Fp: [ed25519.CURVE.Fp] },
  ed448: { Fp: [ed448.CURVE.Fp] },
@@ -314,7 +312,6 @@ const CURVES = {
  secp256k1,
  ed25519, ed25519ctx, ed25519ph,
  ed448, ed448ph,
-  starkCurve,
  pallas, vesta,
  bn254,
  jubjub,
@@ -556,6 +553,7 @@ for (const name in CURVES) {
    });
  }
  describe(name, () => {
+    if (['bn254', 'pallas', 'vesta'].includes(name)) return;
    // Generic complex things (getPublicKey/sign/verify/getSharedSecret)
    should('.getPublicKey() type check', () => {
      throws(() => C.getPublicKey(0), '0');
--- a/test/bls12-381.test.js
+++ b/test/bls12-381.test.js
@@ -2,10 +2,10 @@ import { deepStrictEqual, notDeepStrictEqual, throws } from 'assert';
 import * as fc from 'fast-check';
 import { readFileSync } from 'fs';
 import { describe, should } from 'micro-should';
-import { wNAF } from '../abstract/curve.js';
-import { bytesToHex, utf8ToBytes } from '../abstract/utils.js';
-import { hash_to_field } from '../abstract/hash-to-curve.js';
-import { bls12_381 as bls } from '../bls12-381.js';
+import { wNAF } from '../esm/abstract/curve.js';
+import { bytesToHex, utf8ToBytes } from '../esm/abstract/utils.js';
+import { hash_to_field } from '../esm/abstract/hash-to-curve.js';
+import { bls12_381 as bls } from '../esm/bls12-381.js';

 import zkVectors from './bls12-381/zkcrypto/converted.json' assert { type: 'json' };
 import pairingVectors from './bls12-381/go_pairing_vectors/pairing.json' assert { type: 'json' };
--- a/test/ed25519-addons.test.js
+++ b/test/ed25519-addons.test.js
@@ -2,9 +2,9 @@ import { sha512 } from '@noble/hashes/sha512';
 import { hexToBytes, bytesToHex, randomBytes } from '@noble/hashes/utils';
 import { deepStrictEqual, strictEqual, throws } from 'assert';
 import { describe, should } from 'micro-should';
-import { bytesToNumberLE, numberToBytesLE } from '../abstract/utils.js';
+import { bytesToNumberLE, numberToBytesLE } from '../esm/abstract/utils.js';
 import { default as x25519vectors } from './wycheproof/x25519_test.json' assert { type: 'json' };
-import { ed25519ctx, ed25519ph, RistrettoPoint, x25519 } from '../ed25519.js';
+import { ed25519ctx, ed25519ph, RistrettoPoint, x25519 } from '../esm/ed25519.js';

 // const ed = ed25519;
 const hex = bytesToHex;
--- a/test/ed25519.helpers.js
+++ b/test/ed25519.helpers.js
@@ -1 +1 @@
-export { ed25519, ED25519_TORSION_SUBGROUP } from '../ed25519.js';
+export { ed25519, ED25519_TORSION_SUBGROUP } from '../esm/ed25519.js';
--- a/test/ed448.test.js
+++ b/test/ed448.test.js
@@ -1,9 +1,9 @@
 import { deepStrictEqual, throws } from 'assert';
 import { describe, should } from 'micro-should';
 import * as fc from 'fast-check';
-import { ed448, ed448ph, x448 } from '../ed448.js';
+import { ed448, ed448ph, x448 } from '../esm/ed448.js';
 import { hexToBytes, bytesToHex, randomBytes } from '@noble/hashes/utils';
-import { numberToBytesLE } from '../abstract/utils.js';
+import { numberToBytesLE } from '../esm/abstract/utils.js';
 import { default as ed448vectors } from './wycheproof/ed448_test.json' assert { type: 'json' };
 import { default as x448vectors } from './wycheproof/x448_test.json' assert { type: 'json' };

--- a/test/hash-to-curve.test.js
+++ b/test/hash-to-curve.test.js
@@ -5,15 +5,15 @@ import { bytesToHex } from '@noble/hashes/utils';
 import { sha256 } from '@noble/hashes/sha256';
 import { sha512 } from '@noble/hashes/sha512';
 import { shake128, shake256 } from '@noble/hashes/sha3';
-import * as secp256r1 from '../p256.js';
-import * as secp384r1 from '../p384.js';
-import * as secp521r1 from '../p521.js';
-import * as ed25519 from '../ed25519.js';
-import * as ed448 from '../ed448.js';
-import * as secp256k1 from '../secp256k1.js';
-import { bls12_381 } from '../bls12-381.js';
-import { expand_message_xmd, expand_message_xof } from '../abstract/hash-to-curve.js';
-import { utf8ToBytes } from '../abstract/utils.js';
+import * as secp256r1 from '../esm/p256.js';
+import * as secp384r1 from '../esm/p384.js';
+import * as secp521r1 from '../esm/p521.js';
+import * as ed25519 from '../esm/ed25519.js';
+import * as ed448 from '../esm/ed448.js';
+import * as secp256k1 from '../esm/secp256k1.js';
+import { bls12_381 } from '../esm/bls12-381.js';
+import { expand_message_xmd, expand_message_xof } from '../esm/abstract/hash-to-curve.js';
+import { utf8ToBytes } from '../esm/abstract/utils.js';
 // XMD
 import { default as xmd_sha256_38 } from './hash-to-curve/expand_message_xmd_SHA256_38.json' assert { type: 'json' };
 import { default as xmd_sha256_256 } from './hash-to-curve/expand_message_xmd_SHA256_256.json' assert { type: 'json' };
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -7,9 +7,9 @@ import './ed448.test.js';
 import './ed25519.test.js';
 import './secp256k1.test.js';
 import './secp256k1-schnorr.test.js';
-import './stark/index.test.js';
 import './jubjub.test.js';
-import './bls12-381.test.js';
 import './hash-to-curve.test.js';
+import './poseidon.test.js';
+import './bls12-381.test.js';

 should.run();
--- a/test/jubjub.test.js
+++ b/test/jubjub.test.js
@@ -1,4 +1,4 @@
-import { jubjub, findGroupHash } from '../jubjub.js';
+import { jubjub, findGroupHash } from '../esm/jubjub.js';
 import { describe, should } from 'micro-should';
 import { deepStrictEqual, throws } from 'assert';
 const Point = jubjub.ExtendedPoint;
--- a/test/nist.test.js
+++ b/test/nist.test.js
@@ -1,11 +1,11 @@
 import { deepStrictEqual } from 'assert';
 import { describe, should } from 'micro-should';
 import { secp192r1, secp224r1, P192, P224 } from './_more-curves.helpers.js';
-import { secp256r1, P256 } from '../p256.js';
-import { secp384r1, P384 } from '../p384.js';
-import { secp521r1, P521 } from '../p521.js';
-import { secp256k1 } from '../secp256k1.js';
-import { hexToBytes, bytesToHex } from '../abstract/utils.js';
+import { secp256r1, P256 } from '../esm/p256.js';
+import { secp384r1, P384 } from '../esm/p384.js';
+import { secp521r1, P521 } from '../esm/p521.js';
+import { secp256k1 } from '../esm/secp256k1.js';
+import { hexToBytes, bytesToHex } from '../esm/abstract/utils.js';
 import { default as ecdsa } from './wycheproof/ecdsa_test.json' assert { type: 'json' };
 import { default as ecdh } from './wycheproof/ecdh_test.json' assert { type: 'json' };
 import { default as rfc6979 } from './fixtures/rfc6979.json' assert { type: 'json' };
--- a/test/poseidon.test.js
+++ b/test/poseidon.test.js
@@ -1,8 +1,8 @@
 import { deepStrictEqual, throws } from 'assert';
 import { should, describe } from 'micro-should';
-import * as poseidon from '../abstract/poseidon.js';
-import * as stark from '../stark.js';
-import * as mod from '../abstract/modular.js';
+import * as poseidon from '../esm/abstract/poseidon.js';
+import * as stark from './_poseidon.helpers.js';
+import * as mod from '../esm/abstract/modular.js';
 import { default as pvectors } from './vectors/poseidon.json' assert { type: 'json' };
 const { st1, st2, st3, st4 } = pvectors;

@@ -132,7 +132,9 @@ describe('Stark', () => {
 // Official vectors: https://extgit.iaik.tugraz.at/krypto/hadeshash/-/blob/master/code/test_vectors.txt

 should('poseidonperm_x5_255_3', () => {
-  const Fp = mod.Fp(BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001'));
+  const Fp = mod.Field(
+    BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001')
+  );

  const mds = [
    [
@@ -179,7 +181,7 @@ should('poseidonperm_x5_255_3', () => {
 });

 should('poseidonperm_x5_255_5', () => {
-  const Fp = mod.Fp(0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n);
+  const Fp = mod.Field(0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n);
  const t = 5;

  const mds = [
@@ -250,7 +252,7 @@ should('poseidonperm_x5_255_5', () => {
 });

 should('poseidonperm_x5_254_3', () => {
-  const Fp = mod.Fp(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n);
+  const Fp = mod.Field(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n);
  const t = 3;

  const mds = [
@@ -297,7 +299,7 @@ should('poseidonperm_x5_254_3', () => {
 });

 should('poseidonperm_x5_254_5', () => {
-  const Fp = mod.Fp(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n);
+  const Fp = mod.Field(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n);
  const t = 5;

  const mds = [
--- a/test/secp256k1-schnorr.test.js
+++ b/test/secp256k1-schnorr.test.js
@@ -2,7 +2,7 @@ import { deepStrictEqual, throws } from 'assert';
 import { readFileSync } from 'fs';
 import { should, describe } from 'micro-should';
 import { bytesToHex as hex } from '@noble/hashes/utils';
-import { schnorr } from '../secp256k1.js';
+import { schnorr } from '../esm/secp256k1.js';
 const schCsv = readFileSync('./test/vectors/schnorr.csv', 'utf-8');

 describe('schnorr.sign()', () => {
--- a/test/secp256k1.helpers.js
+++ b/test/secp256k1.helpers.js
@@ -1,8 +1,8 @@
 // @ts-ignore
-export { secp256k1 as secp } from '../secp256k1.js';
-import { secp256k1 as _secp } from '../secp256k1.js';
-export { bytesToNumberBE, numberToBytesBE } from '../abstract/utils.js';
-export { mod } from '../abstract/modular.js';
+export { secp256k1 as secp } from '../esm/secp256k1.js';
+import { secp256k1 as _secp } from '../esm/secp256k1.js';
+export { bytesToNumberBE, numberToBytesBE } from '../esm/abstract/utils.js';
+export { mod } from '../esm/abstract/modular.js';
 export const sigFromDER = (der) => {
  return _secp.Signature.fromDER(der);
 };
--- a/test/stark/basic.test.js
+++ b/test/stark/basic.test.js
@@ -1,201 +0,0 @@
-import { deepStrictEqual, throws } from 'assert';
-import { describe, should } from 'micro-should';
-import * as starknet from '../../stark.js';
-import { default as issue2 } from './fixtures/issue2.json' assert { type: 'json' };
-import * as bip32 from '@scure/bip32';
-import * as bip39 from '@scure/bip39';
-
-describe('starknet basic', () => {
-  should('Basic elliptic sanity check', () => {
-    const g1 = starknet.ProjectivePoint.BASE;
-    deepStrictEqual(
-      g1.toAffine().x.toString(16),
-      '1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca'
-    );
-    deepStrictEqual(
-      g1.toAffine().y.toString(16),
-      '5668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f'
-    );
-    const g2 = g1.double();
-    deepStrictEqual(
-      g2.toAffine().x.toString(16),
-      '759ca09377679ecd535a81e83039658bf40959283187c654c5416f439403cf5'
-    );
-    deepStrictEqual(
-      g2.toAffine().y.toString(16),
-      '6f524a3400e7708d5c01a28598ad272e7455aa88778b19f93b562d7a9646c41'
-    );
-    const g3 = g2.add(g1);
-    deepStrictEqual(
-      g3.toAffine().x.toString(16),
-      '411494b501a98abd8262b0da1351e17899a0c4ef23dd2f96fec5ba847310b20'
-    );
-    deepStrictEqual(
-      g3.toAffine().y.toString(16),
-      '7e1b3ebac08924d2c26f409549191fcf94f3bf6f301ed3553e22dfb802f0686'
-    );
-    const g32 = g1.multiply(3n);
-    deepStrictEqual(
-      g32.toAffine().x.toString(16),
-      '411494b501a98abd8262b0da1351e17899a0c4ef23dd2f96fec5ba847310b20'
-    );
-    deepStrictEqual(
-      g32.toAffine().y.toString(16),
-      '7e1b3ebac08924d2c26f409549191fcf94f3bf6f301ed3553e22dfb802f0686'
-    );
-    const minus1 = g1.multiply(starknet.CURVE.n - 1n);
-    deepStrictEqual(
-      minus1.toAffine().x.toString(16),
-      '1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca'
-    );
-    deepStrictEqual(
-      minus1.toAffine().y.toString(16),
-      '7a997f9f55b68e04841b7fe20b9139d21ac132ee541bc5cd78cfff3c91723e2'
-    );
-  });
-
-  should('Pedersen', () => {
-    deepStrictEqual(
-      starknet.pedersen(2, 3),
-      '0x5774fa77b3d843ae9167abd61cf80365a9b2b02218fc2f628494b5bdc9b33b8'
-    );
-    deepStrictEqual(
-      starknet.pedersen(1, 2),
-      '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026'
-    );
-    deepStrictEqual(
-      starknet.pedersen(3, 4),
-      '0x262697b88544f733e5c6907c3e1763131e9f14c51ee7951258abbfb29415fbf'
-    );
-  });
-
-  should('Hash chain', () => {
-    deepStrictEqual(
-      starknet.hashChain([1, 2, 3]),
-      '0x5d9d62d4040b977c3f8d2389d494e4e89a96a8b45c44b1368f1cc6ec5418915'
-    );
-  });
-
-  should('Pedersen hash edgecases', () => {
-    // >>> pedersen_hash(0,0)
-    const zero = '0x49ee3eba8c1600700ee1b87eb599f16716b0b1022947733551fde4050ca6804';
-    deepStrictEqual(starknet.pedersen(0, 0), zero);
-    deepStrictEqual(starknet.pedersen(0n, 0n), zero);
-    deepStrictEqual(starknet.pedersen('0', '0'), zero);
-    deepStrictEqual(starknet.pedersen('0x0', '0x0'), zero);
-    // >>> pedersen_hash(3618502788666131213697322783095070105623107215331596699973092056135872020475,3618502788666131213697322783095070105623107215331596699973092056135872020475)
-    // 3226051580231087455100099637526672350308978851161639703631919449959447036451
-    const big = 3618502788666131213697322783095070105623107215331596699973092056135872020475n;
-    const bigExp = '0x721e167a36655994e88efa865e2ed8a0488d36db4d988fec043cda755728223';
-    deepStrictEqual(starknet.pedersen(big, big), bigExp);
-    // >= FIELD
-    const big2 = 36185027886661312136973227830950701056231072153315966999730920561358720204751n;
-    throws(() => starknet.pedersen(big2, big2), 'big2');
-
-    // FIELD -1
-    const big3 = 3618502788666131213697322783095070105623107215331596699973092056135872020480n;
-    const big3exp = '0x7258fccaf3371fad51b117471d9d888a1786c5694c3e6099160477b593a576e';
-    deepStrictEqual(starknet.pedersen(big3, big3), big3exp, 'big3');
-    // FIELD
-    const big4 = 3618502788666131213697322783095070105623107215331596699973092056135872020481n;
-    throws(() => starknet.pedersen(big4, big4), 'big4');
-    throws(() => starknet.pedersen(-1, -1), 'neg');
-    throws(() => starknet.pedersen(false, false), 'false');
-    throws(() => starknet.pedersen(true, true), 'true');
-    throws(() => starknet.pedersen(10.1, 10.1), 'float');
-  });
-
-  should('hashChain edgecases', () => {
-    deepStrictEqual(starknet.hashChain([32312321312321312312312321n]), '0x1aba6672c014b4838cc201');
-    deepStrictEqual(
-      starknet.hashChain([1n, 2n]),
-      '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026'
-    );
-    deepStrictEqual(
-      starknet.hashChain([1, 2]),
-      '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026'
-    );
-    throws(() => starknet.hashChain([]));
-    throws(() => starknet.hashChain('123'));
-    deepStrictEqual(
-      starknet.hashChain([1, 2]),
-      '0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026'
-    );
-  });
-
-  should('Pedersen hash, issue #2', () => {
-    // Verified with starnet.js
-    deepStrictEqual(
-      starknet.computeHashOnElements(issue2),
-      '0x22064462ea33a6ce5272a295e0f551c5da3834f80d8444e7a4df68190b1bc42'
-    );
-    deepStrictEqual(
-      starknet.computeHashOnElements([]),
-      '0x49ee3eba8c1600700ee1b87eb599f16716b0b1022947733551fde4050ca6804'
-    );
-    deepStrictEqual(
-      starknet.computeHashOnElements([1]),
-      '0x78d74f61aeaa8286418fd34b3a12a610445eba11d00ecc82ecac2542d55f7a4'
-    );
-  });
-
-
-  should('Seed derivation (example)', () => {
-    const layer = 'starkex';
-    const application = 'starkdeployement';
-    const mnemonic =
-      'range mountain blast problem vibrant void vivid doctor cluster enough melody ' +
-      'salt layer language laptop boat major space monkey unit glimpse pause change vibrant';
-    const ethAddress = '0xa4864d977b944315389d1765ffa7e66F74ee8cd7';
-    const hdKey = bip32.HDKey.fromMasterSeed(bip39.mnemonicToSeedSync(mnemonic)).derive(
-      starknet.getAccountPath(layer, application, ethAddress, 0)
-    );
-    deepStrictEqual(
-      starknet.grindKey(hdKey.privateKey),
-      '6cf0a8bf113352eb863157a45c5e5567abb34f8d32cddafd2c22aa803f4892c'
-    );
-  });
-
-  should('Compressed keys', () => {
-    const G = starknet.ProjectivePoint.BASE;
-    const half = starknet.CURVE.n / 2n;
-    const last = starknet.CURVE.n;
-    const vectors = [
-      1n,
-      2n,
-      3n,
-      4n,
-      5n,
-      half - 5n,
-      half - 4n,
-      half - 3n,
-      half - 2n,
-      half - 1n,
-      half,
-      half + 1n,
-      half + 2n,
-      half + 3n,
-      half + 4n,
-      half + 5n,
-      last - 5n,
-      last - 4n,
-      last - 3n,
-      last - 2n,
-      last - 1n,
-    ].map((i) => G.multiply(i));
-    const fixPoint = (pt) => pt.toAffine();
-    for (const v of vectors) {
-      const uncompressed = v.toHex();
-      const compressed = v.toHex(true);
-      const exp = fixPoint(v);
-      deepStrictEqual(fixPoint(starknet.ProjectivePoint.fromHex(uncompressed)), exp);
-      deepStrictEqual(fixPoint(starknet.ProjectivePoint.fromHex(compressed)), exp);
-      deepStrictEqual(starknet.ProjectivePoint.fromHex(compressed).toHex(), uncompressed);
-    }
-  });
-});
-// ESM is broken.
-import url from 'url';
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-  should.run();
-}
--- a/test/stark/benchmark/index.js
+++ b/test/stark/benchmark/index.js
@@ -1,57 +0,0 @@
-import * as microStark from '../../../stark.js';
-import * as starkwareCrypto from '@starkware-industries/starkware-crypto-utils';
-import * as bench from 'micro-bmark';
-const { run, mark } = bench; // or bench.mark
-
-const privateKey = '2dccce1da22003777062ee0870e9881b460a8b7eca276870f57c601f182136c';
-const msgHash = 'c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47';
-const keyPair = starkwareCrypto.default.ec.keyFromPrivate(privateKey, 'hex');
-const publicKeyStark = starkwareCrypto.default.ec.keyFromPublic(
-  keyPair.getPublic(true, 'hex'),
-  'hex'
-);
-const publicKeyMicro = microStark.getPublicKey(privateKey);
-
-const FNS = {
-  pedersenHash: {
-    samples: 250,
-    starkware: () =>
-      starkwareCrypto.default.pedersen([
-        '3d937c035c878245caf64531a5756109c53068da139362728feb561405371cb',
-        '208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a',
-      ]),
-    'micro-starknet': () =>
-      microStark.pedersen(
-        '3d937c035c878245caf64531a5756109c53068da139362728feb561405371cb',
-        '208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a'
-      ),
-  },
-  signVerify: {
-    samples: 500,
-    starkware: () =>
-      starkwareCrypto.default.verify(
-        publicKeyStark,
-        msgHash,
-        starkwareCrypto.default.sign(keyPair, msgHash)
-      ),
-    'micro-starknet': () =>
-      microStark.verify(microStark.sign(msgHash, privateKey), msgHash, publicKeyMicro),
-  },
-};
-
-const main = () =>
-  run(async () => {
-    for (let [k, libs] of Object.entries(FNS)) {
-      console.log(`==== ${k} ====`);
-      for (const [lib, fn] of Object.entries(libs)) {
-        if (lib === 'samples') continue;
-        let title = `${k} (${lib})`;
-        await mark(title, libs.samples, () => fn());
-      }
-      console.log();
-    }
-    // Log current RAM
-    bench.logMem();
-  });
-
-main();
--- a/test/stark/benchmark/package.json
+++ b/test/stark/benchmark/package.json
@@ -1,19 +0,0 @@
-{
-    "name": "benchmark",
-    "private": true,
-    "version": "0.1.0",
-    "description": "benchmarks",
-    "main": "index.js",
-    "type": "module",
-    "scripts": {
-        "bench": "node index.js"
-    },
-    "keywords": [],
-    "author": "",
-    "license": "MIT",
-    "devDependencies": {
-        "@starkware-industries/starkware-crypto-utils": "^0.0.2",
-        "micro-bmark": "0.2.0",
-        "micro-should": "0.2.0"
-    }
-}
--- a/test/stark/fixtures/issue2.json
+++ b/test/stark/fixtures/issue2.json
--- a/test/stark/fixtures/keys_precomputed.json
+++ b/test/stark/fixtures/keys_precomputed.json
@@ -1,32 +0,0 @@
-{
-    "0x1": "0x1ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca",
-    "0x2": "0x759ca09377679ecd535a81e83039658bf40959283187c654c5416f439403cf5",
-    "0x3": "0x411494b501a98abd8262b0da1351e17899a0c4ef23dd2f96fec5ba847310b20",
-    "0x4": "0xa7da05a4d664859ccd6e567b935cdfbfe3018c7771cb980892ef38878ae9bc",
-    "0x5": "0x788435d61046d3eec54d77d25bd194525f4fa26ebe6575536bc6f656656b74c",
-    "0x6": "0x1efc3d7c9649900fcbd03f578a8248d095bc4b6a13b3c25f9886ef971ff96fa",
-    "0x7": "0x743829e0a179f8afe223fc8112dfc8d024ab6b235fd42283c4f5970259ce7b7",
-    "0x8": "0x6eeee2b0c71d681692559735e08a2c3ba04e7347c0c18d4d49b83bb89771591",
-    "0x9": "0x216b4f076ff47e03a05032d1c6ee17933d8de8b2b4c43eb5ad5a7e1b25d3849",
-    "0x800000000000000000000000000000000000000000000000000000000000000": "0x5c79074e7f7b834c12c81a9bb0d46691a5e7517767a849d9d98cb84e2176ed2",
-    "0x800000000000000000000000000000000000000000000000000000000000001": "0x1c4f24e3bd16db0e2457bc005a9d61965105a535554c6b338871e34cb8e2d3a",
-    "0x800000000000000000000000000000000000000000000000000000000000002": "0xdfbb89b39288a9ddacf3942b4481b04d4fa2f8ed3c424757981cc6357f27ac",
-    "0x800000000000000000000000000000000000000000000000000000000000003": "0x41bef28265fd750b102f4f2d1e0231de7f4a33900a214f191a63d4fec4e72f4",
-    "0x800000000000000000000000000000000000000000000000000000000000004": "0x24de66eb164797d4b414e81ded0cfa1a592ef0a9363ebbcb440d4d03cb18af1",
-    "0x800000000000000000000000000000000000000000000000000000000000005": "0x5efb18c3bc9b69003746acc85fb6ee0cfbdc6adfb982f089cc63e1e5495daad",
-    "0x800000000000000000000000000000000000000000000000000000000000006": "0x10dc71f00918a8ebfe4085c834d41dd22b251b9f81eef8b9a4fab77e7e1afe9",
-    "0x800000000000000000000000000000000000000000000000000000000000007": "0x4267ebfd379b1c8caae73febc5920b0c95bd6f9f3536f47c5ddad1259c332ff",
-    "0x800000000000000000000000000000000000000000000000000000000000008": "0x6da515118c8e01fd5b2e96b814ee95bad7d60be4d2ba6b47e0d283f579d9671",
-    "0x800000000000000000000000000000000000000000000000000000000000009": "0x7a5b4797f4e56ed1473876bc2693fbe3f2fef7e050717cbae924ff23d426052",
-    "0x2e9c99d8382fa004dcbbee720aef8a97002de0e991f6a8344e6dc636a71b59e": "0x1ff6803ae740e7e596504ac5c6afbea472e53679361e214f12be0155b13e25d",
-    "0x8620458785138df8722214e073a91b8f55076ea78197cf41007692dd27fd90": "0x5967da40b90d7ca1e36dc4024381d7d4b403c6ac1a0ab358b0743984934a805",
-    "0x1b920e7dfb49ba5ada673882af5342e7448d3e9335e0ac37feb6280cd7289ce": "0x78c7ab46333968fbde3201cf512c1eeb5529360259072c459a158dee4449b57",
-    "0x704170dbfd5dc63caef69d2ce6dfc2b2dbb2af6e75851242bbe79fb6e62a118": "0x534bd8d6ebe4bb2f6992e2d7c19ef3146247e10c2849f357e44eddd283b2af6",
-    "0x4b58bf4228f39550eca59b5c96a0cb606036cc9495eef9a546f24f01b1b7829": "0x1097a8c5a46d94596f1c8e70ca66941f2bb11e3c8d4fd58fdc4589f09965be8",
-    "0x2e93226c90fb7a2381a24e940a94b98433e3553dcbf745d3f54d62963c75604": "0x369f0e8c8e984f244290267393a004dba435a4df091767ad5063fece7b1884c",
-    "0x4615f94598cd756ad1a551d7e57fd725916adfd0054eb773ceb482eef87d0b2": "0x1ee5b8d612102a2408cde59ce52a6498d2e38fe8789bb26d400dea310684ec9",
-    "0x6ade54b7debd7ca1d4e8e932f9545f8fa4024d73be1efcc86df86367fc333f8": "0x37de3bf52412b2fb9b0030d232ca9dd921cd8f71fd67975cdc62546826e121",
-    "0x618e7467dd24c2a3449c4df640439c12cdd0f8ea779afcee6e252b2cf494354": "0x71c2b578c432f2d305d3808bb645ecc46dd670cb43d4f4a076f75ccbff74fbc",
-    "0x7eae185e1f41ec76d214d763f0592f194933622a9dd5f3d52d0209f71619c1a": "0x2b0160052e70176e5b0ff2a6eff90896ae07b732fc27219e36e077735abd57e",
-    "0x178047D3869489C055D7EA54C014FFB834A069C9595186ABE04EA4D1223A03F": "0x1895a6a77ae14e7987b9cb51329a5adfb17bd8e7c638f92d6892d76e51cebcf"
-}
--- a/test/stark/fixtures/rfc6979_signature_test_vector.json
+++ b/test/stark/fixtures/rfc6979_signature_test_vector.json
@@ -1,57 +0,0 @@
-{
-  "private_key": "0x3c1e9550e66958296d11b60f8e8e7a7ad990d07fa65d5f7652c4a6c87d4e3cc",
-  "messages": [
-    {
-      "hash": "0x1",
-      "r": "3162358736122783857144396205516927012128897537504463716197279730251407200037",
-      "s": "1447067116407676619871126378936374427636662490882969509559888874644844560850"
-    },
-    {
-      "hash": "0x11",
-      "r": "2282960348362869237018441985726545922711140064809058182483721438101695251648",
-      "s": "2905868291002627709651322791912000820756370440695830310841564989426104902684"
-    },
-
-    {
-      "hash": "0x223",
-      "r": "2851492577225522862152785068304516872062840835882746625971400995051610132955",
-      "s": "2227464623243182122770469099770977514100002325017609907274766387592987135410"
-    },
-
-    {
-      "hash": "0x9999",
-      "r": "3551214266795401081823453828727326248401688527835302880992409448142527576296",
-      "s": "2580950807716503852408066180369610390914312729170066679103651110985466032285"
-    },
-
-    {
-      "hash": "0x387e76d1667c4454bfb835144120583af836f8e32a516765497d23eabe16b3f",
-      "r": "3518448914047769356425227827389998721396724764083236823647519654917215164512",
-      "s": "3042321032945513635364267149196358883053166552342928199041742035443537684462"
-    },
-
-    {
-      "hash": "0x3a7e76d1697c4455bfb835144120283af236f8e32a516765497d23eabe16b2",
-      "r": "2261926635950780594216378185339927576862772034098248230433352748057295357217",
-      "s": "2708700003762962638306717009307430364534544393269844487939098184375356178572"
-    },
-
-    {
-      "hash": "0xfa5f0cd1ebff93c9e6474379a213ba111f9e42f2f1cb361b0327e0737203",
-      "r": "3016953906936760149710218073693613509330129567629289734816320774638425763370",
-      "s": "306146275372136078470081798635201810092238376869367156373203048583896337506"
-    },
-
-    {
-      "hash": "0x4c1e9550e66958296d11b60f8e8e7f7ae99dd0cfa6bd5fa652c1a6c87d4e2cc",
-      "r": "3562728603055564208884290243634917206833465920158600288670177317979301056463",
-      "s": "1958799632261808501999574190111106370256896588537275453140683641951899459876"
-    },
-
-    {
-      "hash": "0x6362b40c218fb4c8a8bd42ca482145e8513b78e00faa0de76a98ba14fc37ae8",
-      "r": "3485557127492692423490706790022678621438670833185864153640824729109010175518",
-      "s": "897592218067946175671768586886915961592526001156186496738437723857225288280"
-    }
-  ]
-}
--- a/test/stark/index.test.js
+++ b/test/stark/index.test.js
@@ -1,11 +0,0 @@
-import { describe, should } from 'micro-should';
-import './basic.test.js';
-import './stark.test.js';
-import './property.test.js';
-import './poseidon.test.js';
-
-// ESM is broken.
-import url from 'url';
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-  should.run();
-}
--- a/test/stark/poseidon.test.js
+++ b/test/stark/poseidon.test.js
@@ -1,205 +0,0 @@
-import { deepStrictEqual, throws } from 'assert';
-import { describe, should } from 'micro-should';
-import * as starknet from '../../stark.js';
-import { bytesToHex as hex } from '@noble/hashes/utils';
-import * as fs from 'fs';
-
-function parseTest(path) {
-  let data = fs.readFileSync(path, 'ascii');
-  // Remove whitespaces
-  data = data.replace(/[ |\t]/g, '');
-  const pattern =
-    'Rate=(\\d+)\n' +
-    'Capacity=(\\d+)\n' +
-    'FullRounds=(\\d+)\n' +
-    'PartialRounds=(\\d+)\n' +
-    'MDS=\\[(.+)\\]\n' +
-    'RoundKeys=\\(?\n?\\[\n?(.+)\n?\\]\n?\\)?';
-  const r = data.match(new RegExp(pattern, 'ms'));
-
-  function parseArray(s) {
-    // Remove new lines
-    s = s.replace(/\n/gms, '');
-    return s.match(/(\[.+?\])/g).map((i) =>
-      i
-        .replace(/^\[(.+)\]$/, '$1')
-        .split(',')
-        .filter((i) => !!i)
-    );
-  }
-  const res = {
-    rate: +r[1],
-    capacity: +r[2],
-    roundsFull: +r[3],
-    roundsPartial: +r[4],
-    MDS: parseArray(r[5]).map((i) => i.map((j) => BigInt(j))),
-    roundConstants: parseArray(r[6]).map((i) => i.map((j) => BigInt(j))),
-  };
-  return res;
-}
-
-function mapPoseidon(parsed) {
-  return starknet.poseidonBasic(
-    {
-      Fp: starknet.Fp251,
-      rate: parsed.rate,
-      capacity: parsed.capacity,
-      roundsFull: parsed.roundsFull,
-      roundsPartial: parsed.roundsPartial,
-    },
-    parsed.MDS
-  );
-}
-
-const parsed = {
-  poseidon3: parseTest('./test/stark/poseidon/poseidon3.txt'),
-  poseidon4: parseTest('./test/stark/poseidon/poseidon4.txt'),
-  poseidon5: parseTest('./test/stark/poseidon/poseidon5.txt'),
-  poseidon9: parseTest('./test/stark/poseidon/poseidon9.txt'),
-};
-
-function poseidonTest(name, parsed) {
-  should(`${name}`, () => {
-    const fn = mapPoseidon(parsed);
-    deepStrictEqual(fn.roundConstants, parsed.roundConstants);
-  });
-}
-
-describe('poseidon txt vectors', () => {
-  poseidonTest('poseidon3', parsed.poseidon3);
-  poseidonTest('poseidon4', parsed.poseidon4);
-  poseidonTest('poseidon5', parsed.poseidon5);
-  poseidonTest('poseidon9', parsed.poseidon9);
-});
-
-should('Poseidon examples', () => {
-  const p3 = mapPoseidon(parsed.poseidon3);
-  deepStrictEqual(p3([0n, 0n, 0n]), [
-    3446325744004048536138401612021367625846492093718951375866996507163446763827n,
-    1590252087433376791875644726012779423683501236913937337746052470473806035332n,
-    867921192302518434283879514999422690776342565400001269945778456016268852423n,
-  ]);
-  const p4 = mapPoseidon(parsed.poseidon4);
-  deepStrictEqual(p4([0n, 0n, 0n, 0n]), [
-    535071095200566880914603862188010633478042591441142518549720701573192347548n,
-    3567335813488551850156302853280844225974867890860330236555401145692518003968n,
-    229995103310401763929738317978722680640995513996113588430855556460153357543n,
-    3513983790849716360905369754287999509206472929684378838050290392634812839312n,
-  ]);
-  const p5 = mapPoseidon(parsed.poseidon5);
-  deepStrictEqual(p5([0n, 0n, 0n, 0n, 0n]), [
-    2337689130971531876049206831496963607805116499042700598724344149414565980684n,
-    3230969295497815870174763682436655274044379544854667759151474216427142025631n,
-    3297330512217530111610698859408044542971696143761201570393504997742535648562n,
-    2585480844700786541432072704002477919020588246983274666988914431019064343941n,
-    3595308260654382824623573767385493361624474708214823462901432822513585995028n,
-  ]);
-  const p9 = mapPoseidon(parsed.poseidon9);
-  deepStrictEqual(p9([0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n]), [
-    1534116856660032929112709488204491699743182428465681149262739677337223235050n,
-    1710856073207389764546990138116985223517553616229641666885337928044617114700n,
-    3165864635055638516987240200217592641540231237468651257819894959934472989427n,
-    1003007637710164252047715558598366312649052908276423203724288341354608811559n,
-    68117303579957054409211824649914588822081700129416361923518488718489651489n,
-    1123395637839379807713801282868237406546107732595903195840754789810160564711n,
-    478590974834311070537087181212389392308746075734019180430422247431982932503n,
-    835322726024358888065061514739954009068852229059154336727219387089732433787n,
-    3129703030204995742174502162918848446737407262178341733578946634564864233056n,
-  ]);
-});
-
-should('Poseidon 2', () => {
-  // Cross-test with cairo-lang 0.11
-  deepStrictEqual(
-    starknet.poseidonHash(1n, 1n),
-    315729444126170353286530004158376771769107830460625027134495740547491428733n
-  );
-  deepStrictEqual(
-    starknet.poseidonHash(123n, 123n),
-    3149184350054566761517315875549307360045573205732410509163060794402900549639n
-  );
-  deepStrictEqual(
-    starknet.poseidonHash(1231231231231231231231231312312n, 1231231231231231231231231312312n),
-    2544250291965936388474000136445328679708604225006461780180655815882994563864n
-  );
-  // poseidonHashSingle
-  deepStrictEqual(
-    starknet.poseidonHashSingle(1n),
-    3085182978037364507644541379307921604860861694664657935759708330416374536741n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashSingle(123n),
-    2751345659320901472675327541550911744303539407817894466726181731796247467344n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashSingle(1231231231231231231231231312312n),
-    3083085683696942145160394401206391098729120397175152900096470498748103599322n
-  );
-  // poseidonHashMany
-  throws(() => starknet.poseidonHash(new Uint8Array([1, 2, 3])));
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n]),
-    154809849725474173771833689306955346864791482278938452209165301614543497938n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n]),
-    1557996165160500454210437319447297236715335099509187222888255133199463084263n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n]),
-    976552833909388839716191681593200982850734838655927116322079791360264131378n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n, 4n, 5n, 6n, 7n]),
-    1426681430756292883765769449684978541173830451959857824597431064948702170774n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n, 4n, 5n, 6n]),
-    3578895185591466904832617962452140411216018208734547126302182794057260630783n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n, 4n, 5n]),
-    2047942584693618630610564708884241243670450597197937863619828684896211911953n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n, 4n]),
-    717812721730784692894550948559585317289413466140233907962980309405694367376n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([1n, 2n, 3n, 4n, 5n, 6n, 7n, 8n, 9n, 1n, 2n, 3n]),
-    2926122208425648133778911655767364584769133265503722614793281770361723147648n
-  );
-  deepStrictEqual(
-    starknet.poseidonHashMany([
-      154809849725474173771833689306955346864791482278938452209165301614543497938n,
-      1557996165160500454210437319447297236715335099509187222888255133199463084263n,
-      976552833909388839716191681593200982850734838655927116322079791360264131378n,
-      1426681430756292883765769449684978541173830451959857824597431064948702170774n,
-      3578895185591466904832617962452140411216018208734547126302182794057260630783n,
-    ]),
-    1019392520709073131437410341528874594624843119359955302374885123884546721410n
-  );
-  // poseidon_hash_func
-  deepStrictEqual(
-    hex(starknet.poseidonHashFunc(new Uint8Array([1, 2]), new Uint8Array([3, 4]))),
-    '01f87cbb9c58139605384d0f0df49b446600af020aa9dac92301d45c96d78c0a'
-  );
-  deepStrictEqual(
-    hex(starknet.poseidonHashFunc(new Uint8Array(32).fill(255), new Uint8Array(32).fill(255))),
-    '05fd546b5ee3bcbbcbb733ed90bfc33033169d6765ac37bba71794a11cbb51a6'
-  );
-  deepStrictEqual(
-    hex(starknet.poseidonHashFunc(new Uint8Array(64).fill(255), new Uint8Array(64).fill(255))),
-    '07dba6b4d94b3e32697afe0825d6dac2dccafd439f7806a9575693c93735596b'
-  );
-  deepStrictEqual(
-    hex(starknet.poseidonHashFunc(new Uint8Array(256).fill(255), new Uint8Array(256).fill(255))),
-    '02f048581901865201dad701a5653d946b961748ec770fc11139aa7c06a9432a'
-  );
-});
-
-// ESM is broken.
-import url from 'url';
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-  should.run();
-}
--- a/test/stark/poseidon/LICENSE
+++ b/test/stark/poseidon/LICENSE
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/test/stark/poseidon/README.md
+++ b/test/stark/poseidon/README.md
@@ -1,35 +0,0 @@
-# StarkWare's Poseidon Hash
-
-[Poseidon](https://www.poseidon-hash.info/) is a family of hash functions designed for being very efficient as algebraic circuits.
-As such, they may be very useful in ZK proving systems such as STARKs and others.
-
-This repository provides the official parameters of StarkWare's Poseidon hash implementations.
-
-All the instances are over the prime field:
-p = 2^251 + 17 * 2^192 + 1 = 3618502788666131213697322783095070105623107215331596699973092056135872020481
-
-A few examples hash results with the different parameters:
-
-```
-Poseidon3([0,0,0]) = [3446325744004048536138401612021367625846492093718951375866996507163446763827,
-       1590252087433376791875644726012779423683501236913937337746052470473806035332,
-       867921192302518434283879514999422690776342565400001269945778456016268852423]
-Poseidon4([0,0,0,0]) = [535071095200566880914603862188010633478042591441142518549720701573192347548,
-       3567335813488551850156302853280844225974867890860330236555401145692518003968,
-       229995103310401763929738317978722680640995513996113588430855556460153357543,
-       3513983790849716360905369754287999509206472929684378838050290392634812839312]
-Poseidon5([0,0,0,0,0]) = [2337689130971531876049206831496963607805116499042700598724344149414565980684,
-       3230969295497815870174763682436655274044379544854667759151474216427142025631,
-       3297330512217530111610698859408044542971696143761201570393504997742535648562,
-       2585480844700786541432072704002477919020588246983274666988914431019064343941,
-       3595308260654382824623573767385493361624474708214823462901432822513585995028]
-Poseidon9([0,0,0,0,0,0,0,0,0]) = [1534116856660032929112709488204491699743182428465681149262739677337223235050,
-       1710856073207389764546990138116985223517553616229641666885337928044617114700,
-       3165864635055638516987240200217592641540231237468651257819894959934472989427,
-       1003007637710164252047715558598366312649052908276423203724288341354608811559,
-       68117303579957054409211824649914588822081700129416361923518488718489651489,
-       1123395637839379807713801282868237406546107732595903195840754789810160564711,
-       478590974834311070537087181212389392308746075734019180430422247431982932503,
-       835322726024358888065061514739954009068852229059154336727219387089732433787,
-       3129703030204995742174502162918848446737407262178341733578946634564864233056]
-```
--- a/test/stark/poseidon/poseidon3.txt
+++ b/test/stark/poseidon/poseidon3.txt
@@ -1,462 +0,0 @@
-Rate = 2
-Capacity = 1
-FullRounds = 8
-PartialRounds = 83
-MDS = [[3, 1, 1], [1, -1, 1], [1, 1, -2]]
-RoundKeys = [
-    [
-        2950795762459345168613727575620414179244544320470208355568817838579231751791,
-        1587446564224215276866294500450702039420286416111469274423465069420553242820,
-        1645965921169490687904413452218868659025437693527479459426157555728339600137,
-    ],
-    [
-        2782373324549879794752287702905278018819686065818504085638398966973694145741,
-        3409172630025222641379726933524480516420204828329395644967085131392375707302,
-        2379053116496905638239090788901387719228422033660130943198035907032739387135,
-    ],
-    [
-        2570819397480941104144008784293466051718826502582588529995520356691856497111,
-        3546220846133880637977653625763703334841539452343273304410918449202580719746,
-        2720682389492889709700489490056111332164748138023159726590726667539759963454,
-    ],
-    [
-        1899653471897224903834726250400246354200311275092866725547887381599836519005,
-        2369443697923857319844855392163763375394720104106200469525915896159690979559,
-        2354174693689535854311272135513626412848402744119855553970180659094265527996,
-    ],
-    [
-        2404084503073127963385083467393598147276436640877011103379112521338973185443,
-        950320777137731763811524327595514151340412860090489448295239456547370725376,
-        2121140748740143694053732746913428481442990369183417228688865837805149503386,
-    ],
-    [
-        2372065044800422557577242066480215868569521938346032514014152523102053709709,
-        2618497439310693947058545060953893433487994458443568169824149550389484489896,
-        3518297267402065742048564133910509847197496119850246255805075095266319996916,
-    ],
-    [
-        340529752683340505065238931581518232901634742162506851191464448040657139775,
-        1954876811294863748406056845662382214841467408616109501720437541211031966538,
-        813813157354633930267029888722341725864333883175521358739311868164460385261,
-    ],
-    [
-        71901595776070443337150458310956362034911936706490730914901986556638720031,
-        2789761472166115462625363403490399263810962093264318361008954888847594113421,
-        2628791615374802560074754031104384456692791616314774034906110098358135152410,
-    ],
-    [
-        3617032588734559635167557152518265808024917503198278888820567553943986939719,
-        2624012360209966117322788103333497793082705816015202046036057821340914061980,
-        149101987103211771991327927827692640556911620408176100290586418839323044234,
-    ],
-    [
-        1039927963829140138166373450440320262590862908847727961488297105916489431045,
-        2213946951050724449162431068646025833746639391992751674082854766704900195669,
-        2792724903541814965769131737117981991997031078369482697195201969174353468597,
-    ],
-    [
-        3212031629728871219804596347439383805499808476303618848198208101593976279441,
-        3343514080098703935339621028041191631325798327656683100151836206557453199613,
-        614054702436541219556958850933730254992710988573177298270089989048553060199,
-    ],
-    [
-        148148081026449726283933484730968827750202042869875329032965774667206931170,
-        1158283532103191908366672518396366136968613180867652172211392033571980848414,
-        1032400527342371389481069504520755916075559110755235773196747439146396688513,
-    ],
-    [
-        806900704622005851310078578853499250941978435851598088619290797134710613736,
-        462498083559902778091095573017508352472262817904991134671058825705968404510,
-        1003580119810278869589347418043095667699674425582646347949349245557449452503,
-    ],
-    [
-        619074932220101074089137133998298830285661916867732916607601635248249357793,
-        2635090520059500019661864086615522409798872905401305311748231832709078452746,
-        978252636251682252755279071140187792306115352460774007308726210405257135181,
-    ],
-    [
-        1766912167973123409669091967764158892111310474906691336473559256218048677083,
-        1663265127259512472182980890707014969235283233442916350121860684522654120381,
-        3532407621206959585000336211742670185380751515636605428496206887841428074250,
-    ],
-    [
-        2507023127157093845256722098502856938353143387711652912931112668310034975446,
-        3321152907858462102434883844787153373036767230808678981306827073335525034593,
-        3039253036806065280643845548147711477270022154459620569428286684179698125661,
-    ],
-    [
-        103480338868480851881924519768416587261556021758163719199282794248762465380,
-        2394049781357087698434751577708655768465803975478348134669006211289636928495,
-        2660531560345476340796109810821127229446538730404600368347902087220064379579,
-    ],
-    [
-        3603166934034556203649050570865466556260359798872408576857928196141785055563,
-        1553799760191949768532188139643704561532896296986025007089826672890485412324,
-        2744284717053657689091306578463476341218866418732695211367062598446038965164,
-    ],
-    [
-        320745764922149897598257794663594419839885234101078803811049904310835548856,
-        979382242100682161589753881721708883681034024104145498709287731138044566302,
-        1860426855810549882740147175136418997351054138609396651615467358416651354991,
-    ],
-    [
-        336173081054369235994909356892506146234495707857220254489443629387613956145,
-        1632470326779699229772327605759783482411227247311431865655466227711078175883,
-        921958250077481394074960433988881176409497663777043304881055317463712938502,
-    ],
-    [
-        3034358982193370602048539901033542101022185309652879937418114324899281842797,
-        25626282149517463867572353922222474817434101087272320606729439087234878607,
-        3002662261401575565838149305485737102400501329139562227180277188790091853682,
-    ],
-    [
-        2939684373453383817196521641512509179310654199629514917426341354023324109367,
-        1076484609897998179434851570277297233169621096172424141759873688902355505136,
-        2575095284833160494841112025725243274091830284746697961080467506739203605049,
-    ],
-    [
-        3565075264617591783581665711620369529657840830498005563542124551465195621851,
-        2197016502533303822395077038351174326125210255869204501838837289716363437993,
-        331415322883530754594261416546036195982886300052707474899691116664327869405,
-    ],
-    [
-        1935011233711290003793244296594669823169522055520303479680359990463281661839,
-        3495901467168087413996941216661589517270845976538454329511167073314577412322,
-        954195417117133246453562983448451025087661597543338750600301835944144520375,
-    ],
-    [
-        1271840477709992894995746871435810599280944810893784031132923384456797925777,
-        2565310762274337662754531859505158700827688964841878141121196528015826671847,
-        3365022288251637014588279139038152521653896670895105540140002607272936852513,
-    ],
-    [
-        1660592021628965529963974299647026602622092163312666588591285654477111176051,
-        970104372286014048279296575474974982288801187216974504035759997141059513421,
-        2617024574317953753849168721871770134225690844968986289121504184985993971227,
-    ],
-    [
-        999899815343607746071464113462778273556695659506865124478430189024755832262,
-        2228536129413411161615629030408828764980855956560026807518714080003644769896,
-        2701953891198001564547196795777701119629537795442025393867364730330476403227,
-    ],
-    [
-        837078355588159388741598313782044128527494922918203556465116291436461597853,
-        2121749601840466143704862369657561429793951309962582099604848281796392359214,
-        771812260179247428733132708063116523892339056677915387749121983038690154755,
-    ],
-    [
-        3317336423132806446086732225036532603224267214833263122557471741829060578219,
-        481570067997721834712647566896657604857788523050900222145547508314620762046,
-        242195042559343964206291740270858862066153636168162642380846129622127460192,
-    ],
-    [
-        2855462178889999218204481481614105202770810647859867354506557827319138379686,
-        3525521107148375040131784770413887305850308357895464453970651672160034885202,
-        1320839531502392535964065058804908871811967681250362364246430459003920305799,
-    ],
-    [
-        2514191518588387125173345107242226637171897291221681115249521904869763202419,
-        2798335750958827619666318316247381695117827718387653874070218127140615157902,
-        2808467767967035643407948058486565877867906577474361783201337540214875566395,
-    ],
-    [
-        3551834385992706206273955480294669176699286104229279436819137165202231595747,
-        1219439673853113792340300173186247996249367102884530407862469123523013083971,
-        761519904537984520554247997444508040636526566551719396202550009393012691157,
-    ],
-    [
-        3355402549169351700500518865338783382387571349497391475317206324155237401353,
-        199541098009731541347317515995192175813554789571447733944970283654592727138,
-        192100490643078165121235261796864975568292640203635147901612231594408079071,
-    ],
-    [
-        1187019357602953326192019968809486933768550466167033084944727938441427050581,
-        189525349641911362389041124808934468936759383310282010671081989585219065700,
-        2831653363992091308880573627558515686245403755586311978724025292003353336665,
-    ],
-    [
-        2052859812632218952608271535089179639890275494426396974475479657192657094698,
-        1670756178709659908159049531058853320846231785448204274277900022176591811072,
-        3538757242013734574731807289786598937548399719866320954894004830207085723125,
-    ],
-    [
-        710549042741321081781917034337800036872214466705318638023070812391485261299,
-        2345013122330545298606028187653996682275206910242635100920038943391319595180,
-        3528369671971445493932880023233332035122954362711876290904323783426765912206,
-    ],
-    [
-        1167120829038120978297497195837406760848728897181138760506162680655977700764,
-        3073243357129146594530765548901087443775563058893907738967898816092270628884,
-        378514724418106317738164464176041649567501099164061863402473942795977719726,
-    ],
-    [
-        333391138410406330127594722511180398159664250722328578952158227406762627796,
-        1727570175639917398410201375510924114487348765559913502662122372848626931905,
-        968312190621809249603425066974405725769739606059422769908547372904403793174,
-    ],
-    [
-        360659316299446405855194688051178331671817370423873014757323462844775818348,
-        1386580151907705298970465943238806620109618995410132218037375811184684929291,
-        3604888328937389309031638299660239238400230206645344173700074923133890528967,
-    ],
-    [
-        2496185632263372962152518155651824899299616724241852816983268163379540137546,
-        486538168871046887467737983064272608432052269868418721234810979756540672990,
-        1558415498960552213241704009433360128041672577274390114589014204605400783336,
-    ],
-    [
-        3512058327686147326577190314835092911156317204978509183234511559551181053926,
-        2235429387083113882635494090887463486491842634403047716936833563914243946191,
-        1290896777143878193192832813769470418518651727840187056683408155503813799882,
-    ],
-    [
-        1143310336918357319571079551779316654556781203013096026972411429993634080835,
-        3235435208525081966062419599803346573407862428113723170955762956243193422118,
-        1293239921425673430660897025143433077974838969258268884994339615096356996604,
-    ],
-    [
-        236252269127612784685426260840574970698541177557674806964960352572864382971,
-        1733907592497266237374827232200506798207318263912423249709509725341212026275,
-        302004309771755665128395814807589350526779835595021835389022325987048089868,
-    ],
-    [
-        3018926838139221755384801385583867283206879023218491758435446265703006270945,
-        39701437664873825906031098349904330565195980985885489447836580931425171297,
-        908381723021746969965674308809436059628307487140174335882627549095646509778,
-    ],
-    [
-        219062858908229855064136253265968615354041842047384625689776811853821594358,
-        1283129863776453589317845316917890202859466483456216900835390291449830275503,
-        418512623547417594896140369190919231877873410935689672661226540908900544012,
-    ],
-    [
-        1792181590047131972851015200157890246436013346535432437041535789841136268632,
-        370546432987510607338044736824316856592558876687225326692366316978098770516,
-        3323437805230586112013581113386626899534419826098235300155664022709435756946,
-    ],
-    [
-        910076621742039763058481476739499965761942516177975130656340375573185415877,
-        1762188042455633427137702520675816545396284185254002959309669405982213803405,
-        2186362253913140345102191078329764107619534641234549431429008219905315900520,
-    ],
-    [
-        2230647725927681765419218738218528849146504088716182944327179019215826045083,
-        1069243907556644434301190076451112491469636357133398376850435321160857761825,
-        2695241469149243992683268025359863087303400907336026926662328156934068747593,
-    ],
-    [
-        1361519681544413849831669554199151294308350560528931040264950307931824877035,
-        1339116632207878730171031743761550901312154740800549632983325427035029084904,
-        790593524918851401449292693473498591068920069246127392274811084156907468875,
-    ],
-    [
-        2723400368331924254840192318398326090089058735091724263333980290765736363637,
-        3457180265095920471443772463283225391927927225993685928066766687141729456030,
-        1483675376954327086153452545475557749815683871577400883707749788555424847954,
-    ],
-    [
-        2926303836265506736227240325795090239680154099205721426928300056982414025239,
-        543969119775473768170832347411484329362572550684421616624136244239799475526,
-        237401230683847084256617415614300816373730178313253487575312839074042461932,
-    ],
-    [
-        844568412840391587862072008674263874021460074878949862892685736454654414423,
-        151922054871708336050647150237534498235916969120198637893731715254687336644,
-        1299332034710622815055321547569101119597030148120309411086203580212105652312,
-    ],
-    [
-        487046922649899823989594814663418784068895385009696501386459462815688122993,
-        1104883249092599185744249485896585912845784382683240114120846423960548576851,
-        1458388705536282069567179348797334876446380557083422364875248475157495514484,
-    ],
-    [
-        850248109622750774031817200193861444623975329881731864752464222442574976566,
-        2885843173858536690032695698009109793537724845140477446409245651176355435722,
-        3027068551635372249579348422266406787688980506275086097330568993357835463816,
-    ],
-    [
-        3231892723647447539926175383213338123506134054432701323145045438168976970994,
-        1719080830641935421242626784132692936776388194122314954558418655725251172826,
-        1172253756541066126131022537343350498482225068791630219494878195815226839450,
-    ],
-    [
-        1619232269633026603732619978083169293258272967781186544174521481891163985093,
-        3495680684841853175973173610562400042003100419811771341346135531754869014567,
-        1576161515913099892951745452471618612307857113799539794680346855318958552758,
-    ],
-    [
-        2618326122974253423403350731396350223238201817594761152626832144510903048529,
-        2696245132758436974032479782852265185094623165224532063951287925001108567649,
-        930116505665110070247395429730201844026054810856263733273443066419816003444,
-    ],
-    [
-        2786389174502246248523918824488629229455088716707062764363111940462137404076,
-        1555260846425735320214671887347115247546042526197895180675436886484523605116,
-        2306241912153325247392671742757902161446877415586158295423293240351799505917,
-    ],
-    [
-        411529621724849932999694270803131456243889635467661223241617477462914950626,
-        1542495485262286701469125140275904136434075186064076910329015697714211835205,
-        1853045663799041100600825096887578544265580718909350942241802897995488264551,
-    ],
-    [
-        2963055259497271220202739837493041799968576111953080503132045092194513937286,
-        2303806870349915764285872605046527036748108533406243381676768310692344456050,
-        2622104986201990620910286730213140904984256464479840856728424375142929278875,
-    ],
-    [
-        2369987021925266811581727383184031736927816625797282287927222602539037105864,
-        285070227712021899602056480426671736057274017903028992288878116056674401781,
-        3034087076179360957800568733595959058628497428787907887933697691951454610691,
-    ],
-    [
-        469095854351700119980323115747590868855368701825706298740201488006320881056,
-        360001976264385426746283365024817520563236378289230404095383746911725100012,
-        3438709327109021347267562000879503009590697221730578667498351600602230296178,
-    ],
-    [
-        63573904800572228121671659287593650438456772568903228287754075619928214969,
-        3470881855042989871434874691030920672110111605547839662680968354703074556970,
-        724559311507950497340993415408274803001166693839947519425501269424891465492,
-    ],
-    [
-        880409284677518997550768549487344416321062350742831373397603704465823658986,
-        6876255662475867703077362872097208259197756317287339941435193538565586230,
-        2701916445133770775447884812906226786217969545216086200932273680400909154638,
-    ],
-    [
-        425152119158711585559310064242720816611629181537672850898056934507216982586,
-        1475552998258917706756737045704649573088377604240716286977690565239187213744,
-        2413772448122400684309006716414417978370152271397082147158000439863002593561,
-    ],
-    [
-        392160855822256520519339260245328807036619920858503984710539815951012864164,
-        1075036996503791536261050742318169965707018400307026402939804424927087093987,
-        2176439430328703902070742432016450246365760303014562857296722712989275658921,
-    ],
-    [
-        1413865976587623331051814207977382826721471106513581745229680113383908569693,
-        4879283427490523253696177116563427032332223531862961281430108575019551814,
-        3392583297537374046875199552977614390492290683707960975137418536812266544902,
-    ],
-    [
-        3600854486849487646325182927019642276644093512133907046667282144129939150983,
-        2779924664161372134024229593301361846129279572186444474616319283535189797834,
-        2722699960903170449291146429799738181514821447014433304730310678334403972040,
-    ],
-    [
-        819109815049226540285781191874507704729062681836086010078910930707209464699,
-        3046121243742768013822760785918001632929744274211027071381357122228091333823,
-        1339019590803056172509793134119156250729668216522001157582155155947567682278,
-    ],
-    [
-        1933279639657506214789316403763326578443023901555983256955812717638093967201,
-        2138221547112520744699126051903811860205771600821672121643894708182292213541,
-        2694713515543641924097704224170357995809887124438248292930846280951601597065,
-    ],
-    [
-        2471734202930133750093618989223585244499567111661178960753938272334153710615,
-        504903761112092757611047718215309856203214372330635774577409639907729993533,
-        1943979703748281357156510253941035712048221353507135074336243405478613241290,
-    ],
-    [
-        684525210957572142559049112233609445802004614280157992196913315652663518936,
-        1705585400798782397786453706717059483604368413512485532079242223503960814508,
-        192429517716023021556170942988476050278432319516032402725586427701913624665,
-    ],
-    [
-        1586493702243128040549584165333371192888583026298039652930372758731750166765,
-        686072673323546915014972146032384917012218151266600268450347114036285993377,
-        3464340397998075738891129996710075228740496767934137465519455338004332839215,
-    ],
-    [
-        2805249176617071054530589390406083958753103601524808155663551392362371834663,
-        667746464250968521164727418691487653339733392025160477655836902744186489526,
-        1131527712905109997177270289411406385352032457456054589588342450404257139778,
-    ],
-    [
-        1908969485750011212309284349900149072003218505891252313183123635318886241171,
-        1025257076985551890132050019084873267454083056307650830147063480409707787695,
-        2153175291918371429502545470578981828372846236838301412119329786849737957977,
-    ],
-    [
-        3410257749736714576487217882785226905621212230027780855361670645857085424384,
-        3442969106887588154491488961893254739289120695377621434680934888062399029952,
-        3029953900235731770255937704976720759948880815387104275525268727341390470237,
-    ],
-    [
-        85453456084781138713939104192561924536933417707871501802199311333127894466,
-        2730629666577257820220329078741301754580009106438115341296453318350676425129,
-        178242450661072967256438102630920745430303027840919213764087927763335940415,
-    ],
-    [
-        2844589222514708695700541363167856718216388819406388706818431442998498677557,
-        3547876269219141094308889387292091231377253967587961309624916269569559952944,
-        2525005406762984211707203144785482908331876505006839217175334833739957826850,
-    ],
-    [
-        3096397013555211396701910432830904669391580557191845136003938801598654871345,
-        574424067119200181933992948252007230348512600107123873197603373898923821490,
-        1714030696055067278349157346067719307863507310709155690164546226450579547098,
-    ],
-    [
-        2339895272202694698739231405357972261413383527237194045718815176814132612501,
-        3562501318971895161271663840954705079797767042115717360959659475564651685069,
-        69069358687197963617161747606993436483967992689488259107924379545671193749,
-    ],
-    [
-        2614502738369008850475068874731531583863538486212691941619835266611116051561,
-        655247349763023251625727726218660142895322325659927266813592114640858573566,
-        2305235672527595714255517865498269719545193172975330668070873705108690670678,
-    ],
-    [
-        926416070297755413261159098243058134401665060349723804040714357642180531931,
-        866523735635840246543516964237513287099659681479228450791071595433217821460,
-        2284334068466681424919271582037156124891004191915573957556691163266198707693,
-    ],
-    [
-        1812588309302477291425732810913354633465435706480768615104211305579383928792,
-        2836899808619013605432050476764608707770404125005720004551836441247917488507,
-        2989087789022865112405242078196235025698647423649950459911546051695688370523,
-    ],
-    [
-        68056284404189102136488263779598243992465747932368669388126367131855404486,
-        505425339250887519581119854377342241317528319745596963584548343662758204398,
-        2118963546856545068961709089296976921067035227488975882615462246481055679215,
-    ],
-    [
-        2253872596319969096156004495313034590996995209785432485705134570745135149681,
-        1625090409149943603241183848936692198923183279116014478406452426158572703264,
-        179139838844452470348634657368199622305888473747024389514258107503778442495,
-    ],
-    [
-        1567067018147735642071130442904093290030432522257811793540290101391210410341,
-        2737301854006865242314806979738760349397411136469975337509958305470398783585,
-        3002738216460904473515791428798860225499078134627026021350799206894618186256,
-    ],
-    [
-        374029488099466837453096950537275565120689146401077127482884887409712315162,
-        973403256517481077805460710540468856199855789930951602150773500862180885363,
-        2691967457038172130555117632010860984519926022632800605713473799739632878867,
-    ],
-    [
-        3515906794910381201365530594248181418811879320679684239326734893975752012109,
-        148057579455448384062325089530558091463206199724854022070244924642222283388,
-        1541588700238272710315890873051237741033408846596322948443180470429851502842,
-    ],
-    [
-        147013865879011936545137344076637170977925826031496203944786839068852795297,
-        2630278389304735265620281704608245039972003761509102213752997636382302839857,
-        1359048670759642844930007747955701205155822111403150159614453244477853867621,
-    ],
-    [
-        2438984569205812336319229336885480537793786558293523767186829418969842616677,
-        2137792255841525507649318539501906353254503076308308692873313199435029594138,
-        2262318076430740712267739371170174514379142884859595360065535117601097652755,
-    ],
-    [
-        2792703718581084537295613508201818489836796608902614779596544185252826291584,
-        2294173715793292812015960640392421991604150133581218254866878921346561546149,
-        2770011224727997178743274791849308200493823127651418989170761007078565678171,
-    ],
-]
--- a/test/stark/poseidon/poseidon4.txt
+++ b/test/stark/poseidon/poseidon4.txt
@@ -1,559 +0,0 @@
-Rate = 3
-Capacity = 1
-FullRounds = 8
-PartialRounds = 84
-MDS = [[2, 1, 1, 1], [1, 1, 1, 1], [1, 1, 0, 1], [1, 1, 1, -1]]
-RoundKeys = [
-    [
-        2950795762459345168613727575620414179244544320470208355568817838579231751791,
-        1587446564224215276866294500450702039420286416111469274423465069420553242820,
-        1645965921169490687904413452218868659025437693527479459426157555728339600137,
-        2782373324549879794752287702905278018819686065818504085638398966973694145741,
-    ],
-    [
-        3409172630025222641379726933524480516420204828329395644967085131392375707302,
-        2379053116496905638239090788901387719228422033660130943198035907032739387135,
-        2570819397480941104144008784293466051718826502582588529995520356691856497111,
-        3546220846133880637977653625763703334841539452343273304410918449202580719746,
-    ],
-    [
-        2720682389492889709700489490056111332164748138023159726590726667539759963454,
-        1899653471897224903834726250400246354200311275092866725547887381599836519005,
-        2369443697923857319844855392163763375394720104106200469525915896159690979559,
-        2354174693689535854311272135513626412848402744119855553970180659094265527996,
-    ],
-    [
-        2404084503073127963385083467393598147276436640877011103379112521338973185443,
-        950320777137731763811524327595514151340412860090489448295239456547370725376,
-        2121140748740143694053732746913428481442990369183417228688865837805149503386,
-        2372065044800422557577242066480215868569521938346032514014152523102053709709,
-    ],
-    [
-        2618497439310693947058545060953893433487994458443568169824149550389484489896,
-        3518297267402065742048564133910509847197496119850246255805075095266319996916,
-        340529752683340505065238931581518232901634742162506851191464448040657139775,
-        1954876811294863748406056845662382214841467408616109501720437541211031966538,
-    ],
-    [
-        813813157354633930267029888722341725864333883175521358739311868164460385261,
-        71901595776070443337150458310956362034911936706490730914901986556638720031,
-        2789761472166115462625363403490399263810962093264318361008954888847594113421,
-        2628791615374802560074754031104384456692791616314774034906110098358135152410,
-    ],
-    [
-        3617032588734559635167557152518265808024917503198278888820567553943986939719,
-        2624012360209966117322788103333497793082705816015202046036057821340914061980,
-        149101987103211771991327927827692640556911620408176100290586418839323044234,
-        1039927963829140138166373450440320262590862908847727961488297105916489431045,
-    ],
-    [
-        2213946951050724449162431068646025833746639391992751674082854766704900195669,
-        2792724903541814965769131737117981991997031078369482697195201969174353468597,
-        3212031629728871219804596347439383805499808476303618848198208101593976279441,
-        3343514080098703935339621028041191631325798327656683100151836206557453199613,
-    ],
-    [
-        614054702436541219556958850933730254992710988573177298270089989048553060199,
-        148148081026449726283933484730968827750202042869875329032965774667206931170,
-        1158283532103191908366672518396366136968613180867652172211392033571980848414,
-        1032400527342371389481069504520755916075559110755235773196747439146396688513,
-    ],
-    [
-        806900704622005851310078578853499250941978435851598088619290797134710613736,
-        462498083559902778091095573017508352472262817904991134671058825705968404510,
-        1003580119810278869589347418043095667699674425582646347949349245557449452503,
-        619074932220101074089137133998298830285661916867732916607601635248249357793,
-    ],
-    [
-        2635090520059500019661864086615522409798872905401305311748231832709078452746,
-        978252636251682252755279071140187792306115352460774007308726210405257135181,
-        1766912167973123409669091967764158892111310474906691336473559256218048677083,
-        1663265127259512472182980890707014969235283233442916350121860684522654120381,
-    ],
-    [
-        3532407621206959585000336211742670185380751515636605428496206887841428074250,
-        2507023127157093845256722098502856938353143387711652912931112668310034975446,
-        3321152907858462102434883844787153373036767230808678981306827073335525034593,
-        3039253036806065280643845548147711477270022154459620569428286684179698125661,
-    ],
-    [
-        103480338868480851881924519768416587261556021758163719199282794248762465380,
-        2394049781357087698434751577708655768465803975478348134669006211289636928495,
-        2660531560345476340796109810821127229446538730404600368347902087220064379579,
-        3603166934034556203649050570865466556260359798872408576857928196141785055563,
-    ],
-    [
-        1553799760191949768532188139643704561532896296986025007089826672890485412324,
-        2744284717053657689091306578463476341218866418732695211367062598446038965164,
-        320745764922149897598257794663594419839885234101078803811049904310835548856,
-        979382242100682161589753881721708883681034024104145498709287731138044566302,
-    ],
-    [
-        1860426855810549882740147175136418997351054138609396651615467358416651354991,
-        336173081054369235994909356892506146234495707857220254489443629387613956145,
-        1632470326779699229772327605759783482411227247311431865655466227711078175883,
-        921958250077481394074960433988881176409497663777043304881055317463712938502,
-    ],
-    [
-        3034358982193370602048539901033542101022185309652879937418114324899281842797,
-        25626282149517463867572353922222474817434101087272320606729439087234878607,
-        3002662261401575565838149305485737102400501329139562227180277188790091853682,
-        2939684373453383817196521641512509179310654199629514917426341354023324109367,
-    ],
-    [
-        1076484609897998179434851570277297233169621096172424141759873688902355505136,
-        2575095284833160494841112025725243274091830284746697961080467506739203605049,
-        3565075264617591783581665711620369529657840830498005563542124551465195621851,
-        2197016502533303822395077038351174326125210255869204501838837289716363437993,
-    ],
-    [
-        331415322883530754594261416546036195982886300052707474899691116664327869405,
-        1935011233711290003793244296594669823169522055520303479680359990463281661839,
-        3495901467168087413996941216661589517270845976538454329511167073314577412322,
-        954195417117133246453562983448451025087661597543338750600301835944144520375,
-    ],
-    [
-        1271840477709992894995746871435810599280944810893784031132923384456797925777,
-        2565310762274337662754531859505158700827688964841878141121196528015826671847,
-        3365022288251637014588279139038152521653896670895105540140002607272936852513,
-        1660592021628965529963974299647026602622092163312666588591285654477111176051,
-    ],
-    [
-        970104372286014048279296575474974982288801187216974504035759997141059513421,
-        2617024574317953753849168721871770134225690844968986289121504184985993971227,
-        999899815343607746071464113462778273556695659506865124478430189024755832262,
-        2228536129413411161615629030408828764980855956560026807518714080003644769896,
-    ],
-    [
-        2701953891198001564547196795777701119629537795442025393867364730330476403227,
-        837078355588159388741598313782044128527494922918203556465116291436461597853,
-        2121749601840466143704862369657561429793951309962582099604848281796392359214,
-        771812260179247428733132708063116523892339056677915387749121983038690154755,
-    ],
-    [
-        3317336423132806446086732225036532603224267214833263122557471741829060578219,
-        481570067997721834712647566896657604857788523050900222145547508314620762046,
-        242195042559343964206291740270858862066153636168162642380846129622127460192,
-        2855462178889999218204481481614105202770810647859867354506557827319138379686,
-    ],
-    [
-        3525521107148375040131784770413887305850308357895464453970651672160034885202,
-        1320839531502392535964065058804908871811967681250362364246430459003920305799,
-        2514191518588387125173345107242226637171897291221681115249521904869763202419,
-        2798335750958827619666318316247381695117827718387653874070218127140615157902,
-    ],
-    [
-        2808467767967035643407948058486565877867906577474361783201337540214875566395,
-        3551834385992706206273955480294669176699286104229279436819137165202231595747,
-        1219439673853113792340300173186247996249367102884530407862469123523013083971,
-        761519904537984520554247997444508040636526566551719396202550009393012691157,
-    ],
-    [
-        3355402549169351700500518865338783382387571349497391475317206324155237401353,
-        199541098009731541347317515995192175813554789571447733944970283654592727138,
-        192100490643078165121235261796864975568292640203635147901612231594408079071,
-        1187019357602953326192019968809486933768550466167033084944727938441427050581,
-    ],
-    [
-        189525349641911362389041124808934468936759383310282010671081989585219065700,
-        2831653363992091308880573627558515686245403755586311978724025292003353336665,
-        2052859812632218952608271535089179639890275494426396974475479657192657094698,
-        1670756178709659908159049531058853320846231785448204274277900022176591811072,
-    ],
-    [
-        3538757242013734574731807289786598937548399719866320954894004830207085723125,
-        710549042741321081781917034337800036872214466705318638023070812391485261299,
-        2345013122330545298606028187653996682275206910242635100920038943391319595180,
-        3528369671971445493932880023233332035122954362711876290904323783426765912206,
-    ],
-    [
-        1167120829038120978297497195837406760848728897181138760506162680655977700764,
-        3073243357129146594530765548901087443775563058893907738967898816092270628884,
-        378514724418106317738164464176041649567501099164061863402473942795977719726,
-        333391138410406330127594722511180398159664250722328578952158227406762627796,
-    ],
-    [
-        1727570175639917398410201375510924114487348765559913502662122372848626931905,
-        968312190621809249603425066974405725769739606059422769908547372904403793174,
-        360659316299446405855194688051178331671817370423873014757323462844775818348,
-        1386580151907705298970465943238806620109618995410132218037375811184684929291,
-    ],
-    [
-        3604888328937389309031638299660239238400230206645344173700074923133890528967,
-        2496185632263372962152518155651824899299616724241852816983268163379540137546,
-        486538168871046887467737983064272608432052269868418721234810979756540672990,
-        1558415498960552213241704009433360128041672577274390114589014204605400783336,
-    ],
-    [
-        3512058327686147326577190314835092911156317204978509183234511559551181053926,
-        2235429387083113882635494090887463486491842634403047716936833563914243946191,
-        1290896777143878193192832813769470418518651727840187056683408155503813799882,
-        1143310336918357319571079551779316654556781203013096026972411429993634080835,
-    ],
-    [
-        3235435208525081966062419599803346573407862428113723170955762956243193422118,
-        1293239921425673430660897025143433077974838969258268884994339615096356996604,
-        236252269127612784685426260840574970698541177557674806964960352572864382971,
-        1733907592497266237374827232200506798207318263912423249709509725341212026275,
-    ],
-    [
-        302004309771755665128395814807589350526779835595021835389022325987048089868,
-        3018926838139221755384801385583867283206879023218491758435446265703006270945,
-        39701437664873825906031098349904330565195980985885489447836580931425171297,
-        908381723021746969965674308809436059628307487140174335882627549095646509778,
-    ],
-    [
-        219062858908229855064136253265968615354041842047384625689776811853821594358,
-        1283129863776453589317845316917890202859466483456216900835390291449830275503,
-        418512623547417594896140369190919231877873410935689672661226540908900544012,
-        1792181590047131972851015200157890246436013346535432437041535789841136268632,
-    ],
-    [
-        370546432987510607338044736824316856592558876687225326692366316978098770516,
-        3323437805230586112013581113386626899534419826098235300155664022709435756946,
-        910076621742039763058481476739499965761942516177975130656340375573185415877,
-        1762188042455633427137702520675816545396284185254002959309669405982213803405,
-    ],
-    [
-        2186362253913140345102191078329764107619534641234549431429008219905315900520,
-        2230647725927681765419218738218528849146504088716182944327179019215826045083,
-        1069243907556644434301190076451112491469636357133398376850435321160857761825,
-        2695241469149243992683268025359863087303400907336026926662328156934068747593,
-    ],
-    [
-        1361519681544413849831669554199151294308350560528931040264950307931824877035,
-        1339116632207878730171031743761550901312154740800549632983325427035029084904,
-        790593524918851401449292693473498591068920069246127392274811084156907468875,
-        2723400368331924254840192318398326090089058735091724263333980290765736363637,
-    ],
-    [
-        3457180265095920471443772463283225391927927225993685928066766687141729456030,
-        1483675376954327086153452545475557749815683871577400883707749788555424847954,
-        2926303836265506736227240325795090239680154099205721426928300056982414025239,
-        543969119775473768170832347411484329362572550684421616624136244239799475526,
-    ],
-    [
-        237401230683847084256617415614300816373730178313253487575312839074042461932,
-        844568412840391587862072008674263874021460074878949862892685736454654414423,
-        151922054871708336050647150237534498235916969120198637893731715254687336644,
-        1299332034710622815055321547569101119597030148120309411086203580212105652312,
-    ],
-    [
-        487046922649899823989594814663418784068895385009696501386459462815688122993,
-        1104883249092599185744249485896585912845784382683240114120846423960548576851,
-        1458388705536282069567179348797334876446380557083422364875248475157495514484,
-        850248109622750774031817200193861444623975329881731864752464222442574976566,
-    ],
-    [
-        2885843173858536690032695698009109793537724845140477446409245651176355435722,
-        3027068551635372249579348422266406787688980506275086097330568993357835463816,
-        3231892723647447539926175383213338123506134054432701323145045438168976970994,
-        1719080830641935421242626784132692936776388194122314954558418655725251172826,
-    ],
-    [
-        1172253756541066126131022537343350498482225068791630219494878195815226839450,
-        1619232269633026603732619978083169293258272967781186544174521481891163985093,
-        3495680684841853175973173610562400042003100419811771341346135531754869014567,
-        1576161515913099892951745452471618612307857113799539794680346855318958552758,
-    ],
-    [
-        2618326122974253423403350731396350223238201817594761152626832144510903048529,
-        2696245132758436974032479782852265185094623165224532063951287925001108567649,
-        930116505665110070247395429730201844026054810856263733273443066419816003444,
-        2786389174502246248523918824488629229455088716707062764363111940462137404076,
-    ],
-    [
-        1555260846425735320214671887347115247546042526197895180675436886484523605116,
-        2306241912153325247392671742757902161446877415586158295423293240351799505917,
-        411529621724849932999694270803131456243889635467661223241617477462914950626,
-        1542495485262286701469125140275904136434075186064076910329015697714211835205,
-    ],
-    [
-        1853045663799041100600825096887578544265580718909350942241802897995488264551,
-        2963055259497271220202739837493041799968576111953080503132045092194513937286,
-        2303806870349915764285872605046527036748108533406243381676768310692344456050,
-        2622104986201990620910286730213140904984256464479840856728424375142929278875,
-    ],
-    [
-        2369987021925266811581727383184031736927816625797282287927222602539037105864,
-        285070227712021899602056480426671736057274017903028992288878116056674401781,
-        3034087076179360957800568733595959058628497428787907887933697691951454610691,
-        469095854351700119980323115747590868855368701825706298740201488006320881056,
-    ],
-    [
-        360001976264385426746283365024817520563236378289230404095383746911725100012,
-        3438709327109021347267562000879503009590697221730578667498351600602230296178,
-        63573904800572228121671659287593650438456772568903228287754075619928214969,
-        3470881855042989871434874691030920672110111605547839662680968354703074556970,
-    ],
-    [
-        724559311507950497340993415408274803001166693839947519425501269424891465492,
-        880409284677518997550768549487344416321062350742831373397603704465823658986,
-        6876255662475867703077362872097208259197756317287339941435193538565586230,
-        2701916445133770775447884812906226786217969545216086200932273680400909154638,
-    ],
-    [
-        425152119158711585559310064242720816611629181537672850898056934507216982586,
-        1475552998258917706756737045704649573088377604240716286977690565239187213744,
-        2413772448122400684309006716414417978370152271397082147158000439863002593561,
-        392160855822256520519339260245328807036619920858503984710539815951012864164,
-    ],
-    [
-        1075036996503791536261050742318169965707018400307026402939804424927087093987,
-        2176439430328703902070742432016450246365760303014562857296722712989275658921,
-        1413865976587623331051814207977382826721471106513581745229680113383908569693,
-        4879283427490523253696177116563427032332223531862961281430108575019551814,
-    ],
-    [
-        3392583297537374046875199552977614390492290683707960975137418536812266544902,
-        3600854486849487646325182927019642276644093512133907046667282144129939150983,
-        2779924664161372134024229593301361846129279572186444474616319283535189797834,
-        2722699960903170449291146429799738181514821447014433304730310678334403972040,
-    ],
-    [
-        819109815049226540285781191874507704729062681836086010078910930707209464699,
-        3046121243742768013822760785918001632929744274211027071381357122228091333823,
-        1339019590803056172509793134119156250729668216522001157582155155947567682278,
-        1933279639657506214789316403763326578443023901555983256955812717638093967201,
-    ],
-    [
-        2138221547112520744699126051903811860205771600821672121643894708182292213541,
-        2694713515543641924097704224170357995809887124438248292930846280951601597065,
-        2471734202930133750093618989223585244499567111661178960753938272334153710615,
-        504903761112092757611047718215309856203214372330635774577409639907729993533,
-    ],
-    [
-        1943979703748281357156510253941035712048221353507135074336243405478613241290,
-        684525210957572142559049112233609445802004614280157992196913315652663518936,
-        1705585400798782397786453706717059483604368413512485532079242223503960814508,
-        192429517716023021556170942988476050278432319516032402725586427701913624665,
-    ],
-    [
-        1586493702243128040549584165333371192888583026298039652930372758731750166765,
-        686072673323546915014972146032384917012218151266600268450347114036285993377,
-        3464340397998075738891129996710075228740496767934137465519455338004332839215,
-        2805249176617071054530589390406083958753103601524808155663551392362371834663,
-    ],
-    [
-        667746464250968521164727418691487653339733392025160477655836902744186489526,
-        1131527712905109997177270289411406385352032457456054589588342450404257139778,
-        1908969485750011212309284349900149072003218505891252313183123635318886241171,
-        1025257076985551890132050019084873267454083056307650830147063480409707787695,
-    ],
-    [
-        2153175291918371429502545470578981828372846236838301412119329786849737957977,
-        3410257749736714576487217882785226905621212230027780855361670645857085424384,
-        3442969106887588154491488961893254739289120695377621434680934888062399029952,
-        3029953900235731770255937704976720759948880815387104275525268727341390470237,
-    ],
-    [
-        85453456084781138713939104192561924536933417707871501802199311333127894466,
-        2730629666577257820220329078741301754580009106438115341296453318350676425129,
-        178242450661072967256438102630920745430303027840919213764087927763335940415,
-        2844589222514708695700541363167856718216388819406388706818431442998498677557,
-    ],
-    [
-        3547876269219141094308889387292091231377253967587961309624916269569559952944,
-        2525005406762984211707203144785482908331876505006839217175334833739957826850,
-        3096397013555211396701910432830904669391580557191845136003938801598654871345,
-        574424067119200181933992948252007230348512600107123873197603373898923821490,
-    ],
-    [
-        1714030696055067278349157346067719307863507310709155690164546226450579547098,
-        2339895272202694698739231405357972261413383527237194045718815176814132612501,
-        3562501318971895161271663840954705079797767042115717360959659475564651685069,
-        69069358687197963617161747606993436483967992689488259107924379545671193749,
-    ],
-    [
-        2614502738369008850475068874731531583863538486212691941619835266611116051561,
-        655247349763023251625727726218660142895322325659927266813592114640858573566,
-        2305235672527595714255517865498269719545193172975330668070873705108690670678,
-        926416070297755413261159098243058134401665060349723804040714357642180531931,
-    ],
-    [
-        866523735635840246543516964237513287099659681479228450791071595433217821460,
-        2284334068466681424919271582037156124891004191915573957556691163266198707693,
-        1812588309302477291425732810913354633465435706480768615104211305579383928792,
-        2836899808619013605432050476764608707770404125005720004551836441247917488507,
-    ],
-    [
-        2989087789022865112405242078196235025698647423649950459911546051695688370523,
-        68056284404189102136488263779598243992465747932368669388126367131855404486,
-        505425339250887519581119854377342241317528319745596963584548343662758204398,
-        2118963546856545068961709089296976921067035227488975882615462246481055679215,
-    ],
-    [
-        2253872596319969096156004495313034590996995209785432485705134570745135149681,
-        1625090409149943603241183848936692198923183279116014478406452426158572703264,
-        179139838844452470348634657368199622305888473747024389514258107503778442495,
-        1567067018147735642071130442904093290030432522257811793540290101391210410341,
-    ],
-    [
-        2737301854006865242314806979738760349397411136469975337509958305470398783585,
-        3002738216460904473515791428798860225499078134627026021350799206894618186256,
-        374029488099466837453096950537275565120689146401077127482884887409712315162,
-        973403256517481077805460710540468856199855789930951602150773500862180885363,
-    ],
-    [
-        2691967457038172130555117632010860984519926022632800605713473799739632878867,
-        3515906794910381201365530594248181418811879320679684239326734893975752012109,
-        148057579455448384062325089530558091463206199724854022070244924642222283388,
-        1541588700238272710315890873051237741033408846596322948443180470429851502842,
-    ],
-    [
-        147013865879011936545137344076637170977925826031496203944786839068852795297,
-        2630278389304735265620281704608245039972003761509102213752997636382302839857,
-        1359048670759642844930007747955701205155822111403150159614453244477853867621,
-        2438984569205812336319229336885480537793786558293523767186829418969842616677,
-    ],
-    [
-        2137792255841525507649318539501906353254503076308308692873313199435029594138,
-        2262318076430740712267739371170174514379142884859595360065535117601097652755,
-        2792703718581084537295613508201818489836796608902614779596544185252826291584,
-        2294173715793292812015960640392421991604150133581218254866878921346561546149,
-    ],
-    [
-        2770011224727997178743274791849308200493823127651418989170761007078565678171,
-        3321642244537785916275181932172303118112488081726311374164578600576901819844,
-        3522708517589950573320671158134804505970724681591943826922697952040487655044,
-        3417974441436557992524691506735790206623600049454586729879955931972546347402,
-    ],
-    [
-        175039333145381316571259690443853067809784261609912638686739799135919647022,
-        1930713062131033273316869231148248962041053029742760224583505092759642967464,
-        2971452932574554603554350185069538580257636405419430340233233400633251319042,
-        2774781903758215341037075610938953949868289195845367046186588750871862784919,
-    ],
-    [
-        666516874137869653699423537799457099346460194092311952417454613224504932738,
-        1900462225013533249140457703727169176351786259991305560412832202759625668041,
-        2665631186082687279121709429531834469477679375137509769347092380798929714377,
-        837840745988147279235494664091280091563355097569199320366973125128366540061,
-    ],
-    [
-        3391544118305848781823721719916289805455110924839794510205940718821197620955,
-        2888553035909938253628892138500390690221493345071933642853222968481016605919,
-        3386241569867597612447901482685846444743718781330869478721963580925825915450,
-        1205126220630896984850042596877918177217334376800874965105642874206963597698,
-    ],
-    [
-        3590072615491710252422997155203204584659171612188004116415640739580250394190,
-        692469013329617220154003334549812915100479873898898958632988703738125356983,
-        1623178235190707102808841905143937367808788834203621005714003335195182126335,
-        1972826180775011489122426045504602288576507493792470102803637471568052321297,
-    ],
-    [
-        3415141329098504418158191749675997877417539760075593313736376750580696083073,
-        587811537889727046473915684463981273175495137461951211739526104349163747811,
-        2523982964351069134084525951849317400231659428055762640605248929856135518199,
-        2686176526711834950207666047281383173339057216783586039351834948812568447629,
-    ],
-    [
-        983144446441739425577690449774542566745526459152966545642451764143532586964,
-        171558252019175695567663688494555626159399786667979998273792882504784080805,
-        332337623010057542760158225837623039780806442976079546879646069338600179518,
-        1264669683963885571544813806669118319675288608634733888843804451222546848295,
-    ],
-    [
-        2426165115815723668018318268486497504249785449504758403912155206515511627681,
-        11387399609384288947733630450855186629703576293221897150193655994854764608,
-        2541728569046079092074077754414781968906176513081761690404588216304985421091,
-        47685947554980329431290582269851186106577733250761848107645535357326439312,
-    ],
-    [
-        472176388418187405374813530639596064799362505024895746833751173199773896628,
-        2764298116617383397920343358525617195195060562266243809245480210157942112738,
-        486863835068754002670800862273365477867695879270721744227071001883208334054,
-        2973492686137102577527656941792991264994301121122130295965761350095846874635,
-    ],
-    [
-        178385615141132702906181473263873416748818415607305319148067639744074654009,
-        533624640096756667052211553746016402543259206286603356120804827761339634127,
-        819406716720171922688026098737835227857400444543748198788964759773510472096,
-        531851793767260921861217458033110066464894334064526987603936107947006031387,
-    ],
-    [
-        3269709072483585277009748181134917746036523619604017812342933951952104134829,
-        838191718603413598040249006803464503100808192944407407147899973659013630611,
-        1574561296941310904780257598780779812250055948216417844567262310524022037406,
-        551394354289003977607664358739006072556227894953233419144430578080352094737,
-    ],
-    [
-        445076790942318675726839050057337819004979443030540904213920669247413907302,
-        1963946696292687224902912968478695543164747600779913024040878700455222386521,
-        484284614181963381509745298932402076252103342403432879800905151752488144767,
-        2240507606126946994415203252302826782042951346966859379502140796364876543253,
-    ],
-    [
-        3237135638753992982179886898758938279897590886053928839613434762582576319619,
-        2334333034701915027889533058426879447140084891006486138782876488162658230991,
-        14411091399844539897439754491034751977136685514851444574462584316609631592,
-        1264480371592407258420308876448697804787923638319277097663041109464608464284,
-    ],
-    [
-        671929312763821646360589403212798993954209530574443543917757335777610372144,
-        2513909805455654095962542944994577107405216428214873444765576238504714067396,
-        870121102846043786263357605823753628974859886859187558617096145653709171231,
-        399132620893316356411986266679786708905730068946836982293484206366500277754,
-    ],
-    [
-        2855046250836680633532995284655778407402587437073106249445470889390454667586,
-        2063679741125384345396981490971605710211281905716315529671473143278849561151,
-        1433753212258929925682201698758056443128516570551146995210728194816988328337,
-        3334984763425011856632257855270507440816274246647423607159847074739331865077,
-    ],
-    [
-        337911293622078184850923533628334646725451591671907148383867096651211846605,
-        559587005295238702015018022040357402231957131094636365177008701077975941644,
-        885963059604819264377490633589388189646118257469490919900554134369512794660,
-        1957748763518471091057032383332840331641373304981058387824598000170709016333,
-    ],
-    [
-        3175295982155056798972302481564899381103533409383494814704562889625572018450,
-        498987160612401618114584726510347771865331516606886613019084323862447372555,
-        947374835104260364630171441676101001841507588423166778786886198914150312958,
-        906933977754491302438795274167251538820934378773708095543613756654712689280,
-    ],
-    [
-        2170116291766863179909957030577284618726490893598499117272497866180009722894,
-        1801335399574515889082584621772588704763181408217893911806726119813067220453,
-        1942500232535842474530840356353427989892065499159260166135596750084681859966,
-        62936080219825306823124060587235998278756755377419521154040408253893795176,
-    ],
-    [
-        3091993939935137795359769774909373279950941171574748645375255810204590357753,
-        1283528386884634267663661033944552098742115012555712906773586466375284501324,
-        1581820717639229420476069802992937438655873471854930764425841549067913106065,
-        2301986095388751633126546121528329200085681648876910655269533407603441046514,
-    ],
-    [
-        2850003828037698751961753862613545302539465803982364898225617297398939302949,
-        48024691078494936445046366770271288984930221238071705874025261821606393528,
-        1482336297033144958942154923925185950152551534403871620222916667536030875354,
-        3081177564717719643771186007689458633949181485535169123213511264603782950049,
-    ],
-    [
-        3315701127039521853279746297714590495201061397709680410650043502532250578075,
-        3514407611000441301995070394422463400067690470546731164089622325748803106020,
-        368970178199930154322724953487299516224498421233447528815195701420122548537,
-        584353160413525267849669053228533951552602295860601556035386665117717227391,
-    ],
-    [
-        752038702160385294706011538400822066722189014251268673051846350397729870418,
-        3594041683498798688197194521326299097635429790757880308152971477196489335154,
-        1367902435756906062215608264424138718742854099315395230911274560900857414183,
-        1828549068951502746189364466794037234789986878381694857475972053743463890779,
-    ],
-    [
-        488172495141237210878388657234137733008417573114482400652274985829148564248,
-        962906242461930394022372340919543491337923491322497419797555620396501785566,
-        2275418085010046236619290386129138234541669589549771944697082317642065048898,
-        1966395064658902622886154686288219600816893261614483533899715888994623208964,
-    ],
-    [
-        3496095878293416917311185659829821476802828534554531050412634978086916288609,
-        3368478822390537245916137403277928093536087427951052230723275731232142463388,
-        3397410259276620127103231993277518800970669191016277541098821699302368873803,
-        2662600899665871010006649609856695263727220473364611552472965243032255906029,
-    ],
-]
--- a/test/stark/poseidon/poseidon5.txt
+++ b/test/stark/poseidon/poseidon5.txt
@@ -1,651 +0,0 @@
-Rate = 4
-Capacity = 1
-FullRounds = 8
-PartialRounds = 84
-MDS = [[3, 1, 1, 1, 1], [1, 2, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, -1, 1], [1, 1, 1, 1, -2]]
-RoundKeys = [
-    [
-        2950795762459345168613727575620414179244544320470208355568817838579231751791,
-        1587446564224215276866294500450702039420286416111469274423465069420553242820,
-        1645965921169490687904413452218868659025437693527479459426157555728339600137,
-        2782373324549879794752287702905278018819686065818504085638398966973694145741,
-        3409172630025222641379726933524480516420204828329395644967085131392375707302,
-    ],
-    [
-        2379053116496905638239090788901387719228422033660130943198035907032739387135,
-        2570819397480941104144008784293466051718826502582588529995520356691856497111,
-        3546220846133880637977653625763703334841539452343273304410918449202580719746,
-        2720682389492889709700489490056111332164748138023159726590726667539759963454,
-        1899653471897224903834726250400246354200311275092866725547887381599836519005,
-    ],
-    [
-        2369443697923857319844855392163763375394720104106200469525915896159690979559,
-        2354174693689535854311272135513626412848402744119855553970180659094265527996,
-        2404084503073127963385083467393598147276436640877011103379112521338973185443,
-        950320777137731763811524327595514151340412860090489448295239456547370725376,
-        2121140748740143694053732746913428481442990369183417228688865837805149503386,
-    ],
-    [
-        2372065044800422557577242066480215868569521938346032514014152523102053709709,
-        2618497439310693947058545060953893433487994458443568169824149550389484489896,
-        3518297267402065742048564133910509847197496119850246255805075095266319996916,
-        340529752683340505065238931581518232901634742162506851191464448040657139775,
-        1954876811294863748406056845662382214841467408616109501720437541211031966538,
-    ],
-    [
-        813813157354633930267029888722341725864333883175521358739311868164460385261,
-        71901595776070443337150458310956362034911936706490730914901986556638720031,
-        2789761472166115462625363403490399263810962093264318361008954888847594113421,
-        2628791615374802560074754031104384456692791616314774034906110098358135152410,
-        3617032588734559635167557152518265808024917503198278888820567553943986939719,
-    ],
-    [
-        2624012360209966117322788103333497793082705816015202046036057821340914061980,
-        149101987103211771991327927827692640556911620408176100290586418839323044234,
-        1039927963829140138166373450440320262590862908847727961488297105916489431045,
-        2213946951050724449162431068646025833746639391992751674082854766704900195669,
-        2792724903541814965769131737117981991997031078369482697195201969174353468597,
-    ],
-    [
-        3212031629728871219804596347439383805499808476303618848198208101593976279441,
-        3343514080098703935339621028041191631325798327656683100151836206557453199613,
-        614054702436541219556958850933730254992710988573177298270089989048553060199,
-        148148081026449726283933484730968827750202042869875329032965774667206931170,
-        1158283532103191908366672518396366136968613180867652172211392033571980848414,
-    ],
-    [
-        1032400527342371389481069504520755916075559110755235773196747439146396688513,
-        806900704622005851310078578853499250941978435851598088619290797134710613736,
-        462498083559902778091095573017508352472262817904991134671058825705968404510,
-        1003580119810278869589347418043095667699674425582646347949349245557449452503,
-        619074932220101074089137133998298830285661916867732916607601635248249357793,
-    ],
-    [
-        2635090520059500019661864086615522409798872905401305311748231832709078452746,
-        978252636251682252755279071140187792306115352460774007308726210405257135181,
-        1766912167973123409669091967764158892111310474906691336473559256218048677083,
-        1663265127259512472182980890707014969235283233442916350121860684522654120381,
-        3532407621206959585000336211742670185380751515636605428496206887841428074250,
-    ],
-    [
-        2507023127157093845256722098502856938353143387711652912931112668310034975446,
-        3321152907858462102434883844787153373036767230808678981306827073335525034593,
-        3039253036806065280643845548147711477270022154459620569428286684179698125661,
-        103480338868480851881924519768416587261556021758163719199282794248762465380,
-        2394049781357087698434751577708655768465803975478348134669006211289636928495,
-    ],
-    [
-        2660531560345476340796109810821127229446538730404600368347902087220064379579,
-        3603166934034556203649050570865466556260359798872408576857928196141785055563,
-        1553799760191949768532188139643704561532896296986025007089826672890485412324,
-        2744284717053657689091306578463476341218866418732695211367062598446038965164,
-        320745764922149897598257794663594419839885234101078803811049904310835548856,
-    ],
-    [
-        979382242100682161589753881721708883681034024104145498709287731138044566302,
-        1860426855810549882740147175136418997351054138609396651615467358416651354991,
-        336173081054369235994909356892506146234495707857220254489443629387613956145,
-        1632470326779699229772327605759783482411227247311431865655466227711078175883,
-        921958250077481394074960433988881176409497663777043304881055317463712938502,
-    ],
-    [
-        3034358982193370602048539901033542101022185309652879937418114324899281842797,
-        25626282149517463867572353922222474817434101087272320606729439087234878607,
-        3002662261401575565838149305485737102400501329139562227180277188790091853682,
-        2939684373453383817196521641512509179310654199629514917426341354023324109367,
-        1076484609897998179434851570277297233169621096172424141759873688902355505136,
-    ],
-    [
-        2575095284833160494841112025725243274091830284746697961080467506739203605049,
-        3565075264617591783581665711620369529657840830498005563542124551465195621851,
-        2197016502533303822395077038351174326125210255869204501838837289716363437993,
-        331415322883530754594261416546036195982886300052707474899691116664327869405,
-        1935011233711290003793244296594669823169522055520303479680359990463281661839,
-    ],
-    [
-        3495901467168087413996941216661589517270845976538454329511167073314577412322,
-        954195417117133246453562983448451025087661597543338750600301835944144520375,
-        1271840477709992894995746871435810599280944810893784031132923384456797925777,
-        2565310762274337662754531859505158700827688964841878141121196528015826671847,
-        3365022288251637014588279139038152521653896670895105540140002607272936852513,
-    ],
-    [
-        1660592021628965529963974299647026602622092163312666588591285654477111176051,
-        970104372286014048279296575474974982288801187216974504035759997141059513421,
-        2617024574317953753849168721871770134225690844968986289121504184985993971227,
-        999899815343607746071464113462778273556695659506865124478430189024755832262,
-        2228536129413411161615629030408828764980855956560026807518714080003644769896,
-    ],
-    [
-        2701953891198001564547196795777701119629537795442025393867364730330476403227,
-        837078355588159388741598313782044128527494922918203556465116291436461597853,
-        2121749601840466143704862369657561429793951309962582099604848281796392359214,
-        771812260179247428733132708063116523892339056677915387749121983038690154755,
-        3317336423132806446086732225036532603224267214833263122557471741829060578219,
-    ],
-    [
-        481570067997721834712647566896657604857788523050900222145547508314620762046,
-        242195042559343964206291740270858862066153636168162642380846129622127460192,
-        2855462178889999218204481481614105202770810647859867354506557827319138379686,
-        3525521107148375040131784770413887305850308357895464453970651672160034885202,
-        1320839531502392535964065058804908871811967681250362364246430459003920305799,
-    ],
-    [
-        2514191518588387125173345107242226637171897291221681115249521904869763202419,
-        2798335750958827619666318316247381695117827718387653874070218127140615157902,
-        2808467767967035643407948058486565877867906577474361783201337540214875566395,
-        3551834385992706206273955480294669176699286104229279436819137165202231595747,
-        1219439673853113792340300173186247996249367102884530407862469123523013083971,
-    ],
-    [
-        761519904537984520554247997444508040636526566551719396202550009393012691157,
-        3355402549169351700500518865338783382387571349497391475317206324155237401353,
-        199541098009731541347317515995192175813554789571447733944970283654592727138,
-        192100490643078165121235261796864975568292640203635147901612231594408079071,
-        1187019357602953326192019968809486933768550466167033084944727938441427050581,
-    ],
-    [
-        189525349641911362389041124808934468936759383310282010671081989585219065700,
-        2831653363992091308880573627558515686245403755586311978724025292003353336665,
-        2052859812632218952608271535089179639890275494426396974475479657192657094698,
-        1670756178709659908159049531058853320846231785448204274277900022176591811072,
-        3538757242013734574731807289786598937548399719866320954894004830207085723125,
-    ],
-    [
-        710549042741321081781917034337800036872214466705318638023070812391485261299,
-        2345013122330545298606028187653996682275206910242635100920038943391319595180,
-        3528369671971445493932880023233332035122954362711876290904323783426765912206,
-        1167120829038120978297497195837406760848728897181138760506162680655977700764,
-        3073243357129146594530765548901087443775563058893907738967898816092270628884,
-    ],
-    [
-        378514724418106317738164464176041649567501099164061863402473942795977719726,
-        333391138410406330127594722511180398159664250722328578952158227406762627796,
-        1727570175639917398410201375510924114487348765559913502662122372848626931905,
-        968312190621809249603425066974405725769739606059422769908547372904403793174,
-        360659316299446405855194688051178331671817370423873014757323462844775818348,
-    ],
-    [
-        1386580151907705298970465943238806620109618995410132218037375811184684929291,
-        3604888328937389309031638299660239238400230206645344173700074923133890528967,
-        2496185632263372962152518155651824899299616724241852816983268163379540137546,
-        486538168871046887467737983064272608432052269868418721234810979756540672990,
-        1558415498960552213241704009433360128041672577274390114589014204605400783336,
-    ],
-    [
-        3512058327686147326577190314835092911156317204978509183234511559551181053926,
-        2235429387083113882635494090887463486491842634403047716936833563914243946191,
-        1290896777143878193192832813769470418518651727840187056683408155503813799882,
-        1143310336918357319571079551779316654556781203013096026972411429993634080835,
-        3235435208525081966062419599803346573407862428113723170955762956243193422118,
-    ],
-    [
-        1293239921425673430660897025143433077974838969258268884994339615096356996604,
-        236252269127612784685426260840574970698541177557674806964960352572864382971,
-        1733907592497266237374827232200506798207318263912423249709509725341212026275,
-        302004309771755665128395814807589350526779835595021835389022325987048089868,
-        3018926838139221755384801385583867283206879023218491758435446265703006270945,
-    ],
-    [
-        39701437664873825906031098349904330565195980985885489447836580931425171297,
-        908381723021746969965674308809436059628307487140174335882627549095646509778,
-        219062858908229855064136253265968615354041842047384625689776811853821594358,
-        1283129863776453589317845316917890202859466483456216900835390291449830275503,
-        418512623547417594896140369190919231877873410935689672661226540908900544012,
-    ],
-    [
-        1792181590047131972851015200157890246436013346535432437041535789841136268632,
-        370546432987510607338044736824316856592558876687225326692366316978098770516,
-        3323437805230586112013581113386626899534419826098235300155664022709435756946,
-        910076621742039763058481476739499965761942516177975130656340375573185415877,
-        1762188042455633427137702520675816545396284185254002959309669405982213803405,
-    ],
-    [
-        2186362253913140345102191078329764107619534641234549431429008219905315900520,
-        2230647725927681765419218738218528849146504088716182944327179019215826045083,
-        1069243907556644434301190076451112491469636357133398376850435321160857761825,
-        2695241469149243992683268025359863087303400907336026926662328156934068747593,
-        1361519681544413849831669554199151294308350560528931040264950307931824877035,
-    ],
-    [
-        1339116632207878730171031743761550901312154740800549632983325427035029084904,
-        790593524918851401449292693473498591068920069246127392274811084156907468875,
-        2723400368331924254840192318398326090089058735091724263333980290765736363637,
-        3457180265095920471443772463283225391927927225993685928066766687141729456030,
-        1483675376954327086153452545475557749815683871577400883707749788555424847954,
-    ],
-    [
-        2926303836265506736227240325795090239680154099205721426928300056982414025239,
-        543969119775473768170832347411484329362572550684421616624136244239799475526,
-        237401230683847084256617415614300816373730178313253487575312839074042461932,
-        844568412840391587862072008674263874021460074878949862892685736454654414423,
-        151922054871708336050647150237534498235916969120198637893731715254687336644,
-    ],
-    [
-        1299332034710622815055321547569101119597030148120309411086203580212105652312,
-        487046922649899823989594814663418784068895385009696501386459462815688122993,
-        1104883249092599185744249485896585912845784382683240114120846423960548576851,
-        1458388705536282069567179348797334876446380557083422364875248475157495514484,
-        850248109622750774031817200193861444623975329881731864752464222442574976566,
-    ],
-    [
-        2885843173858536690032695698009109793537724845140477446409245651176355435722,
-        3027068551635372249579348422266406787688980506275086097330568993357835463816,
-        3231892723647447539926175383213338123506134054432701323145045438168976970994,
-        1719080830641935421242626784132692936776388194122314954558418655725251172826,
-        1172253756541066126131022537343350498482225068791630219494878195815226839450,
-    ],
-    [
-        1619232269633026603732619978083169293258272967781186544174521481891163985093,
-        3495680684841853175973173610562400042003100419811771341346135531754869014567,
-        1576161515913099892951745452471618612307857113799539794680346855318958552758,
-        2618326122974253423403350731396350223238201817594761152626832144510903048529,
-        2696245132758436974032479782852265185094623165224532063951287925001108567649,
-    ],
-    [
-        930116505665110070247395429730201844026054810856263733273443066419816003444,
-        2786389174502246248523918824488629229455088716707062764363111940462137404076,
-        1555260846425735320214671887347115247546042526197895180675436886484523605116,
-        2306241912153325247392671742757902161446877415586158295423293240351799505917,
-        411529621724849932999694270803131456243889635467661223241617477462914950626,
-    ],
-    [
-        1542495485262286701469125140275904136434075186064076910329015697714211835205,
-        1853045663799041100600825096887578544265580718909350942241802897995488264551,
-        2963055259497271220202739837493041799968576111953080503132045092194513937286,
-        2303806870349915764285872605046527036748108533406243381676768310692344456050,
-        2622104986201990620910286730213140904984256464479840856728424375142929278875,
-    ],
-    [
-        2369987021925266811581727383184031736927816625797282287927222602539037105864,
-        285070227712021899602056480426671736057274017903028992288878116056674401781,
-        3034087076179360957800568733595959058628497428787907887933697691951454610691,
-        469095854351700119980323115747590868855368701825706298740201488006320881056,
-        360001976264385426746283365024817520563236378289230404095383746911725100012,
-    ],
-    [
-        3438709327109021347267562000879503009590697221730578667498351600602230296178,
-        63573904800572228121671659287593650438456772568903228287754075619928214969,
-        3470881855042989871434874691030920672110111605547839662680968354703074556970,
-        724559311507950497340993415408274803001166693839947519425501269424891465492,
-        880409284677518997550768549487344416321062350742831373397603704465823658986,
-    ],
-    [
-        6876255662475867703077362872097208259197756317287339941435193538565586230,
-        2701916445133770775447884812906226786217969545216086200932273680400909154638,
-        425152119158711585559310064242720816611629181537672850898056934507216982586,
-        1475552998258917706756737045704649573088377604240716286977690565239187213744,
-        2413772448122400684309006716414417978370152271397082147158000439863002593561,
-    ],
-    [
-        392160855822256520519339260245328807036619920858503984710539815951012864164,
-        1075036996503791536261050742318169965707018400307026402939804424927087093987,
-        2176439430328703902070742432016450246365760303014562857296722712989275658921,
-        1413865976587623331051814207977382826721471106513581745229680113383908569693,
-        4879283427490523253696177116563427032332223531862961281430108575019551814,
-    ],
-    [
-        3392583297537374046875199552977614390492290683707960975137418536812266544902,
-        3600854486849487646325182927019642276644093512133907046667282144129939150983,
-        2779924664161372134024229593301361846129279572186444474616319283535189797834,
-        2722699960903170449291146429799738181514821447014433304730310678334403972040,
-        819109815049226540285781191874507704729062681836086010078910930707209464699,
-    ],
-    [
-        3046121243742768013822760785918001632929744274211027071381357122228091333823,
-        1339019590803056172509793134119156250729668216522001157582155155947567682278,
-        1933279639657506214789316403763326578443023901555983256955812717638093967201,
-        2138221547112520744699126051903811860205771600821672121643894708182292213541,
-        2694713515543641924097704224170357995809887124438248292930846280951601597065,
-    ],
-    [
-        2471734202930133750093618989223585244499567111661178960753938272334153710615,
-        504903761112092757611047718215309856203214372330635774577409639907729993533,
-        1943979703748281357156510253941035712048221353507135074336243405478613241290,
-        684525210957572142559049112233609445802004614280157992196913315652663518936,
-        1705585400798782397786453706717059483604368413512485532079242223503960814508,
-    ],
-    [
-        192429517716023021556170942988476050278432319516032402725586427701913624665,
-        1586493702243128040549584165333371192888583026298039652930372758731750166765,
-        686072673323546915014972146032384917012218151266600268450347114036285993377,
-        3464340397998075738891129996710075228740496767934137465519455338004332839215,
-        2805249176617071054530589390406083958753103601524808155663551392362371834663,
-    ],
-    [
-        667746464250968521164727418691487653339733392025160477655836902744186489526,
-        1131527712905109997177270289411406385352032457456054589588342450404257139778,
-        1908969485750011212309284349900149072003218505891252313183123635318886241171,
-        1025257076985551890132050019084873267454083056307650830147063480409707787695,
-        2153175291918371429502545470578981828372846236838301412119329786849737957977,
-    ],
-    [
-        3410257749736714576487217882785226905621212230027780855361670645857085424384,
-        3442969106887588154491488961893254739289120695377621434680934888062399029952,
-        3029953900235731770255937704976720759948880815387104275525268727341390470237,
-        85453456084781138713939104192561924536933417707871501802199311333127894466,
-        2730629666577257820220329078741301754580009106438115341296453318350676425129,
-    ],
-    [
-        178242450661072967256438102630920745430303027840919213764087927763335940415,
-        2844589222514708695700541363167856718216388819406388706818431442998498677557,
-        3547876269219141094308889387292091231377253967587961309624916269569559952944,
-        2525005406762984211707203144785482908331876505006839217175334833739957826850,
-        3096397013555211396701910432830904669391580557191845136003938801598654871345,
-    ],
-    [
-        574424067119200181933992948252007230348512600107123873197603373898923821490,
-        1714030696055067278349157346067719307863507310709155690164546226450579547098,
-        2339895272202694698739231405357972261413383527237194045718815176814132612501,
-        3562501318971895161271663840954705079797767042115717360959659475564651685069,
-        69069358687197963617161747606993436483967992689488259107924379545671193749,
-    ],
-    [
-        2614502738369008850475068874731531583863538486212691941619835266611116051561,
-        655247349763023251625727726218660142895322325659927266813592114640858573566,
-        2305235672527595714255517865498269719545193172975330668070873705108690670678,
-        926416070297755413261159098243058134401665060349723804040714357642180531931,
-        866523735635840246543516964237513287099659681479228450791071595433217821460,
-    ],
-    [
-        2284334068466681424919271582037156124891004191915573957556691163266198707693,
-        1812588309302477291425732810913354633465435706480768615104211305579383928792,
-        2836899808619013605432050476764608707770404125005720004551836441247917488507,
-        2989087789022865112405242078196235025698647423649950459911546051695688370523,
-        68056284404189102136488263779598243992465747932368669388126367131855404486,
-    ],
-    [
-        505425339250887519581119854377342241317528319745596963584548343662758204398,
-        2118963546856545068961709089296976921067035227488975882615462246481055679215,
-        2253872596319969096156004495313034590996995209785432485705134570745135149681,
-        1625090409149943603241183848936692198923183279116014478406452426158572703264,
-        179139838844452470348634657368199622305888473747024389514258107503778442495,
-    ],
-    [
-        1567067018147735642071130442904093290030432522257811793540290101391210410341,
-        2737301854006865242314806979738760349397411136469975337509958305470398783585,
-        3002738216460904473515791428798860225499078134627026021350799206894618186256,
-        374029488099466837453096950537275565120689146401077127482884887409712315162,
-        973403256517481077805460710540468856199855789930951602150773500862180885363,
-    ],
-    [
-        2691967457038172130555117632010860984519926022632800605713473799739632878867,
-        3515906794910381201365530594248181418811879320679684239326734893975752012109,
-        148057579455448384062325089530558091463206199724854022070244924642222283388,
-        1541588700238272710315890873051237741033408846596322948443180470429851502842,
-        147013865879011936545137344076637170977925826031496203944786839068852795297,
-    ],
-    [
-        2630278389304735265620281704608245039972003761509102213752997636382302839857,
-        1359048670759642844930007747955701205155822111403150159614453244477853867621,
-        2438984569205812336319229336885480537793786558293523767186829418969842616677,
-        2137792255841525507649318539501906353254503076308308692873313199435029594138,
-        2262318076430740712267739371170174514379142884859595360065535117601097652755,
-    ],
-    [
-        2792703718581084537295613508201818489836796608902614779596544185252826291584,
-        2294173715793292812015960640392421991604150133581218254866878921346561546149,
-        2770011224727997178743274791849308200493823127651418989170761007078565678171,
-        3321642244537785916275181932172303118112488081726311374164578600576901819844,
-        3522708517589950573320671158134804505970724681591943826922697952040487655044,
-    ],
-    [
-        3417974441436557992524691506735790206623600049454586729879955931972546347402,
-        175039333145381316571259690443853067809784261609912638686739799135919647022,
-        1930713062131033273316869231148248962041053029742760224583505092759642967464,
-        2971452932574554603554350185069538580257636405419430340233233400633251319042,
-        2774781903758215341037075610938953949868289195845367046186588750871862784919,
-    ],
-    [
-        666516874137869653699423537799457099346460194092311952417454613224504932738,
-        1900462225013533249140457703727169176351786259991305560412832202759625668041,
-        2665631186082687279121709429531834469477679375137509769347092380798929714377,
-        837840745988147279235494664091280091563355097569199320366973125128366540061,
-        3391544118305848781823721719916289805455110924839794510205940718821197620955,
-    ],
-    [
-        2888553035909938253628892138500390690221493345071933642853222968481016605919,
-        3386241569867597612447901482685846444743718781330869478721963580925825915450,
-        1205126220630896984850042596877918177217334376800874965105642874206963597698,
-        3590072615491710252422997155203204584659171612188004116415640739580250394190,
-        692469013329617220154003334549812915100479873898898958632988703738125356983,
-    ],
-    [
-        1623178235190707102808841905143937367808788834203621005714003335195182126335,
-        1972826180775011489122426045504602288576507493792470102803637471568052321297,
-        3415141329098504418158191749675997877417539760075593313736376750580696083073,
-        587811537889727046473915684463981273175495137461951211739526104349163747811,
-        2523982964351069134084525951849317400231659428055762640605248929856135518199,
-    ],
-    [
-        2686176526711834950207666047281383173339057216783586039351834948812568447629,
-        983144446441739425577690449774542566745526459152966545642451764143532586964,
-        171558252019175695567663688494555626159399786667979998273792882504784080805,
-        332337623010057542760158225837623039780806442976079546879646069338600179518,
-        1264669683963885571544813806669118319675288608634733888843804451222546848295,
-    ],
-    [
-        2426165115815723668018318268486497504249785449504758403912155206515511627681,
-        11387399609384288947733630450855186629703576293221897150193655994854764608,
-        2541728569046079092074077754414781968906176513081761690404588216304985421091,
-        47685947554980329431290582269851186106577733250761848107645535357326439312,
-        472176388418187405374813530639596064799362505024895746833751173199773896628,
-    ],
-    [
-        2764298116617383397920343358525617195195060562266243809245480210157942112738,
-        486863835068754002670800862273365477867695879270721744227071001883208334054,
-        2973492686137102577527656941792991264994301121122130295965761350095846874635,
-        178385615141132702906181473263873416748818415607305319148067639744074654009,
-        533624640096756667052211553746016402543259206286603356120804827761339634127,
-    ],
-    [
-        819406716720171922688026098737835227857400444543748198788964759773510472096,
-        531851793767260921861217458033110066464894334064526987603936107947006031387,
-        3269709072483585277009748181134917746036523619604017812342933951952104134829,
-        838191718603413598040249006803464503100808192944407407147899973659013630611,
-        1574561296941310904780257598780779812250055948216417844567262310524022037406,
-    ],
-    [
-        551394354289003977607664358739006072556227894953233419144430578080352094737,
-        445076790942318675726839050057337819004979443030540904213920669247413907302,
-        1963946696292687224902912968478695543164747600779913024040878700455222386521,
-        484284614181963381509745298932402076252103342403432879800905151752488144767,
-        2240507606126946994415203252302826782042951346966859379502140796364876543253,
-    ],
-    [
-        3237135638753992982179886898758938279897590886053928839613434762582576319619,
-        2334333034701915027889533058426879447140084891006486138782876488162658230991,
-        14411091399844539897439754491034751977136685514851444574462584316609631592,
-        1264480371592407258420308876448697804787923638319277097663041109464608464284,
-        671929312763821646360589403212798993954209530574443543917757335777610372144,
-    ],
-    [
-        2513909805455654095962542944994577107405216428214873444765576238504714067396,
-        870121102846043786263357605823753628974859886859187558617096145653709171231,
-        399132620893316356411986266679786708905730068946836982293484206366500277754,
-        2855046250836680633532995284655778407402587437073106249445470889390454667586,
-        2063679741125384345396981490971605710211281905716315529671473143278849561151,
-    ],
-    [
-        1433753212258929925682201698758056443128516570551146995210728194816988328337,
-        3334984763425011856632257855270507440816274246647423607159847074739331865077,
-        337911293622078184850923533628334646725451591671907148383867096651211846605,
-        559587005295238702015018022040357402231957131094636365177008701077975941644,
-        885963059604819264377490633589388189646118257469490919900554134369512794660,
-    ],
-    [
-        1957748763518471091057032383332840331641373304981058387824598000170709016333,
-        3175295982155056798972302481564899381103533409383494814704562889625572018450,
-        498987160612401618114584726510347771865331516606886613019084323862447372555,
-        947374835104260364630171441676101001841507588423166778786886198914150312958,
-        906933977754491302438795274167251538820934378773708095543613756654712689280,
-    ],
-    [
-        2170116291766863179909957030577284618726490893598499117272497866180009722894,
-        1801335399574515889082584621772588704763181408217893911806726119813067220453,
-        1942500232535842474530840356353427989892065499159260166135596750084681859966,
-        62936080219825306823124060587235998278756755377419521154040408253893795176,
-        3091993939935137795359769774909373279950941171574748645375255810204590357753,
-    ],
-    [
-        1283528386884634267663661033944552098742115012555712906773586466375284501324,
-        1581820717639229420476069802992937438655873471854930764425841549067913106065,
-        2301986095388751633126546121528329200085681648876910655269533407603441046514,
-        2850003828037698751961753862613545302539465803982364898225617297398939302949,
-        48024691078494936445046366770271288984930221238071705874025261821606393528,
-    ],
-    [
-        1482336297033144958942154923925185950152551534403871620222916667536030875354,
-        3081177564717719643771186007689458633949181485535169123213511264603782950049,
-        3315701127039521853279746297714590495201061397709680410650043502532250578075,
-        3514407611000441301995070394422463400067690470546731164089622325748803106020,
-        368970178199930154322724953487299516224498421233447528815195701420122548537,
-    ],
-    [
-        584353160413525267849669053228533951552602295860601556035386665117717227391,
-        752038702160385294706011538400822066722189014251268673051846350397729870418,
-        3594041683498798688197194521326299097635429790757880308152971477196489335154,
-        1367902435756906062215608264424138718742854099315395230911274560900857414183,
-        1828549068951502746189364466794037234789986878381694857475972053743463890779,
-    ],
-    [
-        488172495141237210878388657234137733008417573114482400652274985829148564248,
-        962906242461930394022372340919543491337923491322497419797555620396501785566,
-        2275418085010046236619290386129138234541669589549771944697082317642065048898,
-        1966395064658902622886154686288219600816893261614483533899715888994623208964,
-        3496095878293416917311185659829821476802828534554531050412634978086916288609,
-    ],
-    [
-        3368478822390537245916137403277928093536087427951052230723275731232142463388,
-        3397410259276620127103231993277518800970669191016277541098821699302368873803,
-        2662600899665871010006649609856695263727220473364611552472965243032255906029,
-        2854831720595596992200155718152374313555878203864206470581502555480894633975,
-        2417859092561967752135741161218626374900182454089059862468108240576782064037,
-    ],
-    [
-        1064506915903089299531724594973601253341866933071158266140674053459433520889,
-        243845138053687262800349059300355289745206315347524675450796070948867090098,
-        1952653154963756062322124110012629666160000286707762177032475477295929736283,
-        2760979128531476595658428672038276216079708408852493051222686009638650156041,
-        3341178930260137001230946104398194306290005446746057811731360203227371301716,
-    ],
-    [
-        1033242545866274439991875444609632860132556714736615395036273942261573810479,
-        3567973410830779135148598005871071456943945697865168835204985462698751038238,
-        23014034649293369426970379738102323014738017168969687350330825050016457105,
-        1146720508452451012445869043641390200263192255569203352823376998708972325392,
-        2553707028642376593497768606567528232999203496079990242456254686325586089356,
-    ],
-    [
-        269729857648436699208023125596593246149228245518586029792966091405383426269,
-        276912682886955358118649215147238115764108757952690361549816619060658800027,
-        2367180947887796341722261610916728725977893583923967218630363334645641817362,
-        2398694802751362950028137620758033447242325333923222365760836442417755445092,
-        984868389243025029364428136317275892280780834039611841422502834917752411391,
-    ],
-    [
-        861353329558771468244040268521983016756775808329676883407171471251365927595,
-        2498672969617384807617108262141800974986393948110233099680635130601163654234,
-        1336236634145657673540555267430353130305889434115514586892320600753700983325,
-        980337801407886250576371882962628290239239581416378379141354256717803603922,
-        2308558359523317875952657835109605515063994805873180719205156915762120497245,
-    ],
-    [
-        2116737905426837141304542819940293184404010538896700217242374222514653607487,
-        2143995283326808680518644927890182524580312777400009071739277407358043120199,
-        3038758768133404431511594054950351369492648883179154555267474054094234927849,
-        981824005865625678985009911415023115269386212492064371040001594972137748141,
-        2427990511715778580869565219059895697855813782250850855111162965998948386792,
-    ],
-    [
-        1987498156785173719076522405088076990979859292718600184358583152317049836167,
-        1633834915134208237423144264187482951766302060112099587851513525797020813799,
-        2895454976388515752029424688351979030650325184941524820409482023485820781526,
-        941019661238578826272324221721825852217063629464317974190162904813488515671,
-        2529926057929249454763690180607677568685011502604470585585763159431333258299,
-    ],
-    [
-        2604831509257756199338105380847564711923112853239827243306562341166492672823,
-        2300475954087415591738767759767032267163723345312082546282694920273655145455,
-        1954000528502201000509342111010021527425422549437946241062907964768089317082,
-        1179936151696782249912570883839105595634344582873818018332922940963046083567,
-        3077707030301573630126144767923697288658782137457660869231140049571827937228,
-    ],
-    [
-        1062324397142900251844488719868780667589966366756786302007970554437994421840,
-        353718609497993885193404630053532608155520921625518104461520254335222009911,
-        770557645309607171206012551080400276506165720184677119001983749356594531977,
-        3043628430985247363392058521341757139056029350680498644930013342982472853636,
-        1694968537785457252742656255724723357998402478572600479401200420305593921487,
-    ],
-    [
-        539865665379093791531434211889371819368504193082947002067781562776138072582,
-        3473466148775696692731190426971123680342615414200262605154732883324298196699,
-        482783534456196983135936103604928650836406142744767857356485953118411089098,
-        2389101033971236780034779577432189630800997581132154923233144722790749715251,
-        845264223568475649981141803833883014312596504303895519674002924871878791033,
-    ],
-    [
-        3027004059915270231142566724881373969831662022738947178800901294120992473905,
-        2169574859350740480088697859610203373582027214052754592019828328614087431593,
-        3515527080764222354309565181793838292349410992793070639041305826153436624160,
-        1817926918350512904327755405973355211358017834277255662858654992240629698587,
-        1999148133619270973098477176176178514394558202995832714883251820350860287223,
-    ],
-    [
-        1203131300029280096510929599113528018338088236684405405384757591977164161039,
-        336815403657101171302040383579077521911288747438919304948637997306314852594,
-        986661060847815533035934253464295060766339947679669645818832311132001095573,
-        2291116974939980228917916563988261327966840303336559854772343651559589512651,
-        3421243089992476528970346847858594146122972226790673723411896208702859892637,
-    ],
-    [
-        1015505198663386486420800821559060487156096175034250154764824837183581949724,
-        1165880582987807286271819576391581724550686829511475839624601920297855380101,
-        904232961143172831178860280790910264843503022179578981166030973682571903458,
-        261322216292849827900157598748641385787016033372999683866859675894253115357,
-        3060676319159217735181388708455879854358158161989877552543698103915296690395,
-    ],
-    [
-        1175560144527845912984609340783959238735643215413930887771084560168082442967,
-        2813871258576082360085006002528268796351819524936446195552260262614692343332,
-        1841341101531851399935829271555098629075809587212843292354556374386667658235,
-        3076135575511709688509914361447080149794919016880133063891720256749999834767,
-        753111801049754117414662684453226478940731922961768343984187479992842213733,
-    ],
-    [
-        1405657437118503342762241742745888533114216548278983907019917904938403345580,
-        3111186124713876864436867307979940633543281080828379725576742174555539054855,
-        3404463650394703220454952017098727360005393139199301323890695570346564876407,
-        2024087816190101179456573591359233695334184711688920998987373624570170649371,
-        2770035625774572095496575568588054654502991645588385802705097377675051032967,
-    ],
-    [
-        437058215235292632621847481185406671372191763951486300610124033096831557414,
-        1345792773780982398809956395232061067669190682958320579442454533085407626029,
-        925357273912625669941681596445839316566672314870287993638671283923476231904,
-        3288133122086768300615066039539687885053110015077924175836976549020438910830,
-        666190075990703867784232802074474372379358766701681865975596503982238839889,
-    ],
-    [
-        2664898601165892062970298960258838238925231697327906221693001926762280012052,
-        2075648691532387787722427044464731934171216054855867223374228487601569118337,
-        3173725544188532489243684991828985285646224157242834030308807120745121062293,
-        1517474443612606408422643323550409253700128234157734252330869178582583531320,
-        1593950878945144789965609248470060076911813704207225832606804796819386297511,
-    ],
-    [
-        141195541167651298813588829225208004611326987855926870823948793274702167509,
-        2990187949585642302497822222637786229364740008175968941859105979392907839776,
-        2893807105405820282316438050347503569385510241526138409321358916388308586443,
-        1379719211597875648759619903854862028510320482486109668868067715175935658353,
-        2702780364788282233075255946852944970202849869091427738791947810055591218061,
-    ],
-    [
-        1825815734419326277729273926504439575157952821379179501821641713286627304656,
-        1481344458867016048625916723816339719872443766684158199301690902395849166360,
-        2014084774259125722186109781197998076881266739680534358898592778318128968629,
-        2612744185006548312909661512508122065214170543806989291921289897662387203493,
-        2486291022451231582267428921150634472835925206862678364689227838329114330247,
-    ],
-]
--- a/test/stark/poseidon/poseidon9.txt
+++ b/test/stark/poseidon/poseidon9.txt
--- a/test/stark/property.test.js
+++ b/test/stark/property.test.js
@@ -1,53 +0,0 @@
-import { deepStrictEqual, throws } from 'assert';
-import { describe, should } from 'micro-should';
-import * as starknet from '../../stark.js';
-import * as fc from 'fast-check';
-
-const FC_BIGINT = fc.bigInt(1n + 1n, starknet.CURVE.n - 1n);
-
-describe('starknet property', () => {
-  should('Point#toHex() roundtrip', () => {
-    fc.assert(
-      fc.property(FC_BIGINT, (x) => {
-        const point1 = starknet.ProjectivePoint.fromPrivateKey(x);
-        const hex = point1.toHex(true);
-        deepStrictEqual(starknet.ProjectivePoint.fromHex(hex).toHex(true), hex);
-      })
-    );
-  });
-
-  should('Signature.fromCompactHex() roundtrip', () => {
-    fc.assert(
-      fc.property(FC_BIGINT, FC_BIGINT, (r, s) => {
-        const sig = new starknet.Signature(r, s);
-        deepStrictEqual(starknet.Signature.fromCompact(sig.toCompactHex()), sig);
-      })
-    );
-  });
-
-  should('Signature.fromDERHex() roundtrip', () => {
-    fc.assert(
-      fc.property(FC_BIGINT, FC_BIGINT, (r, s) => {
-        const sig = new starknet.Signature(r, s);
-        deepStrictEqual(starknet.Signature.fromDER(sig.toDERHex()), sig);
-      })
-    );
-  });
-
-  should('verify()/should verify random signatures', () =>
-    fc.assert(
-      fc.property(FC_BIGINT, fc.hexaString({ minLength: 64, maxLength: 64 }), (privNum, msg) => {
-        const privKey = privNum.toString(16).padStart(64, '0');
-        const pub = starknet.getPublicKey(privKey);
-        const sig = starknet.sign(msg, privKey);
-        deepStrictEqual(starknet.verify(sig, msg, pub), true);
-      })
-    )
-  );
-});
-
-// ESM is broken.
-import url from 'url';
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-  should.run();
-}
--- a/test/stark/stark.test.js
+++ b/test/stark/stark.test.js
@@ -1,288 +0,0 @@
-import { deepStrictEqual, throws } from 'assert';
-import { describe, should } from 'micro-should';
-import { utf8ToBytes } from '@noble/hashes/utils';
-import * as bip32 from '@scure/bip32';
-import * as bip39 from '@scure/bip39';
-import * as starknet from '../../stark.js';
-import { default as sigVec } from './fixtures/rfc6979_signature_test_vector.json' assert { type: 'json' };
-import { default as precomputedKeys } from './fixtures/keys_precomputed.json' assert { type: 'json' };
-
-describe('starknet', () => {
-  should('custom keccak', () => {
-    const value = starknet.keccak(utf8ToBytes('hello'));
-    deepStrictEqual(value, 0x8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8n);
-    deepStrictEqual(value < 2n ** 250n, true);
-  });
-
-  should('RFC6979', () => {
-    for (const msg of sigVec.messages) {
-      const { r, s } = starknet.sign(msg.hash, sigVec.private_key);
-      // const { r, s } = starknet.Signature.fromDER(sig);
-      deepStrictEqual(r.toString(10), msg.r);
-      deepStrictEqual(s.toString(10), msg.s);
-    }
-  });
-
-  should('Signatures', () => {
-    const vectors = [
-      {
-        // Message hash of length 61.
-        msg: 'c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47',
-        r: '5f496f6f210b5810b2711c74c15c05244dad43d18ecbbdbe6ed55584bc3b0a2',
-        s: '4e8657b153787f741a67c0666bad6426c3741b478c8eaa3155196fc571416f3',
-      },
-      {
-        // Message hash of length 61, with leading zeros.
-        msg: '00c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47',
-        r: '5f496f6f210b5810b2711c74c15c05244dad43d18ecbbdbe6ed55584bc3b0a2',
-        s: '4e8657b153787f741a67c0666bad6426c3741b478c8eaa3155196fc571416f3',
-      },
-      {
-        // Message hash of length 62.
-        msg: 'c465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47a',
-        r: '233b88c4578f0807b4a7480c8076eca5cfefa29980dd8e2af3c46a253490e9c',
-        s: '28b055e825bc507349edfb944740a35c6f22d377443c34742c04e0d82278cf1',
-      },
-      {
-        // Message hash of length 63.
-        msg: '7465dd6b1bbffdb05442eb17f5ca38ad1aa78a6f56bf4415bdee219114a47a1',
-        r: 'b6bee8010f96a723f6de06b5fa06e820418712439c93850dd4e9bde43ddf',
-        s: '1a3d2bc954ed77e22986f507d68d18115fa543d1901f5b4620db98e2f6efd80',
-      },
-    ];
-    const privateKey = '2dccce1da22003777062ee0870e9881b460a8b7eca276870f57c601f182136c';
-    const publicKey = starknet.getPublicKey(privateKey);
-    for (const v of vectors) {
-      const sig = starknet.sign(v.msg, privateKey);
-      const { r, s } = sig;
-      // const { r, s } = starknet.Signature.fromDER(sig);
-      deepStrictEqual(r.toString(16), v.r, 'r equality');
-      deepStrictEqual(s.toString(16), v.s, 's equality');
-      deepStrictEqual(starknet.verify(sig, v.msg, publicKey), true, 'verify');
-    }
-  });
-
-  should('Invalid signatures', () => {
-    /*
-
-    it('should not verify invalid signature inputs lengths', () => {
-      const ecOrder = starkwareCrypto.ec.n;
-      const {maxEcdsaVal} = starkwareCrypto;
-      const maxMsgHash = maxEcdsaVal.sub(oneBn);
-      const maxR = maxEcdsaVal.sub(oneBn);
-      const maxS = ecOrder.sub(oneBn).sub(oneBn);
-      const maxStarkKey = maxEcdsaVal.sub(oneBn);
-
-      // Test invalid message length.
-      expect(() =>
-        starkwareCrypto.verify(maxStarkKey, maxMsgHash.add(oneBn).toString(16), {
-          r: maxR,
-          s: maxS
-        })
-      ).to.throw('Message not signable, invalid msgHash length.');
-      // Test invalid r length.
-      expect(() =>
-        starkwareCrypto.verify(maxStarkKey, maxMsgHash.toString(16), {
-          r: maxR.add(oneBn),
-          s: maxS
-        })
-      ).to.throw('Message not signable, invalid r length.');
-      // Test invalid w length.
-      expect(() =>
-        starkwareCrypto.verify(maxStarkKey, maxMsgHash.toString(16), {
-          r: maxR,
-          s: maxS.add(oneBn)
-        })
-      ).to.throw('Message not signable, invalid w length.');
-      // Test invalid s length.
-      expect(() =>
-        starkwareCrypto.verify(maxStarkKey, maxMsgHash.toString(16), {
-          r: maxR,
-          s: maxS.add(oneBn).add(oneBn)
-        })
-      ).to.throw('Message not signable, invalid s length.');
-    });
-
-    it('should not verify invalid signatures', () => {
-      const privKey = generateRandomStarkPrivateKey();
-      const keyPair = starkwareCrypto.ec.keyFromPrivate(privKey, 'hex');
-      const keyPairPub = starkwareCrypto.ec.keyFromPublic(
-        keyPair.getPublic(),
-        'BN'
-      );
-      const msgHash = new BN(randomHexString(61));
-      const msgSignature = starkwareCrypto.sign(keyPair, msgHash);
-
-      // Test invalid public key.
-      const invalidKeyPairPub = starkwareCrypto.ec.keyFromPublic(
-        {x: keyPairPub.pub.getX().add(oneBn), y: keyPairPub.pub.getY()},
-        'BN'
-      );
-      expect(
-        starkwareCrypto.verify(
-          invalidKeyPairPub,
-          msgHash.toString(16),
-          msgSignature
-        )
-      ).to.be.false;
-      // Test invalid message.
-      expect(
-        starkwareCrypto.verify(
-          keyPair,
-          msgHash.add(oneBn).toString(16),
-          msgSignature
-        )
-      ).to.be.false;
-      expect(
-        starkwareCrypto.verify(
-          keyPairPub,
-          msgHash.add(oneBn).toString(16),
-          msgSignature
-        )
-      ).to.be.false;
-      // Test invalid r.
-      msgSignature.r.iadd(oneBn);
-      expect(starkwareCrypto.verify(keyPair, msgHash.toString(16), msgSignature))
-        .to.be.false;
-      expect(
-        starkwareCrypto.verify(keyPairPub, msgHash.toString(16), msgSignature)
-      ).to.be.false;
-      // Test invalid s.
-      msgSignature.r.isub(oneBn);
-      msgSignature.s.iadd(oneBn);
-      expect(starkwareCrypto.verify(keyPair, msgHash.toString(16), msgSignature))
-        .to.be.false;
-      expect(
-        starkwareCrypto.verify(keyPairPub, msgHash.toString(16), msgSignature)
-      ).to.be.false;
-    });
-  });
-    */
-  });
-
-  should('Pedersen', () => {
-    deepStrictEqual(
-      starknet.pedersen(
-        '0x3d937c035c878245caf64531a5756109c53068da139362728feb561405371cb',
-        '0x208a0a10250e382e1e4bbe2880906c2791bf6275695e02fbbc6aeff9cd8b31a'
-      ),
-      '0x30e480bed5fe53fa909cc0f8c4d99b8f9f2c016be4c41e13a4848797979c662'
-    );
-    deepStrictEqual(
-      starknet.pedersen(
-        '0x58f580910a6ca59b28927c08fe6c43e2e303ca384badc365795fc645d479d45',
-        '0x78734f65a067be9bdb39de18434d71e79f7b6466a4b66bbd979ab9e7515fe0b'
-      ),
-      '0x68cc0b76cddd1dd4ed2301ada9b7c872b23875d5ff837b3a87993e0d9996b87'
-    );
-  });
-
-  should('Hash chain', () => {
-    deepStrictEqual(starknet.hashChain([1, 2, 3]), starknet.pedersen(1, starknet.pedersen(2, 3)));
-  });
-
-  should('Key grinding', () => {
-    deepStrictEqual(
-      starknet.grindKey('86F3E7293141F20A8BAFF320E8EE4ACCB9D4A4BF2B4D295E8CEE784DB46E0519'),
-      '5c8c8683596c732541a59e03007b2d30dbbbb873556fe65b5fb63c16688f941'
-    );
-    // Loops more than once (verified manually)
-    deepStrictEqual(
-      starknet.grindKey('94F3E7293141F20A8BAFF320E8EE4ACCB9D4A4BF2B4D295E8CEE784DB46E0595'),
-      '33880b9aba464c1c01c9f8f5b4fc1134698f9b0a8d18505cab6cdd34d93dc02'
-    );
-  });
-
-  should('Private to stark key', () => {
-    deepStrictEqual(
-      starknet.getStarkKey('0x178047D3869489C055D7EA54C014FFB834A069C9595186ABE04EA4D1223A03F'),
-      '0x1895a6a77ae14e7987b9cb51329a5adfb17bd8e7c638f92d6892d76e51cebcf'
-    );
-    for (const [privKey, expectedPubKey] of Object.entries(precomputedKeys)) {
-      deepStrictEqual(starknet.getStarkKey(privKey), expectedPubKey);
-    }
-  });
-
-  should('Private stark key from eth signature', () => {
-    const ethSignature =
-      '0x21fbf0696d5e0aa2ef41a2b4ffb623bcaf070461d61cf7251c74161f82fec3a43' +
-      '70854bc0a34b3ab487c1bc021cd318c734c51ae29374f2beb0e6f2dd49b4bf41c';
-    deepStrictEqual(
-      starknet.ethSigToPrivate(ethSignature),
-      '766f11e90cd7c7b43085b56da35c781f8c067ac0d578eabdceebc4886435bda'
-    );
-  });
-
-  should('Key derivation', () => {
-    const layer = 'starkex';
-    const application = 'starkdeployement';
-    const mnemonic =
-      'range mountain blast problem vibrant void vivid doctor cluster enough melody ' +
-      'salt layer language laptop boat major space monkey unit glimpse pause change vibrant';
-    const ethAddress = '0xa4864d977b944315389d1765ffa7e66F74ee8cd7';
-    const VECTORS = [
-      {
-        index: 0,
-        path: "m/2645'/579218131'/891216374'/1961790679'/2135936222'/0",
-        privateKey: '6cf0a8bf113352eb863157a45c5e5567abb34f8d32cddafd2c22aa803f4892c',
-      },
-      {
-        index: 7,
-        path: "m/2645'/579218131'/891216374'/1961790679'/2135936222'/7",
-        privateKey: '341751bdc42841da35ab74d13a1372c1f0250617e8a2ef96034d9f46e6847af',
-      },
-      {
-        index: 598,
-        path: "m/2645'/579218131'/891216374'/1961790679'/2135936222'/598",
-        privateKey: '41a4d591a868353d28b7947eb132aa4d00c4a022743689ffd20a3628d6ca28c',
-      },
-    ];
-    const hd = bip32.HDKey.fromMasterSeed(bip39.mnemonicToSeedSync(mnemonic));
-    for (const { index, path, privateKey } of VECTORS) {
-      const realPath = starknet.getAccountPath(layer, application, ethAddress, index);
-      deepStrictEqual(realPath, path);
-      deepStrictEqual(starknet.grindKey(hd.derive(realPath).privateKey), privateKey);
-    }
-  });
-
-  // Verified against starknet.js
-  should('Starknet.js cross-tests', () => {
-    const privateKey = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
-    // NOTE: there is no compressed keys here, getPubKey returns stark-key (which is schnorr-like X coordinate)
-    // But it is not used in signing/verifying
-    deepStrictEqual(
-      starknet.getStarkKey(privateKey),
-      '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745'
-    );
-    const msgHash = '0x6d1706bd3d1ba7c517be2a2a335996f63d4738e2f182144d078a1dd9997062e';
-    const sig = starknet.sign(msgHash, privateKey);
-    const { r, s } = sig;
-
-    deepStrictEqual(
-      r.toString(),
-      '1427981024487605678086498726488552139932400435436186597196374630267616399345'
-    );
-    deepStrictEqual(
-      s.toString(),
-      '1853664302719670721837677288395394946745467311923401353018029119631574115563'
-    );
-    const hashMsg2 = starknet.pedersen(
-      '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745',
-      '1'
-    );
-    deepStrictEqual(hashMsg2, '0x2b0d4d43acce8ff68416f667f92ec7eab2b96f1d2224abd4d9d4d1e7fa4bb00');
-    const pubKey =
-      '04033f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d997450319d0f53f6ca077c4fa5207819144a2a4165daef6ee47a7c1d06c0dcaa3e456';
-    const sig2 = new starknet.Signature(
-      558858382392827003930138586379728730695763862039474863361948210004201119180n,
-      2440689354481625417078677634625227600823892606910345662891037256374285369343n
-    );
-    deepStrictEqual(starknet.verify(sig2.toDERHex(), hashMsg2, pubKey), true);
-  });
-});
-
-// ESM is broken.
-import url from 'url';
-if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
-  should.run();
-}
--- a/tsconfig.esm.json
+++ b/tsconfig.esm.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "outDir": "esm",
+        "target": "es2020",
+        "module": "es6",
+        "moduleResolution": "node16",
+        "noUnusedLocals": true,
+        "sourceMap": true,
+        "baseUrl": ".",
+        "paths": {
+            "@noble/hashes/crypto": [ "src/crypto" ]
+        },
+    },
+    "include": ["src"],
+    "exclude": [
+        "node_modules",
+        "lib",
+    ],
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -7,8 +7,8 @@
        "outDir": ".",
        "target": "es2020",
        "lib": ["es2020"], // Set explicitly to remove DOM
-        "module": "es6",
-        "moduleResolution": "node16",
+        "module": "commonjs",
+        "moduleResolution": "node",
        "noUnusedLocals": true,
        "baseUrl": ".",
    },
@@ -17,4 +17,4 @@
        "node_modules",
        "*.d.ts"
    ],
-}
+}
Author	SHA1	Message	Date
Paul Miller	19f04a4c1c	Release 0.9.1.	2023-03-31 10:02:05 +02:00
Paul Miller	d0c3bee4de	weierstrass, edwards: make points expose typescript x, y	2023-03-30 09:20:35 +02:00
Paul Miller	4244f97d38	bls: get rid of bigint literals. gh-22	2023-03-28 19:01:42 +02:00
Paul Miller	618508d32c	weierstrass, edwards: get rid of bigint literals. Closes gh-22	2023-03-28 19:01:00 +02:00
Paul Miller	3936449e7b	edwards: add toRawBytes to ts type	2023-03-26 15:54:04 +02:00
Paul Miller	0ffa38db6b	Release 0.9.0.	2023-03-24 11:12:02 +01:00
Paul Miller	c4c580edc0	Bump devdeps	2023-03-24 11:06:48 +01:00
Paul Miller	abe8adac7b	README	2023-03-24 10:25:03 +01:00
Paul Miller	4fd2ae82b6	readme	2023-03-21 07:27:45 +01:00
Paul Miller	e2411f7dfd	modular: add comment	2023-03-21 07:25:09 +01:00
Paul Miller	cb61e4f292	readme	2023-03-21 07:25:01 +01:00
Paul Miller	bb875791bd	docs	2023-03-21 07:11:17 +01:00
Paul Miller	3df2553ced	Docs	2023-03-21 07:02:07 +01:00
Paul Miller	8fabc7ff06	All files: rename Fp to Field	2023-03-21 06:51:18 +01:00
Paul Miller	f3c21eb347	weierstrass: make weierstrassPoints fromBytes / toBytes optional	2023-03-21 05:51:10 +01:00
Paul Miller	a8b8192714	Add CURVE.p param	2023-03-21 03:06:06 +01:00
Paul Miller	1c6aa07ff7	Release 0.8.3.	2023-03-16 19:41:20 +01:00
Paul Miller	e110237298	readme	2023-03-16 19:17:34 +01:00
Paul Miller	45393db807	Bump docs	2023-03-16 19:05:33 +01:00
Paul Miller	acc3a9dc4d	Bump devdep types/node	2023-03-16 18:52:03 +01:00
Paul Miller	9295b0dbae	Upgrade to Typescript 5	2023-03-16 18:49:48 +01:00
Paul Miller	5784ef23f6	Release 0.8.2.	2023-03-14 00:44:02 +01:00
Paul Miller	ef55efe842	Fix common.js build	2023-03-14 00:42:40 +01:00
Paul Miller	1cfd6a76ca	Release 0.8.1.	2023-03-14 00:40:05 +01:00
Paul Miller	89f81b2204	pkg.json: improve bench, clean scripts	2023-03-14 00:39:21 +01:00
Paul Miller	d77ac16f51	Bring back common.js for now. Need more thorough work with consumers	2023-03-14 00:32:09 +01:00
Paul Miller	fe68da61f6	Move stark curve to micro-starknet	2023-03-10 20:18:05 +01:00
Paul Miller	32c0841bed	Add Trail of Bits audit	2023-03-10 01:09:49 +01:00