@semaphore-protocol/proof 4.0.0-alpha.6 → 4.0.0-alpha.8

package/README.md

@@ -73,8 +73,8 @@ yarn add @semaphore-protocol/identity @semaphore-protocol/group @semaphore-proto
 \# **generateProof**(
 identity: _Identity_,
 group: _Group_,
-message: _BytesLike | Hexable | number | bigint_,
-scope: _BytesLike | Hexable | number | bigint_,
+message: _BigNumberish_ | _Uint8Array_ | string,
+scope: _BigNumberish_ | _Uint8Array_ | string,
 merkleTreeDepth: _number_,
 snarkArtifacts?: _SnarkArtifacts_
 ): Promise\<_SemaphoreProof_>
@@ -83,23 +83,23 @@ snarkArtifacts?: _SnarkArtifacts_
 import { Identity } from "@semaphore-protocol/identity"
 import { Group } from "@semaphore-protocol/group"
 import { generateProof } from "@semaphore-protocol/proof"
-import { utils } from "ethers"
 
-const identity = new Identity()
-const group = new Group()
+const identity1 = new Identity()
+const identity2 = new Identity()
+const identity3 = new Identity()
 
-const scope = utils.formatBytes32String("Topic")
-const message = utils.formatBytes32String("Hello world")
+const group = new Group([identity1.commitment, identity2.commitment, identity3.commitment])
 
-group.addMembers([...identityCommitments, identity.generateCommitment()])
+const message = "Hello world"
+const scope = "Semaphore"
 
-const proof1 = await generateProof(identity, group, message, scope)
+const proof1 = await generateProof(identity1, group, message, scope)
 
 // You can also specify the maximum tree depth supported by the proof.
-const proof2 = await generateProof(identity, group, message, scope, 20)
+const proof2 = await generateProof(identity2, group, message, scope, 20)
 
 // You can also specify the default zkey/wasm files.
-const proof3 = await generateProof(identity, group, message, scope, 20, {
+const proof3 = await generateProof(identity3, group, message, scope, 20, {
     wasmFilePath: "./semaphore.wasm",
     zkeyFilePath: "./semaphore.zkey"
 })

package/dist/index.browser.js

@@ -1,15 +1,15 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-alpha.6
+ * @version 4.0.0-alpha.8
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/proof}
 */
-import { BigNumber } from '@ethersproject/bignumber';
 import { groth16 } from 'snarkjs';
-import { zeroPad } from '@ethersproject/bytes';
-import { keccak256 } from '@ethersproject/keccak256';
+import { keccak256 } from 'ethers/crypto';
+import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
+import { encodeBytes32String } from 'ethers/abi';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -99,9 +99,7 @@ function getSnarkArtifacts(treeDepth) {
  * @returns The message digest.
  */
 function hash(message) {
-    message = BigNumber.from(message).toTwos(256).toHexString();
-    message = zeroPad(message, 32);
-    return (BigInt(keccak256(message)) >> BigInt(8)).toString();
+    return (BigInt(keccak256(toBeHex(message, 32))) >> BigInt(8)).toString();
 }
 
 /**
@@ -122,12 +120,24 @@ function packPoints(proof) {
     ];
 }
 
+function toBigInt(value) {
+    try {
+        return toBigInt$1(value);
+    }
+    catch (error) {
+        if (typeof value === "string") {
+            return toBigInt$1(encodeBytes32String(value));
+        }
+        throw TypeError(error.message);
+    }
+}
+
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
+ * @param scope The Semaphore scope.
+ * @param message The Semaphore message.
  * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
@@ -138,6 +148,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    message = toBigInt(message);
+                    scope = toBigInt(scope);
                     if ("siblings" in groupOrMerkleProof) {
                         merkleProof = groupOrMerkleProof;
                     }
@@ -182,8 +194,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                             merkleTreeDepth: merkleTreeDepth,
                             merkleTreeRoot: publicSignals[0],
                             nullifier: publicSignals[1],
-                            message: BigNumber.from(message).toString(),
-                            scope: BigNumber.from(scope).toString(),
+                            message: message.toString(),
+                            scope: scope.toString(),
                             points: packPoints(proof)
                         }];
             }

package/dist/index.node.cjs

@@ -1,6 +1,6 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-alpha.6
+ * @version 4.0.0-alpha.8
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
@@ -8,13 +8,16 @@
 */
 'use strict';
 
-var bignumber = require('@ethersproject/bignumber');
 var snarkjs = require('snarkjs');
-var download = require('download');
-var fs = require('fs');
-var tmp = require('tmp');
-var bytes = require('@ethersproject/bytes');
-var keccak256 = require('@ethersproject/keccak256');
+var node_fs = require('node:fs');
+var promises$1 = require('node:fs/promises');
+var os = require('node:os');
+var node_path = require('node:path');
+var node_stream = require('node:stream');
+var promises = require('node:stream/promises');
+var crypto = require('ethers/crypto');
+var utils = require('ethers/utils');
+var abi = require('ethers/abi');
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -87,6 +90,30 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function download(url, outputPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, dir, fileStream;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch(url)];
+                case 1:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Failed to fetch ".concat(url, ": ").concat(response.statusText));
+                    }
+                    dir = node_path.dirname(outputPath);
+                    return [4 /*yield*/, promises$1.mkdir(dir, { recursive: true })];
+                case 2:
+                    _a.sent();
+                    fileStream = node_fs.createWriteStream(outputPath);
+                    return [4 /*yield*/, promises.finished(node_stream.Readable.fromWeb(response.body).pipe(fileStream))];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
 function getSnarkArtifacts(treeDepth) {
     return __awaiter(this, void 0, void 0, function () {
         var tmpDir, tmpPath;
@@ -94,12 +121,12 @@ function getSnarkArtifacts(treeDepth) {
             switch (_a.label) {
                 case 0:
                     tmpDir = "semaphore-proof";
-                    tmpPath = "".concat(tmp.tmpdir, "/").concat(tmpDir, "-").concat(treeDepth);
-                    if (!(!fs.existsSync(tmpPath) || fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), tmpPath)];
+                    tmpPath = "".concat(os.tmpdir(), "/").concat(tmpDir, "-").concat(treeDepth);
+                    if (!(!node_fs.existsSync(tmpPath) || node_fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), "".concat(tmpPath, "/semaphore.wasm"))];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), tmpPath)];
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), "".concat(tmpPath, "/semaphore.zkey"))];
                 case 2:
                     _a.sent();
                     _a.label = 3;
@@ -118,9 +145,7 @@ function getSnarkArtifacts(treeDepth) {
  * @returns The message digest.
  */
 function hash(message) {
-    message = bignumber.BigNumber.from(message).toTwos(256).toHexString();
-    message = bytes.zeroPad(message, 32);
-    return (BigInt(keccak256.keccak256(message)) >> BigInt(8)).toString();
+    return (BigInt(crypto.keccak256(utils.toBeHex(message, 32))) >> BigInt(8)).toString();
 }
 
 /**
@@ -141,12 +166,24 @@ function packPoints(proof) {
     ];
 }
 
+function toBigInt(value) {
+    try {
+        return utils.toBigInt(value);
+    }
+    catch (error) {
+        if (typeof value === "string") {
+            return utils.toBigInt(abi.encodeBytes32String(value));
+        }
+        throw TypeError(error.message);
+    }
+}
+
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
+ * @param scope The Semaphore scope.
+ * @param message The Semaphore message.
  * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
@@ -157,6 +194,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    message = toBigInt(message);
+                    scope = toBigInt(scope);
                     if ("siblings" in groupOrMerkleProof) {
                         merkleProof = groupOrMerkleProof;
                     }
@@ -201,8 +240,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                             merkleTreeDepth: merkleTreeDepth,
                             merkleTreeRoot: publicSignals[0],
                             nullifier: publicSignals[1],
-                            message: bignumber.BigNumber.from(message).toString(),
-                            scope: bignumber.BigNumber.from(scope).toString(),
+                            message: message.toString(),
+                            scope: scope.toString(),
                             points: packPoints(proof)
                         }];
             }

package/dist/index.node.js

@@ -1,18 +1,21 @@
 /**
  * @module @semaphore-protocol/proof
- * @version 4.0.0-alpha.6
+ * @version 4.0.0-alpha.8
  * @file A library to generate and verify Semaphore proofs.
  * @copyright Ethereum Foundation 2024
  * @license MIT
  * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/proof}
 */
-import { BigNumber } from '@ethersproject/bignumber';
 import { groth16 } from 'snarkjs';
-import download from 'download';
-import fs from 'fs';
-import tmp from 'tmp';
-import { zeroPad } from '@ethersproject/bytes';
-import { keccak256 } from '@ethersproject/keccak256';
+import { existsSync, readdirSync, createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import os from 'node:os';
+import { dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+import { keccak256 } from 'ethers/crypto';
+import { toBeHex, toBigInt as toBigInt$1 } from 'ethers/utils';
+import { encodeBytes32String } from 'ethers/abi';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -85,6 +88,30 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+function download(url, outputPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var response, dir, fileStream;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fetch(url)];
+                case 1:
+                    response = _a.sent();
+                    if (!response.ok) {
+                        throw new Error("Failed to fetch ".concat(url, ": ").concat(response.statusText));
+                    }
+                    dir = dirname(outputPath);
+                    return [4 /*yield*/, mkdir(dir, { recursive: true })];
+                case 2:
+                    _a.sent();
+                    fileStream = createWriteStream(outputPath);
+                    return [4 /*yield*/, finished(Readable.fromWeb(response.body).pipe(fileStream))];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
 function getSnarkArtifacts(treeDepth) {
     return __awaiter(this, void 0, void 0, function () {
         var tmpDir, tmpPath;
@@ -92,12 +119,12 @@ function getSnarkArtifacts(treeDepth) {
             switch (_a.label) {
                 case 0:
                     tmpDir = "semaphore-proof";
-                    tmpPath = "".concat(tmp.tmpdir, "/").concat(tmpDir, "-").concat(treeDepth);
-                    if (!(!fs.existsSync(tmpPath) || fs.readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), tmpPath)];
+                    tmpPath = "".concat(os.tmpdir(), "/").concat(tmpDir, "-").concat(treeDepth);
+                    if (!(!existsSync(tmpPath) || readdirSync(tmpPath).length !== 2)) return [3 /*break*/, 3];
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.wasm"), "".concat(tmpPath, "/semaphore.wasm"))];
                 case 1:
                     _a.sent();
-                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), tmpPath)];
+                    return [4 /*yield*/, download("https://semaphore.cedoor.dev/artifacts/".concat(treeDepth, "/semaphore.zkey"), "".concat(tmpPath, "/semaphore.zkey"))];
                 case 2:
                     _a.sent();
                     _a.label = 3;
@@ -116,9 +143,7 @@ function getSnarkArtifacts(treeDepth) {
  * @returns The message digest.
  */
 function hash(message) {
-    message = BigNumber.from(message).toTwos(256).toHexString();
-    message = zeroPad(message, 32);
-    return (BigInt(keccak256(message)) >> BigInt(8)).toString();
+    return (BigInt(keccak256(toBeHex(message, 32))) >> BigInt(8)).toString();
 }
 
 /**
@@ -139,12 +164,24 @@ function packPoints(proof) {
     ];
 }
 
+function toBigInt(value) {
+    try {
+        return toBigInt$1(value);
+    }
+    catch (error) {
+        if (typeof value === "string") {
+            return toBigInt$1(encodeBytes32String(value));
+        }
+        throw TypeError(error.message);
+    }
+}
+
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
+ * @param scope The Semaphore scope.
+ * @param message The Semaphore message.
  * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
@@ -155,6 +192,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
+                    message = toBigInt(message);
+                    scope = toBigInt(scope);
                     if ("siblings" in groupOrMerkleProof) {
                         merkleProof = groupOrMerkleProof;
                     }
@@ -199,8 +238,8 @@ function generateProof(identity, groupOrMerkleProof, message, scope, merkleTreeD
                             merkleTreeDepth: merkleTreeDepth,
                             merkleTreeRoot: publicSignals[0],
                             nullifier: publicSignals[1],
-                            message: BigNumber.from(message).toString(),
-                            scope: BigNumber.from(scope).toString(),
+                            message: message.toString(),
+                            scope: scope.toString(),
                             points: packPoints(proof)
                         }];
             }

package/dist/types/generate-proof.d.ts

@@ -1,15 +1,14 @@
-import { BytesLike, Hexable } from "@ethersproject/bytes";
 import type { Group, MerkleProof } from "@semaphore-protocol/group";
 import type { Identity } from "@semaphore-protocol/identity";
-import { SemaphoreProof, SnarkArtifacts } from "./types";
+import { BigNumberish, SemaphoreProof, SnarkArtifacts } from "./types";
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
+ * @param scope The Semaphore scope.
+ * @param message The Semaphore message.
  * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
  */
-export default function generateProof(identity: Identity, groupOrMerkleProof: Group | MerkleProof, message: BytesLike | Hexable | number | bigint, scope: BytesLike | Hexable | number | bigint, merkleTreeDepth?: number, snarkArtifacts?: SnarkArtifacts): Promise<SemaphoreProof>;
+export default function generateProof(identity: Identity, groupOrMerkleProof: Group | MerkleProof, message: BigNumberish | Uint8Array | string, scope: BigNumberish | Uint8Array | string, merkleTreeDepth?: number, snarkArtifacts?: SnarkArtifacts): Promise<SemaphoreProof>;

package/dist/types/hash.d.ts

@@ -1,8 +1,8 @@
-import { BytesLike, Hexable } from "@ethersproject/bytes";
 import { NumericString } from "snarkjs";
+import { BigNumberish } from "./types";
 /**
  * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
  * @param message The message to be hashed.
  * @returns The message digest.
  */
-export default function hash(message: BytesLike | Hexable | number | bigint): NumericString;
+export default function hash(message: BigNumberish): NumericString;

package/dist/types/to-bigint.d.ts

@@ -0,0 +1,2 @@
+import { BigNumberish } from "./types";
+export default function toBigInt(value: BigNumberish | Uint8Array | string): bigint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semaphore-protocol/proof",
-  "version": "4.0.0-alpha.6",
+  "version": "4.0.0-alpha.8",
   "description": "A library to generate and verify Semaphore proofs.",
   "type": "module",
   "license": "MIT",
@@ -38,7 +38,6 @@
     "access": "public"
   },
   "devDependencies": {
-    "@ethersproject/strings": "^5.7.0",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-json": "^6.1.0",
     "@types/download": "^8.0.5",
@@ -50,16 +49,12 @@
     "rollup-plugin-typescript2": "^0.36.0"
   },
   "peerDependencies": {
-    "@semaphore-protocol/group": "4.0.0-alpha.6",
-    "@semaphore-protocol/identity": "4.0.0-alpha.6"
+    "@semaphore-protocol/group": "4.0.0-alpha.8",
+    "@semaphore-protocol/identity": "4.0.0-alpha.8"
   },
   "dependencies": {
-    "@ethersproject/bignumber": "5.7.0",
-    "@ethersproject/bytes": "5.7.0",
-    "@ethersproject/keccak256": "5.7.0",
     "@types/snarkjs": "0.7.8",
-    "download": "8.0.0",
-    "snarkjs": "0.7.3",
-    "tmp": "0.2.1"
+    "ethers": "6.10.0",
+    "snarkjs": "0.7.3"
   }
 }

package/src/generate-proof.ts

@@ -1,19 +1,18 @@
-import { BigNumber } from "@ethersproject/bignumber"
-import { BytesLike, Hexable } from "@ethersproject/bytes"
 import type { Group, MerkleProof } from "@semaphore-protocol/group"
 import type { Identity } from "@semaphore-protocol/identity"
 import { NumericString, groth16 } from "snarkjs"
 import getSnarkArtifacts from "./get-snark-artifacts.node"
 import hash from "./hash"
 import packPoints from "./pack-points"
-import { SemaphoreProof, SnarkArtifacts } from "./types"
+import { BigNumberish, SemaphoreProof, SnarkArtifacts } from "./types"
+import toBigInt from "./to-bigint"
 
 /**
  * Generates a Semaphore proof.
  * @param identity The Semaphore identity.
  * @param groupOrMerkleProof The Semaphore group or its Merkle proof.
- * @param scope The external nullifier.
- * @param message The Semaphore signal.
+ * @param scope The Semaphore scope.
+ * @param message The Semaphore message.
  * @param merkleTreeDepth The depth of the tree with which the circuit was compiled.
  * @param snarkArtifacts The SNARK artifacts.
  * @returns The Semaphore proof ready to be verified.
@@ -21,11 +20,14 @@ import { SemaphoreProof, SnarkArtifacts } from "./types"
 export default async function generateProof(
     identity: Identity,
     groupOrMerkleProof: Group | MerkleProof,
-    message: BytesLike | Hexable | number | bigint,
-    scope: BytesLike | Hexable | number | bigint,
+    message: BigNumberish | Uint8Array | string,
+    scope: BigNumberish | Uint8Array | string,
     merkleTreeDepth?: number,
     snarkArtifacts?: SnarkArtifacts
 ): Promise<SemaphoreProof> {
+    message = toBigInt(message)
+    scope = toBigInt(scope)
+
     let merkleProof
 
     if ("siblings" in groupOrMerkleProof) {
@@ -46,7 +48,6 @@ export default async function generateProof(
     }
 
     // If the Snark artifacts are not defined they will be automatically downloaded.
-    /* istanbul ignore next */
     if (!snarkArtifacts) {
         snarkArtifacts = await getSnarkArtifacts(merkleTreeDepth)
     }
@@ -81,8 +82,8 @@ export default async function generateProof(
         merkleTreeDepth,
         merkleTreeRoot: publicSignals[0],
         nullifier: publicSignals[1],
-        message: BigNumber.from(message).toString() as NumericString,
-        scope: BigNumber.from(scope).toString() as NumericString,
+        message: message.toString() as NumericString,
+        scope: scope.toString() as NumericString,
         points: packPoints(proof)
     }
 }

package/src/get-snark-artifacts.node.ts

@@ -1,16 +1,40 @@
 /* istanbul ignore file */
-import download from "download"
-import fs from "fs"
-import tmp from "tmp"
+import { createWriteStream, existsSync, readdirSync } from "node:fs"
+import { mkdir } from "node:fs/promises"
+import os from "node:os"
+import { dirname } from "node:path"
+import { Readable } from "node:stream"
+import { finished } from "node:stream/promises"
 import { SnarkArtifacts } from "./types"
 
+async function download(url: string, outputPath: string) {
+    const response = await fetch(url)
+
+    if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.statusText}`)
+    }
+
+    // Ensure the directory exists.
+    const dir = dirname(outputPath)
+    await mkdir(dir, { recursive: true })
+
+    const fileStream = createWriteStream(outputPath)
+    await finished(Readable.fromWeb(response.body as any).pipe(fileStream))
+}
+
 export default async function getSnarkArtifacts(treeDepth: number): Promise<SnarkArtifacts> {
     const tmpDir = "semaphore-proof"
-    const tmpPath = `${tmp.tmpdir}/${tmpDir}-${treeDepth}`
+    const tmpPath = `${os.tmpdir()}/${tmpDir}-${treeDepth}`
 
-    if (!fs.existsSync(tmpPath) || fs.readdirSync(tmpPath).length !== 2) {
-        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.wasm`, tmpPath)
-        await download(`https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.zkey`, tmpPath)
+    if (!existsSync(tmpPath) || readdirSync(tmpPath).length !== 2) {
+        await download(
+            `https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.wasm`,
+            `${tmpPath}/semaphore.wasm`
+        )
+        await download(
+            `https://semaphore.cedoor.dev/artifacts/${treeDepth}/semaphore.zkey`,
+            `${tmpPath}/semaphore.zkey`
+        )
     }
 
     return {

package/src/hash.ts

@@ -1,16 +1,13 @@
-import { BigNumber } from "@ethersproject/bignumber"
-import { BytesLike, Hexable, zeroPad } from "@ethersproject/bytes"
-import { keccak256 } from "@ethersproject/keccak256"
+import { keccak256 } from "ethers/crypto"
+import { toBeHex } from "ethers/utils"
 import { NumericString } from "snarkjs"
+import { BigNumberish } from "./types"
 
 /**
  * Creates a keccak256 hash of a message compatible with the SNARK scalar modulus.
  * @param message The message to be hashed.
  * @returns The message digest.
  */
-export default function hash(message: BytesLike | Hexable | number | bigint): NumericString {
-    message = BigNumber.from(message).toTwos(256).toHexString()
-    message = zeroPad(message, 32)
-
-    return (BigInt(keccak256(message)) >> BigInt(8)).toString() as NumericString
+export default function hash(message: BigNumberish): NumericString {
+    return (BigInt(keccak256(toBeHex(message, 32))) >> BigInt(8)).toString()
 }

package/src/to-bigint.ts

@@ -0,0 +1,15 @@
+import { encodeBytes32String } from "ethers/abi"
+import { toBigInt as _toBigInt } from "ethers/utils"
+import { BigNumberish } from "./types"
+
+export default function toBigInt(value: BigNumberish | Uint8Array | string): bigint {
+    try {
+        return _toBigInt(value)
+    } catch (error: any) {
+        if (typeof value === "string") {
+            return _toBigInt(encodeBytes32String(value))
+        }
+
+        throw TypeError(error.message)
+    }
+}