@tezos-x/octez.js-timelock 0.9.0

package/README.md

@@ -0,0 +1,69 @@
+# octez.js Timelock package (BETA)
+
+**Maintained by [Nomadic Labs](https://www.nomadic-labs.com/).**
+
+:::info
+This feature is a work in progress, and might be refined in the near future. We encourage octez.js users to try this feature and reach out to us if you have any issues or concerns.
+:::
+
+Timelock is a cryptographic primitive that can be used as a part of a commit & reveal scheme, it provides a guarantee that the information associated to the commit phase is eventually revealed.
+
+## Commit & Reveal
+A classic commit & reveal scheme consists of these 2 stepsL
+- Before the deadline, each participant makes a decision and publishes a commitment, which is proof that they have made a decision that they are unable to change. The proof is the hash of the data they have decided on.
+- After the deadline, each participant reveals the data corresponding to their commitment. Other participants will be able to check that the hash of this data is indeed the same as the previous commitment
+
+This scheme makes it possible to prove a certain decision was made before the information is revealed. This information might be the decision of other participants, or some external independent information.
+
+above excerpt, taken from [here](https://docs.tezos.com/smart-contracts/data-types/crypto-data-types#classical-commit--reveal-scheme)
+
+## octez.js Implementation
+
+### Creating a chest
+```
+import { Chest } from '@tezos-x/octez.js-timelock'
+
+const time = 10000;
+const payload = new TextEncoder().encode('message');
+const { chest, key } = Chest.newChestAndKey(payload, time);
+
+const chestBytes = chest.encode();
+const keyBytes = key.encode();
+```
+
+### Create a chest from an existing Timelock
+```
+import { Chest, Timelock } from '@tezos-x/octez.js-timelock';
+
+// ...
+const time = 10000;
+const precomputedTimelock = Timelock.precompute(time); // can be cached
+const  { chest, key } = Chest.fromTimelock(payload, time, precomputedTimelock);
+
+const chestBytes = chest.encode();
+const keyBytes = key.encode();
+```
+
+### Opening a chest
+```
+import { Chest, ChestKey} from '@tezos-x/octez.js-timelock';
+
+//...
+const time = 10000;
+const [chest] = Chest.fromArray(chestBytes);
+const [chestKey] = ChestKey.fromArray(chestKeyBytes);
+const data = chest.open(chestKey, time);
+
+```
+
+**Important Notes**:
+- `time` param being passed should not be mistaken with the 'time' it takes for a chest to open in Timelocks. The `time` param here relates to a complexity relating to the number of power by modulo operations required to compute the key. Without getting too much into the weeds, we recommend using a value of `10000` and adjust accordingly.
+- `payload` relates to the message payload you would like to lock in a chest
+
+## Additional info
+
+See the top-level [https://github.com/trilitech/octez.js](https://github.com/trilitech/octez.js) file for details on reporting issues, contributing and versioning.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/lib/chest.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chest = exports.ChestKey = void 0;
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const nacl_1 = require("@stablelib/nacl");
+const timelock_util_1 = require("./timelock-util");
+// globalThis.crypto is available in browsers and Node.js 20+
+const defaultRNG = globalThis.crypto;
+class ChestKey extends timelock_util_1.TimelockProof {
+}
+exports.ChestKey = ChestKey;
+function encrypt(key, text, rng = defaultRNG) {
+    const nonce = new Uint8Array(24);
+    rng.getRandomValues(nonce);
+    const payload = (0, nacl_1.secretBox)(key, nonce, text);
+    return {
+        payload,
+        nonce,
+    };
+}
+function decrypt(key, c) {
+    return (0, nacl_1.openSecretBox)(key, c.nonce, c.payload);
+}
+class Chest {
+    constructor({ lockedValue, cipherText }) {
+        this.lockedValue = lockedValue;
+        this.cipherText = cipherText;
+    }
+    static newChestAndKey(payload, time, mod, rng) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        const vdfTuple = timelock_util_1.Timelock.precompute(time, mod, rng);
+        return Chest.fromTimelock(payload, time, vdfTuple, rng);
+    }
+    static fromTimelock(payload, time, timelock, rng) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        const { lockedValue, proof } = timelock.getProof(time, rng);
+        const symKey = proof.symmetricKey();
+        const cipherText = encrypt(symKey, payload, rng);
+        return { chest: new Chest({ lockedValue, cipherText }), key: proof };
+    }
+    newKey(time, mod) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        return (0, timelock_util_1.unlockAndProve)(time, this.lockedValue, mod);
+    }
+    open(key, time) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        if (!(0, timelock_util_1.verify)(this.lockedValue, key, time)) {
+            return null;
+        }
+        const symKey = key.symmetricKey();
+        return decrypt(symKey, this.cipherText);
+    }
+    encode() {
+        const locked = (0, timelock_util_1.encodeBigInt)(this.lockedValue);
+        const res = new Uint8Array(locked.length + 24 + 4 + this.cipherText.payload.length);
+        res.set(locked);
+        let off = locked.length;
+        res.set(this.cipherText.nonce, off);
+        off += 24;
+        new DataView(res.buffer, res.byteOffset, res.byteLength).setUint32(off, this.cipherText.payload.length);
+        off += 4;
+        res.set(this.cipherText.payload, off);
+        return res;
+    }
+    static fromArray(buf) {
+        let i = 0;
+        const [lockedValue, n] = (0, timelock_util_1.decodeBigInt)(buf);
+        i += n;
+        if (buf.length - i < 24 + 4) {
+            throw new Error('Buffer is too short');
+        }
+        const nonce = new Uint8Array(buf.slice(i, i + 24));
+        i += 24;
+        const len = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(i);
+        i += 4;
+        if (buf.length - i < len) {
+            throw new Error('Buffer is too short');
+        }
+        const payload = new Uint8Array(buf.slice(i, i + len));
+        i += len;
+        return [new Chest({ lockedValue, cipherText: { nonce, payload } }), i];
+    }
+}
+exports.Chest = Chest;

package/dist/lib/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/octez.js-timelock.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelockProof = exports.Timelock = void 0;
+__exportStar(require("./chest"), exports);
+__exportStar(require("./interface"), exports);
+var timelock_util_1 = require("./timelock-util");
+Object.defineProperty(exports, "Timelock", { enumerable: true, get: function () { return timelock_util_1.Timelock; } });
+Object.defineProperty(exports, "TimelockProof", { enumerable: true, get: function () { return timelock_util_1.TimelockProof; } });

package/dist/lib/timelock-util.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelockProof = exports.Timelock = exports.RSA_MODULUS = void 0;
+exports.prove = prove;
+exports.unlockAndProve = unlockAndProve;
+exports.verify = verify;
+exports.encodeBigInt = encodeBigInt;
+exports.decodeBigInt = decodeBigInt;
+const big_integer_1 = require("big-integer");
+const blake2b_1 = require("@stablelib/blake2b");
+// globalThis.crypto is available in browsers and Node.js 20+
+const defaultRNG = globalThis.crypto;
+exports.RSA_MODULUS = (0, big_integer_1.default)('25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357');
+function rand(rng = defaultRNG) {
+    const bytes = new Uint8Array(4);
+    rng.getRandomValues(bytes);
+    const x = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
+    return x / Math.pow(2, 32);
+}
+function randomInteger(rng, bits) {
+    const bytes = new Uint8Array(bits / 8);
+    rng.getRandomValues(bytes);
+    return big_integer_1.default.fromArray(Array.from(bytes), 256);
+}
+function nextPrime(n) {
+    if (n.compare(2) < 0) {
+        return (0, big_integer_1.default)(2);
+    }
+    const limit = n.multiply(2);
+    for (let p = n.next(); p.compare(limit) < 0; p = p.next()) {
+        // use 25 bases like in GMP mpz_nextprime and thus in Tezos
+        if (p.isProbablePrime(25, rand)) {
+            return p;
+        }
+    }
+    throw new Error('!!!nextPrime!!!'); // shouldn't happen
+}
+function generate(rng, mod) {
+    const m = mod.subtract((0, big_integer_1.default)(2));
+    return randomInteger(rng, mod.bitLength().toJSNumber()).mod(m).add((0, big_integer_1.default)(2));
+}
+function toLE(x) {
+    return x.toArray(256).value.reverse();
+}
+function fromLE(x) {
+    return big_integer_1.default.fromArray(x.reverse(), 256);
+}
+const HASH_SEPARATOR = [0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00];
+function hashToPrime(time, value, key, mod) {
+    const b = [
+        ...new TextEncoder().encode(String(time)),
+        ...HASH_SEPARATOR,
+        ...toLE(mod),
+        ...HASH_SEPARATOR,
+        ...toLE(value),
+        ...HASH_SEPARATOR,
+        ...toLE(key),
+    ];
+    const sum = (0, blake2b_1.hash)(new Uint8Array(b), 32, { key: new Uint8Array([32]) });
+    const val = fromLE(Array.from(sum));
+    return nextPrime(val);
+}
+function proveWesolowski(time, locked, unlocked, mod) {
+    const l = hashToPrime(time, locked, unlocked, mod);
+    let pi = (0, big_integer_1.default)(1);
+    let r = (0, big_integer_1.default)(1);
+    for (; time > 0; time -= 1) {
+        const rr = r.multiply(2);
+        r = rr.mod(l);
+        const pi2 = pi.multiply(pi).mod(mod);
+        if (rr.compare(l) >= 0) {
+            pi = pi2.multiply(locked);
+        }
+        else {
+            pi = pi2;
+        }
+    }
+    return pi.mod(mod);
+}
+function prove(time, locked, unlocked, mod = exports.RSA_MODULUS) {
+    return new TimelockProof({
+        vdfTuple: new Timelock({
+            lockedValue: locked,
+            unlockedValue: unlocked,
+            vdfProof: proveWesolowski(time, locked, unlocked, mod),
+            modulus: mod,
+        }),
+        nonce: (0, big_integer_1.default)(1),
+    });
+}
+function unlockTimelock(time, locked, mod) {
+    if (locked.compare((0, big_integer_1.default)(1)) <= 0) {
+        return locked;
+    }
+    let x = locked;
+    for (; time > 0; time -= 1) {
+        x = x.multiply(x).mod(mod);
+    }
+    return x;
+}
+function unlockAndProve(time, locked, mod = exports.RSA_MODULUS) {
+    const unlocked = unlockTimelock(time, locked, mod);
+    return prove(time, locked, unlocked, mod);
+}
+function verifyWesolowski(vdfTuple, time) {
+    const l = hashToPrime(time, vdfTuple.lockedValue, vdfTuple.unlockedValue, vdfTuple.modulus);
+    const ll = vdfTuple.vdfProof.modPow(l, vdfTuple.modulus);
+    const r = (0, big_integer_1.default)(2).modPow(time, l);
+    const rr = vdfTuple.lockedValue.modPow(r, vdfTuple.modulus);
+    const unlocked = ll.multiply(rr).mod(vdfTuple.modulus);
+    return unlocked.compare(vdfTuple.unlockedValue) === 0;
+}
+function verify(locked, proof, time) {
+    const randomizedChallenge = proof.vdfTuple.lockedValue.modPow(proof.nonce, proof.vdfTuple.modulus);
+    return randomizedChallenge.compare(locked) === 0 && verifyWesolowski(proof.vdfTuple, time);
+}
+class Timelock {
+    constructor({ lockedValue, unlockedValue, vdfProof, modulus }) {
+        this.lockedValue = lockedValue;
+        this.unlockedValue = unlockedValue;
+        this.vdfProof = vdfProof;
+        this.modulus = modulus !== null && modulus !== void 0 ? modulus : exports.RSA_MODULUS;
+    }
+    static precompute(time, mod = exports.RSA_MODULUS, rng = defaultRNG) {
+        const locked = generate(rng, mod);
+        const unlocked = unlockTimelock(time, locked, mod);
+        return new Timelock({
+            lockedValue: locked,
+            unlockedValue: unlocked,
+            vdfProof: proveWesolowski(time, locked, unlocked, mod),
+            modulus: mod,
+        });
+    }
+    getProof(time, rng = defaultRNG) {
+        if (this.lockedValue.compare((0, big_integer_1.default)(1)) < 1 ||
+            this.unlockedValue.compare((0, big_integer_1.default)(0)) < 1 ||
+            this.vdfProof.compare((0, big_integer_1.default)(0)) < 1 ||
+            this.lockedValue.compare(this.modulus) > 0 ||
+            this.unlockedValue.compare(this.modulus) > 0 ||
+            this.vdfProof.compare(this.modulus) >= 0) {
+            throw new Error('Invalid argument');
+        }
+        if (!verifyWesolowski(this, time)) {
+            throw new Error('Verification error');
+        }
+        const nonce = randomInteger(rng, 16 * 8);
+        const lockedValue = this.lockedValue.modPow(nonce, this.modulus);
+        return {
+            lockedValue,
+            proof: new TimelockProof({
+                vdfTuple: this,
+                nonce,
+            }),
+        };
+    }
+    encode() {
+        return new Uint8Array([
+            ...encodeBigInt(this.lockedValue),
+            ...encodeBigInt(this.unlockedValue),
+            ...encodeBigInt(this.vdfProof),
+        ]);
+    }
+    static fromArray(buf, mod = exports.RSA_MODULUS) {
+        let i = 0;
+        const [lockedValue, n1] = decodeBigInt(buf);
+        i += n1;
+        const [unlockedValue, n2] = decodeBigInt(buf.slice(i));
+        i += n2;
+        const [vdfProof, n3] = decodeBigInt(buf.slice(i));
+        i += n3;
+        return [
+            new Timelock({
+                lockedValue,
+                unlockedValue,
+                vdfProof,
+                modulus: mod,
+            }),
+            i,
+        ];
+    }
+}
+exports.Timelock = Timelock;
+const KDF_KEY = new TextEncoder().encode('Tezoskdftimelockv1');
+class TimelockProof {
+    constructor({ vdfTuple, nonce }) {
+        this.vdfTuple = vdfTuple;
+        this.nonce = nonce;
+    }
+    symmetricKey() {
+        const updated = this.vdfTuple.unlockedValue.modPow(this.nonce, this.vdfTuple.modulus);
+        return (0, blake2b_1.hash)(new TextEncoder().encode(String(updated)), 32, { key: KDF_KEY });
+    }
+    encode() {
+        return new Uint8Array([...this.vdfTuple.encode(), ...encodeBigInt(this.nonce)]);
+    }
+    static fromArray(buf, mod = exports.RSA_MODULUS) {
+        let i = 0;
+        const [vdfTuple, n1] = Timelock.fromArray(buf, mod);
+        i += n1;
+        const [nonce, n2] = decodeBigInt(buf.slice(i));
+        i += n2;
+        return [new TimelockProof({ vdfTuple, nonce }), i];
+    }
+}
+exports.TimelockProof = TimelockProof;
+function encodeBigInt(v) {
+    if (v.isNegative()) {
+        throw new Error('Negative value');
+    }
+    const res = [];
+    for (let i = 0;; i++) {
+        const x = v.and((0, big_integer_1.default)(0x7f)).toJSNumber();
+        v = v.shiftRight(7);
+        if (!v.isZero()) {
+            res.push(x | 0x80);
+        }
+        else {
+            res.push(x);
+            break;
+        }
+    }
+    return res;
+}
+function decodeBigInt(buf) {
+    let shift = 0;
+    let i = 0;
+    let res = (0, big_integer_1.default)(0);
+    while (i < buf.length) {
+        const x = buf[i];
+        res = res.add((0, big_integer_1.default)(x & 0x7f).shiftLeft(shift));
+        shift += 7;
+        i++;
+        if ((x & 0x80) === 0)
+            break;
+    }
+    return [res, i];
+}

package/dist/lib/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "f798e97ba998acc2cc5310278d812448591bd312",
+    "version": "24.0.2"
+};

package/dist/octez.js-timelock.es6.js

@@ -0,0 +1,317 @@
+import { openSecretBox, secretBox } from '@stablelib/nacl';
+import bigInt from 'big-integer';
+import { hash } from '@stablelib/blake2b';
+
+// globalThis.crypto is available in browsers and Node.js 20+
+const defaultRNG$1 = globalThis.crypto;
+const RSA_MODULUS = bigInt('25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357');
+function rand(rng = defaultRNG$1) {
+    const bytes = new Uint8Array(4);
+    rng.getRandomValues(bytes);
+    const x = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
+    return x / Math.pow(2, 32);
+}
+function randomInteger(rng, bits) {
+    const bytes = new Uint8Array(bits / 8);
+    rng.getRandomValues(bytes);
+    return bigInt.fromArray(Array.from(bytes), 256);
+}
+function nextPrime(n) {
+    if (n.compare(2) < 0) {
+        return bigInt(2);
+    }
+    const limit = n.multiply(2);
+    for (let p = n.next(); p.compare(limit) < 0; p = p.next()) {
+        // use 25 bases like in GMP mpz_nextprime and thus in Tezos
+        if (p.isProbablePrime(25, rand)) {
+            return p;
+        }
+    }
+    throw new Error('!!!nextPrime!!!'); // shouldn't happen
+}
+function generate(rng, mod) {
+    const m = mod.subtract(bigInt(2));
+    return randomInteger(rng, mod.bitLength().toJSNumber()).mod(m).add(bigInt(2));
+}
+function toLE(x) {
+    return x.toArray(256).value.reverse();
+}
+function fromLE(x) {
+    return bigInt.fromArray(x.reverse(), 256);
+}
+const HASH_SEPARATOR = [0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00];
+function hashToPrime(time, value, key, mod) {
+    const b = [
+        ...new TextEncoder().encode(String(time)),
+        ...HASH_SEPARATOR,
+        ...toLE(mod),
+        ...HASH_SEPARATOR,
+        ...toLE(value),
+        ...HASH_SEPARATOR,
+        ...toLE(key),
+    ];
+    const sum = hash(new Uint8Array(b), 32, { key: new Uint8Array([32]) });
+    const val = fromLE(Array.from(sum));
+    return nextPrime(val);
+}
+function proveWesolowski(time, locked, unlocked, mod) {
+    const l = hashToPrime(time, locked, unlocked, mod);
+    let pi = bigInt(1);
+    let r = bigInt(1);
+    for (; time > 0; time -= 1) {
+        const rr = r.multiply(2);
+        r = rr.mod(l);
+        const pi2 = pi.multiply(pi).mod(mod);
+        if (rr.compare(l) >= 0) {
+            pi = pi2.multiply(locked);
+        }
+        else {
+            pi = pi2;
+        }
+    }
+    return pi.mod(mod);
+}
+function prove(time, locked, unlocked, mod = RSA_MODULUS) {
+    return new TimelockProof({
+        vdfTuple: new Timelock({
+            lockedValue: locked,
+            unlockedValue: unlocked,
+            vdfProof: proveWesolowski(time, locked, unlocked, mod),
+            modulus: mod,
+        }),
+        nonce: bigInt(1),
+    });
+}
+function unlockTimelock(time, locked, mod) {
+    if (locked.compare(bigInt(1)) <= 0) {
+        return locked;
+    }
+    let x = locked;
+    for (; time > 0; time -= 1) {
+        x = x.multiply(x).mod(mod);
+    }
+    return x;
+}
+function unlockAndProve(time, locked, mod = RSA_MODULUS) {
+    const unlocked = unlockTimelock(time, locked, mod);
+    return prove(time, locked, unlocked, mod);
+}
+function verifyWesolowski(vdfTuple, time) {
+    const l = hashToPrime(time, vdfTuple.lockedValue, vdfTuple.unlockedValue, vdfTuple.modulus);
+    const ll = vdfTuple.vdfProof.modPow(l, vdfTuple.modulus);
+    const r = bigInt(2).modPow(time, l);
+    const rr = vdfTuple.lockedValue.modPow(r, vdfTuple.modulus);
+    const unlocked = ll.multiply(rr).mod(vdfTuple.modulus);
+    return unlocked.compare(vdfTuple.unlockedValue) === 0;
+}
+function verify(locked, proof, time) {
+    const randomizedChallenge = proof.vdfTuple.lockedValue.modPow(proof.nonce, proof.vdfTuple.modulus);
+    return randomizedChallenge.compare(locked) === 0 && verifyWesolowski(proof.vdfTuple, time);
+}
+class Timelock {
+    constructor({ lockedValue, unlockedValue, vdfProof, modulus }) {
+        this.lockedValue = lockedValue;
+        this.unlockedValue = unlockedValue;
+        this.vdfProof = vdfProof;
+        this.modulus = modulus !== null && modulus !== void 0 ? modulus : RSA_MODULUS;
+    }
+    static precompute(time, mod = RSA_MODULUS, rng = defaultRNG$1) {
+        const locked = generate(rng, mod);
+        const unlocked = unlockTimelock(time, locked, mod);
+        return new Timelock({
+            lockedValue: locked,
+            unlockedValue: unlocked,
+            vdfProof: proveWesolowski(time, locked, unlocked, mod),
+            modulus: mod,
+        });
+    }
+    getProof(time, rng = defaultRNG$1) {
+        if (this.lockedValue.compare(bigInt(1)) < 1 ||
+            this.unlockedValue.compare(bigInt(0)) < 1 ||
+            this.vdfProof.compare(bigInt(0)) < 1 ||
+            this.lockedValue.compare(this.modulus) > 0 ||
+            this.unlockedValue.compare(this.modulus) > 0 ||
+            this.vdfProof.compare(this.modulus) >= 0) {
+            throw new Error('Invalid argument');
+        }
+        if (!verifyWesolowski(this, time)) {
+            throw new Error('Verification error');
+        }
+        const nonce = randomInteger(rng, 16 * 8);
+        const lockedValue = this.lockedValue.modPow(nonce, this.modulus);
+        return {
+            lockedValue,
+            proof: new TimelockProof({
+                vdfTuple: this,
+                nonce,
+            }),
+        };
+    }
+    encode() {
+        return new Uint8Array([
+            ...encodeBigInt(this.lockedValue),
+            ...encodeBigInt(this.unlockedValue),
+            ...encodeBigInt(this.vdfProof),
+        ]);
+    }
+    static fromArray(buf, mod = RSA_MODULUS) {
+        let i = 0;
+        const [lockedValue, n1] = decodeBigInt(buf);
+        i += n1;
+        const [unlockedValue, n2] = decodeBigInt(buf.slice(i));
+        i += n2;
+        const [vdfProof, n3] = decodeBigInt(buf.slice(i));
+        i += n3;
+        return [
+            new Timelock({
+                lockedValue,
+                unlockedValue,
+                vdfProof,
+                modulus: mod,
+            }),
+            i,
+        ];
+    }
+}
+const KDF_KEY = new TextEncoder().encode('Tezoskdftimelockv1');
+class TimelockProof {
+    constructor({ vdfTuple, nonce }) {
+        this.vdfTuple = vdfTuple;
+        this.nonce = nonce;
+    }
+    symmetricKey() {
+        const updated = this.vdfTuple.unlockedValue.modPow(this.nonce, this.vdfTuple.modulus);
+        return hash(new TextEncoder().encode(String(updated)), 32, { key: KDF_KEY });
+    }
+    encode() {
+        return new Uint8Array([...this.vdfTuple.encode(), ...encodeBigInt(this.nonce)]);
+    }
+    static fromArray(buf, mod = RSA_MODULUS) {
+        let i = 0;
+        const [vdfTuple, n1] = Timelock.fromArray(buf, mod);
+        i += n1;
+        const [nonce, n2] = decodeBigInt(buf.slice(i));
+        i += n2;
+        return [new TimelockProof({ vdfTuple, nonce }), i];
+    }
+}
+function encodeBigInt(v) {
+    if (v.isNegative()) {
+        throw new Error('Negative value');
+    }
+    const res = [];
+    for (let i = 0;; i++) {
+        const x = v.and(bigInt(0x7f)).toJSNumber();
+        v = v.shiftRight(7);
+        if (!v.isZero()) {
+            res.push(x | 0x80);
+        }
+        else {
+            res.push(x);
+            break;
+        }
+    }
+    return res;
+}
+function decodeBigInt(buf) {
+    let shift = 0;
+    let i = 0;
+    let res = bigInt(0);
+    while (i < buf.length) {
+        const x = buf[i];
+        res = res.add(bigInt(x & 0x7f).shiftLeft(shift));
+        shift += 7;
+        i++;
+        if ((x & 0x80) === 0)
+            break;
+    }
+    return [res, i];
+}
+
+// globalThis.crypto is available in browsers and Node.js 20+
+const defaultRNG = globalThis.crypto;
+class ChestKey extends TimelockProof {
+}
+function encrypt(key, text, rng = defaultRNG) {
+    const nonce = new Uint8Array(24);
+    rng.getRandomValues(nonce);
+    const payload = secretBox(key, nonce, text);
+    return {
+        payload,
+        nonce,
+    };
+}
+function decrypt(key, c) {
+    return openSecretBox(key, c.nonce, c.payload);
+}
+class Chest {
+    constructor({ lockedValue, cipherText }) {
+        this.lockedValue = lockedValue;
+        this.cipherText = cipherText;
+    }
+    static newChestAndKey(payload, time, mod, rng) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        const vdfTuple = Timelock.precompute(time, mod, rng);
+        return Chest.fromTimelock(payload, time, vdfTuple, rng);
+    }
+    static fromTimelock(payload, time, timelock, rng) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        const { lockedValue, proof } = timelock.getProof(time, rng);
+        const symKey = proof.symmetricKey();
+        const cipherText = encrypt(symKey, payload, rng);
+        return { chest: new Chest({ lockedValue, cipherText }), key: proof };
+    }
+    newKey(time, mod) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        return unlockAndProve(time, this.lockedValue, mod);
+    }
+    open(key, time) {
+        if (time <= 0) {
+            throw new Error('Invalid argument');
+        }
+        if (!verify(this.lockedValue, key, time)) {
+            return null;
+        }
+        const symKey = key.symmetricKey();
+        return decrypt(symKey, this.cipherText);
+    }
+    encode() {
+        const locked = encodeBigInt(this.lockedValue);
+        const res = new Uint8Array(locked.length + 24 + 4 + this.cipherText.payload.length);
+        res.set(locked);
+        let off = locked.length;
+        res.set(this.cipherText.nonce, off);
+        off += 24;
+        new DataView(res.buffer, res.byteOffset, res.byteLength).setUint32(off, this.cipherText.payload.length);
+        off += 4;
+        res.set(this.cipherText.payload, off);
+        return res;
+    }
+    static fromArray(buf) {
+        let i = 0;
+        const [lockedValue, n] = decodeBigInt(buf);
+        i += n;
+        if (buf.length - i < 24 + 4) {
+            throw new Error('Buffer is too short');
+        }
+        const nonce = new Uint8Array(buf.slice(i, i + 24));
+        i += 24;
+        const len = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(i);
+        i += 4;
+        if (buf.length - i < len) {
+            throw new Error('Buffer is too short');
+        }
+        const payload = new Uint8Array(buf.slice(i, i + len));
+        i += len;
+        return [new Chest({ lockedValue, cipherText: { nonce, payload } }), i];
+    }
+}
+
+export { Chest, ChestKey, Timelock, TimelockProof, decrypt, encrypt };
+//# sourceMappingURL=octez.js-timelock.es6.js.map

package/dist/octez.js-timelock.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"octez.js-timelock.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/octez.js-timelock.umd.js

@@ -0,0 +1,326 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@stablelib/nacl'), require('big-integer'), require('@stablelib/blake2b')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@stablelib/nacl', 'big-integer', '@stablelib/blake2b'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.octezJsTimelock = {}, global.nacl, global.bigInt, global.blake2b));
+})(this, (function (exports, nacl, bigInt, blake2b) { 'use strict';
+
+  // globalThis.crypto is available in browsers and Node.js 20+
+  const defaultRNG$1 = globalThis.crypto;
+  const RSA_MODULUS = bigInt('25195908475657893494027183240048398571429282126204032027777137836043662020707595556264018525880784406918290641249515082189298559149176184502808489120072844992687392807287776735971418347270261896375014971824691165077613379859095700097330459748808428401797429100642458691817195118746121515172654632282216869987549182422433637259085141865462043576798423387184774447920739934236584823824281198163815010674810451660377306056201619676256133844143603833904414952634432190114657544454178424020924616515723350778707749817125772467962926386356373289912154831438167899885040445364023527381951378636564391212010397122822120720357');
+  function rand(rng = defaultRNG$1) {
+      const bytes = new Uint8Array(4);
+      rng.getRandomValues(bytes);
+      const x = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0;
+      return x / Math.pow(2, 32);
+  }
+  function randomInteger(rng, bits) {
+      const bytes = new Uint8Array(bits / 8);
+      rng.getRandomValues(bytes);
+      return bigInt.fromArray(Array.from(bytes), 256);
+  }
+  function nextPrime(n) {
+      if (n.compare(2) < 0) {
+          return bigInt(2);
+      }
+      const limit = n.multiply(2);
+      for (let p = n.next(); p.compare(limit) < 0; p = p.next()) {
+          // use 25 bases like in GMP mpz_nextprime and thus in Tezos
+          if (p.isProbablePrime(25, rand)) {
+              return p;
+          }
+      }
+      throw new Error('!!!nextPrime!!!'); // shouldn't happen
+  }
+  function generate(rng, mod) {
+      const m = mod.subtract(bigInt(2));
+      return randomInteger(rng, mod.bitLength().toJSNumber()).mod(m).add(bigInt(2));
+  }
+  function toLE(x) {
+      return x.toArray(256).value.reverse();
+  }
+  function fromLE(x) {
+      return bigInt.fromArray(x.reverse(), 256);
+  }
+  const HASH_SEPARATOR = [0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00];
+  function hashToPrime(time, value, key, mod) {
+      const b = [
+          ...new TextEncoder().encode(String(time)),
+          ...HASH_SEPARATOR,
+          ...toLE(mod),
+          ...HASH_SEPARATOR,
+          ...toLE(value),
+          ...HASH_SEPARATOR,
+          ...toLE(key),
+      ];
+      const sum = blake2b.hash(new Uint8Array(b), 32, { key: new Uint8Array([32]) });
+      const val = fromLE(Array.from(sum));
+      return nextPrime(val);
+  }
+  function proveWesolowski(time, locked, unlocked, mod) {
+      const l = hashToPrime(time, locked, unlocked, mod);
+      let pi = bigInt(1);
+      let r = bigInt(1);
+      for (; time > 0; time -= 1) {
+          const rr = r.multiply(2);
+          r = rr.mod(l);
+          const pi2 = pi.multiply(pi).mod(mod);
+          if (rr.compare(l) >= 0) {
+              pi = pi2.multiply(locked);
+          }
+          else {
+              pi = pi2;
+          }
+      }
+      return pi.mod(mod);
+  }
+  function prove(time, locked, unlocked, mod = RSA_MODULUS) {
+      return new TimelockProof({
+          vdfTuple: new Timelock({
+              lockedValue: locked,
+              unlockedValue: unlocked,
+              vdfProof: proveWesolowski(time, locked, unlocked, mod),
+              modulus: mod,
+          }),
+          nonce: bigInt(1),
+      });
+  }
+  function unlockTimelock(time, locked, mod) {
+      if (locked.compare(bigInt(1)) <= 0) {
+          return locked;
+      }
+      let x = locked;
+      for (; time > 0; time -= 1) {
+          x = x.multiply(x).mod(mod);
+      }
+      return x;
+  }
+  function unlockAndProve(time, locked, mod = RSA_MODULUS) {
+      const unlocked = unlockTimelock(time, locked, mod);
+      return prove(time, locked, unlocked, mod);
+  }
+  function verifyWesolowski(vdfTuple, time) {
+      const l = hashToPrime(time, vdfTuple.lockedValue, vdfTuple.unlockedValue, vdfTuple.modulus);
+      const ll = vdfTuple.vdfProof.modPow(l, vdfTuple.modulus);
+      const r = bigInt(2).modPow(time, l);
+      const rr = vdfTuple.lockedValue.modPow(r, vdfTuple.modulus);
+      const unlocked = ll.multiply(rr).mod(vdfTuple.modulus);
+      return unlocked.compare(vdfTuple.unlockedValue) === 0;
+  }
+  function verify(locked, proof, time) {
+      const randomizedChallenge = proof.vdfTuple.lockedValue.modPow(proof.nonce, proof.vdfTuple.modulus);
+      return randomizedChallenge.compare(locked) === 0 && verifyWesolowski(proof.vdfTuple, time);
+  }
+  class Timelock {
+      constructor({ lockedValue, unlockedValue, vdfProof, modulus }) {
+          this.lockedValue = lockedValue;
+          this.unlockedValue = unlockedValue;
+          this.vdfProof = vdfProof;
+          this.modulus = modulus !== null && modulus !== void 0 ? modulus : RSA_MODULUS;
+      }
+      static precompute(time, mod = RSA_MODULUS, rng = defaultRNG$1) {
+          const locked = generate(rng, mod);
+          const unlocked = unlockTimelock(time, locked, mod);
+          return new Timelock({
+              lockedValue: locked,
+              unlockedValue: unlocked,
+              vdfProof: proveWesolowski(time, locked, unlocked, mod),
+              modulus: mod,
+          });
+      }
+      getProof(time, rng = defaultRNG$1) {
+          if (this.lockedValue.compare(bigInt(1)) < 1 ||
+              this.unlockedValue.compare(bigInt(0)) < 1 ||
+              this.vdfProof.compare(bigInt(0)) < 1 ||
+              this.lockedValue.compare(this.modulus) > 0 ||
+              this.unlockedValue.compare(this.modulus) > 0 ||
+              this.vdfProof.compare(this.modulus) >= 0) {
+              throw new Error('Invalid argument');
+          }
+          if (!verifyWesolowski(this, time)) {
+              throw new Error('Verification error');
+          }
+          const nonce = randomInteger(rng, 16 * 8);
+          const lockedValue = this.lockedValue.modPow(nonce, this.modulus);
+          return {
+              lockedValue,
+              proof: new TimelockProof({
+                  vdfTuple: this,
+                  nonce,
+              }),
+          };
+      }
+      encode() {
+          return new Uint8Array([
+              ...encodeBigInt(this.lockedValue),
+              ...encodeBigInt(this.unlockedValue),
+              ...encodeBigInt(this.vdfProof),
+          ]);
+      }
+      static fromArray(buf, mod = RSA_MODULUS) {
+          let i = 0;
+          const [lockedValue, n1] = decodeBigInt(buf);
+          i += n1;
+          const [unlockedValue, n2] = decodeBigInt(buf.slice(i));
+          i += n2;
+          const [vdfProof, n3] = decodeBigInt(buf.slice(i));
+          i += n3;
+          return [
+              new Timelock({
+                  lockedValue,
+                  unlockedValue,
+                  vdfProof,
+                  modulus: mod,
+              }),
+              i,
+          ];
+      }
+  }
+  const KDF_KEY = new TextEncoder().encode('Tezoskdftimelockv1');
+  class TimelockProof {
+      constructor({ vdfTuple, nonce }) {
+          this.vdfTuple = vdfTuple;
+          this.nonce = nonce;
+      }
+      symmetricKey() {
+          const updated = this.vdfTuple.unlockedValue.modPow(this.nonce, this.vdfTuple.modulus);
+          return blake2b.hash(new TextEncoder().encode(String(updated)), 32, { key: KDF_KEY });
+      }
+      encode() {
+          return new Uint8Array([...this.vdfTuple.encode(), ...encodeBigInt(this.nonce)]);
+      }
+      static fromArray(buf, mod = RSA_MODULUS) {
+          let i = 0;
+          const [vdfTuple, n1] = Timelock.fromArray(buf, mod);
+          i += n1;
+          const [nonce, n2] = decodeBigInt(buf.slice(i));
+          i += n2;
+          return [new TimelockProof({ vdfTuple, nonce }), i];
+      }
+  }
+  function encodeBigInt(v) {
+      if (v.isNegative()) {
+          throw new Error('Negative value');
+      }
+      const res = [];
+      for (let i = 0;; i++) {
+          const x = v.and(bigInt(0x7f)).toJSNumber();
+          v = v.shiftRight(7);
+          if (!v.isZero()) {
+              res.push(x | 0x80);
+          }
+          else {
+              res.push(x);
+              break;
+          }
+      }
+      return res;
+  }
+  function decodeBigInt(buf) {
+      let shift = 0;
+      let i = 0;
+      let res = bigInt(0);
+      while (i < buf.length) {
+          const x = buf[i];
+          res = res.add(bigInt(x & 0x7f).shiftLeft(shift));
+          shift += 7;
+          i++;
+          if ((x & 0x80) === 0)
+              break;
+      }
+      return [res, i];
+  }
+
+  // globalThis.crypto is available in browsers and Node.js 20+
+  const defaultRNG = globalThis.crypto;
+  class ChestKey extends TimelockProof {
+  }
+  function encrypt(key, text, rng = defaultRNG) {
+      const nonce = new Uint8Array(24);
+      rng.getRandomValues(nonce);
+      const payload = nacl.secretBox(key, nonce, text);
+      return {
+          payload,
+          nonce,
+      };
+  }
+  function decrypt(key, c) {
+      return nacl.openSecretBox(key, c.nonce, c.payload);
+  }
+  class Chest {
+      constructor({ lockedValue, cipherText }) {
+          this.lockedValue = lockedValue;
+          this.cipherText = cipherText;
+      }
+      static newChestAndKey(payload, time, mod, rng) {
+          if (time <= 0) {
+              throw new Error('Invalid argument');
+          }
+          const vdfTuple = Timelock.precompute(time, mod, rng);
+          return Chest.fromTimelock(payload, time, vdfTuple, rng);
+      }
+      static fromTimelock(payload, time, timelock, rng) {
+          if (time <= 0) {
+              throw new Error('Invalid argument');
+          }
+          const { lockedValue, proof } = timelock.getProof(time, rng);
+          const symKey = proof.symmetricKey();
+          const cipherText = encrypt(symKey, payload, rng);
+          return { chest: new Chest({ lockedValue, cipherText }), key: proof };
+      }
+      newKey(time, mod) {
+          if (time <= 0) {
+              throw new Error('Invalid argument');
+          }
+          return unlockAndProve(time, this.lockedValue, mod);
+      }
+      open(key, time) {
+          if (time <= 0) {
+              throw new Error('Invalid argument');
+          }
+          if (!verify(this.lockedValue, key, time)) {
+              return null;
+          }
+          const symKey = key.symmetricKey();
+          return decrypt(symKey, this.cipherText);
+      }
+      encode() {
+          const locked = encodeBigInt(this.lockedValue);
+          const res = new Uint8Array(locked.length + 24 + 4 + this.cipherText.payload.length);
+          res.set(locked);
+          let off = locked.length;
+          res.set(this.cipherText.nonce, off);
+          off += 24;
+          new DataView(res.buffer, res.byteOffset, res.byteLength).setUint32(off, this.cipherText.payload.length);
+          off += 4;
+          res.set(this.cipherText.payload, off);
+          return res;
+      }
+      static fromArray(buf) {
+          let i = 0;
+          const [lockedValue, n] = decodeBigInt(buf);
+          i += n;
+          if (buf.length - i < 24 + 4) {
+              throw new Error('Buffer is too short');
+          }
+          const nonce = new Uint8Array(buf.slice(i, i + 24));
+          i += 24;
+          const len = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(i);
+          i += 4;
+          if (buf.length - i < len) {
+              throw new Error('Buffer is too short');
+          }
+          const payload = new Uint8Array(buf.slice(i, i + len));
+          i += len;
+          return [new Chest({ lockedValue, cipherText: { nonce, payload } }), i];
+      }
+  }
+
+  exports.Chest = Chest;
+  exports.ChestKey = ChestKey;
+  exports.Timelock = Timelock;
+  exports.TimelockProof = TimelockProof;
+  exports.decrypt = decrypt;
+  exports.encrypt = encrypt;
+
+}));
+//# sourceMappingURL=octez.js-timelock.umd.js.map

package/dist/octez.js-timelock.umd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"octez.js-timelock.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/chest.d.ts

@@ -0,0 +1,27 @@
+import { BigInteger } from 'big-integer';
+import { RNG, CipherText } from './interface';
+import { TimelockProof, Timelock } from './timelock-util';
+export declare class ChestKey extends TimelockProof {
+}
+export declare function encrypt(key: Uint8Array, text: Uint8Array, rng?: RNG): CipherText;
+export declare function decrypt(key: Uint8Array, c: CipherText): Uint8Array | null;
+export declare class Chest {
+    lockedValue: BigInteger;
+    cipherText: CipherText;
+    constructor({ lockedValue, cipherText }: {
+        lockedValue: BigInteger;
+        cipherText: CipherText;
+    });
+    static newChestAndKey(payload: Uint8Array, time: number, mod?: BigInteger, rng?: RNG): {
+        chest: Chest;
+        key: ChestKey;
+    };
+    static fromTimelock(payload: Uint8Array, time: number, timelock: Timelock, rng?: RNG): {
+        chest: Chest;
+        key: ChestKey;
+    };
+    newKey(time: number, mod?: BigInteger): ChestKey;
+    open(key: ChestKey, time: number): Uint8Array | null;
+    encode(): Uint8Array;
+    static fromArray(buf: Uint8Array): [Chest, number];
+}

package/dist/types/interface.d.ts

@@ -0,0 +1,14 @@
+import { BigInteger } from 'big-integer';
+export interface RNG {
+    getRandomValues: (array: Uint8Array) => Uint8Array;
+}
+export interface TimelockInit {
+    lockedValue: BigInteger;
+    unlockedValue: BigInteger;
+    vdfProof: BigInteger;
+    modulus?: BigInteger;
+}
+export interface CipherText {
+    nonce: Uint8Array;
+    payload: Uint8Array;
+}

package/dist/types/octez.js-timelock.d.ts

@@ -0,0 +1,3 @@
+export * from './chest';
+export * from './interface';
+export { Timelock, TimelockProof } from './timelock-util';

package/dist/types/timelock-util.d.ts

@@ -0,0 +1,33 @@
+import bigInt, { BigInteger } from 'big-integer';
+import { TimelockInit, RNG } from './interface';
+export declare const RSA_MODULUS: bigInt.BigInteger;
+export declare function prove(time: number, locked: BigInteger, unlocked: BigInteger, mod?: BigInteger): TimelockProof;
+export declare function unlockAndProve(time: number, locked: BigInteger, mod?: BigInteger): TimelockProof;
+export declare function verify(locked: BigInteger, proof: TimelockProof, time: number): boolean;
+export declare class Timelock {
+    lockedValue: BigInteger;
+    unlockedValue: BigInteger;
+    vdfProof: BigInteger;
+    modulus: BigInteger;
+    constructor({ lockedValue, unlockedValue, vdfProof, modulus }: TimelockInit);
+    static precompute(time: number, mod?: BigInteger, rng?: RNG): Timelock;
+    getProof(time: number, rng?: RNG): {
+        lockedValue: BigInteger;
+        proof: TimelockProof;
+    };
+    encode(): Uint8Array;
+    static fromArray(buf: Uint8Array, mod?: BigInteger): [Timelock, number];
+}
+export declare class TimelockProof {
+    vdfTuple: Timelock;
+    nonce: BigInteger;
+    constructor({ vdfTuple, nonce }: {
+        vdfTuple: Timelock;
+        nonce: BigInteger;
+    });
+    symmetricKey(): Uint8Array;
+    encode(): Uint8Array;
+    static fromArray(buf: Uint8Array, mod?: BigInteger): [TimelockProof, number];
+}
+export declare function encodeBigInt(v: BigInteger): number[];
+export declare function decodeBigInt(buf: ArrayLike<number>): [BigInteger, number];

package/dist/types/version.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION: {
+    commitHash: string;
+    version: string;
+};

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@tezos-x/octez.js-timelock",
+  "version": "0.9.0",
+  "description": "TypeScript implementation of the Timelock feature in Tezos",
+  "main": "./dist/octez.js-timelock.umd.js",
+  "module": "./dist/octez.js-timelock.es6.js",
+  "typings": "./dist/types/octez.js-timelock.d.ts",
+  "files": [
+    "dist",
+    "signature.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Eugene Zagidullin <eugene@ecadlabs.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/trilitech/octez.js.git"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "jest --coverage",
+    "test:watch": "jest --coverage --watch",
+    "test:prod": "npm run lint && npm run test -- --no-cache",
+    "lint": "eslint --ext .js,.ts .",
+    "precommit": "lint-staged",
+    "prebuild": "rimraf dist",
+    "version-stamp": "node ../octez.js/version-stamping.js",
+    "build": "tsc --project ./tsconfig.prod.json --module commonjs && rollup -c rollup.config.ts --bundleConfigAsCjs",
+    "start": "rollup -c rollup.config.ts --bundleConfigAsCjs -w"
+  },
+  "lint-staged": {
+    "{src,test}/**/*.ts": [
+      "prettier --write",
+      "eslint --fix"
+    ]
+  },
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "ts-jest"
+    },
+    "testEnvironment": "node",
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ],
+    "moduleNameMapper": {
+      "^@tezos-x/octez.js-utils$": "<rootDir>/../octez.js-utils/src/octez.js-utils.ts",
+      "^@tezos-x/octez.js-signer$": "<rootDir>/../octez.js-signer/src/octez.js-signer.ts",
+      "^@tezos-x/octez.js$": "<rootDir>/../octez.js/src/octez.ts"
+    },
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/test/"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{js,ts}"
+    ]
+  },
+  "dependencies": {
+    "@stablelib/blake2b": "^1.0.1",
+    "@stablelib/nacl": "^1.0.4",
+    "big-integer": "^1.6.52"
+  },
+  "devDependencies": {
+    "@tezos-x/octez.js-signer": "*",
+    "@tezos-x/octez.js": "*",
+    "@tezos-x/octez.js-utils": "*",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint": "^8.57.0",
+    "eslint-config-standard-with-typescript": "^43.0.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "jest": "^29.7.0",
+    "jest-config": "^29.7.0",
+    "jest-extended": "^4.0.2",
+    "lint-staged": "^15.2.7",
+    "lodash.camelcase": "^4.3.0",
+    "prettier": "^3.3.3",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.22.4",
+    "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "ts-jest": "^29.2.3",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "ts-toolbelt": "^9.6.0",
+    "typescript": "^5.5.4"
+  },
+  "gitHead": "551e35aeff7d6dcde1c72284238c0ed3c3aae77e"
+}