Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

chore(sigil): drop the abandoned monorepo scaffold in favour of three standalone repos

nirholasc985bcd9930b
diff --git a/sigil/.gitignore b/sigil/.gitignore
deleted file mode 100644
index dc40561bb..000000000
--- a/sigil/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-node_modules
-dist
-.wrangler
-*.log
-.DS_Store
diff --git a/sigil/LICENSE b/sigil/LICENSE
deleted file mode 100644
index b5ae2a4e1..000000000
--- a/sigil/LICENSE
+++ /dev/null
@@ -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 2026 nirholas
-
- 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.
diff --git a/sigil/NOTICE b/sigil/NOTICE
deleted file mode 100644
index 9f03147ba..000000000
--- a/sigil/NOTICE
+++ /dev/null
@@ -1,27 +0,0 @@
-Sigil
-Copyright 2026 nirholas
-
-The open multi-chain vanity address foundry.
-https://github.com/nirholas/sigil
-
-Licensed under the Apache License, Version 2.0. See the LICENSE file in the
-root of this repository for the full terms.
-
-Portions of this project were first developed inside the three.ws monorepo
-(https://github.com/nirholas/three.ws) and are re-licensed here under the same
-Apache License, Version 2.0:
-
- packages/core/src/difficulty.js base58 leading-character distribution model
- packages/solana/src/* ed25519 grinding and BIP-39 mnemonic search
- packages/evm/src/* secp256k1 EOA and CREATE2 salt grinding
- packages/splitkey/src/ed25519.js trustless split-key grinding for Ed25519
- packages/attest/src/* proof-of-grind certificate format
-
-Third-party dependencies keep their own licenses:
-
- @noble/curves, @noble/hashes MIT, Paul Miller
- bs58, base-x MIT
- three MIT, three.js authors
- hono MIT, Yusuke Wada
-
-Nothing in this NOTICE modifies the terms of the Apache License, Version 2.0.
diff --git a/sigil/package.json b/sigil/package.json
deleted file mode 100644
index 4746babb1..000000000
--- a/sigil/package.json
+++ /dev/null
@@ -1,33 +0,0 @@
-{
- "name": "sigil",
- "version": "1.0.0",
- "private": true,
- "description": "Sigil: the open multi-chain vanity address foundry. Grind branded Solana and EVM addresses in the browser, prove how they were made, and deploy the same vanity contract address on every chain.",
- "type": "module",
- "license": "Apache-2.0",
- "author": "nirholas <[email protected]>",
- "homepage": "https://three.ws/sigil",
- "repository": {
- "type": "git",
- "url": "git+https://github.com/nirholas/sigil.git"
- },
- "workspaces": [
- "packages/*",
- "apps/*"
- ],
- "scripts": {
- "test": "node --test packages/*/test/*.test.js",
- "dev": "npm run dev --workspace @three-ws/sigil-site",
- "dev:api": "npm run dev --workspace @three-ws/sigil-api",
- "build": "npm run build --workspace @three-ws/sigil-site",
- "lint:pack": "node scripts/check-packages.mjs",
- "deploy:pages": "npm run build && npx wrangler pages deploy apps/site/dist --project-name sigil",
- "deploy:worker": "npx wrangler deploy --config apps/api/wrangler.toml"
- },
- "engines": {
- "node": ">=20"
- },
- "devDependencies": {
- "vite": "^7.3.0"
- }
-}
diff --git a/sigil/packages/core/package.json b/sigil/packages/core/package.json
deleted file mode 100644
index ebd1b4050..000000000
--- a/sigil/packages/core/package.json
+++ /dev/null
@@ -1,22 +0,0 @@
-{
- "name": "@three-ws/sigil-core",
- "version": "1.0.0",
- "description": "Exact vanity-address difficulty math for Base58 (Solana) and hex (EVM) address spaces: pattern parsing, probability, expected attempts, ETA, and rarity tiers.",
- "type": "module",
- "main": "./src/index.js",
- "exports": {
- ".": "./src/index.js",
- "./base58": "./src/base58.js",
- "./hex": "./src/hex.js",
- "./package.json": "./package.json"
- },
- "files": ["src", "README.md"],
- "keywords": ["vanity-address", "base58", "solana", "ethereum", "evm", "difficulty", "probability", "rarity", "sigil"],
- "license": "Apache-2.0",
- "author": "nirholas <[email protected]>",
- "homepage": "https://three.ws/sigil",
- "repository": { "type": "git", "url": "git+https://github.com/nirholas/sigil.git", "directory": "packages/core" },
- "engines": { "node": ">=20" },
- "publishConfig": { "access": "public" },
- "scripts": { "test": "node --test test/*.test.js" }
-}
diff --git a/sigil/packages/core/src/base58.js b/sigil/packages/core/src/base58.js
deleted file mode 100644
index db45e9c1f..000000000
--- a/sigil/packages/core/src/base58.js
+++ /dev/null
@@ -1,228 +0,0 @@
-/**
- * The true probability distribution of Base58-encoded Solana addresses.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- * Originally written for three.ws and re-licensed here under the same terms.
- *
- * ── Why this module exists ───────────────────────────────────────────────────
- * Every difficulty, rarity, price and time estimate in the vanity product used
- * to assume each Base58 character is uniform: probability 1/58 per position, so
- * an n-character pattern costs 58ⁿ attempts. That is correct for *trailing*
- * characters and wrong for the *leading* one, because Base58 is a positional
- * numeral encoding of a 32-byte integer, not a string of independent symbols.
- *
- * A Solana key is 32 bytes; once leading zero bytes are stripped it spans
- * [2²⁴⁸, 2²⁵⁶). Base58 encodes such a value in 44 digits when it is at least
- * 58⁴³ and 43 digits otherwise, and two ratios carve the alphabet up:
- *
- * 2²⁵⁶ / 58⁴³ ≈ 17.05 so 44-digit encodings lead with symbols 1..17
- * 2²⁴⁸ / 58⁴² ≈ 3.90 so 43-digit encodings lead with symbols 3..57
- *
- * which yields six bands, spanning 58× in how hard a leading character is to hit:
- *
- * '1' P = 3.906e-3 (a leading zero byte, exactly 1/256)
- * '2'-'3' P = 5.804e-2 (44-digit encodings only)
- * '4' P = 5.814e-2 (plus the sliver of 43-digit that clears 2²⁴⁸)
- * '5'-'H' P = 5.904e-2 (3.43× *easier* than the uniform model claims)
- * 'J' P = 1.433e-2 (0.83×, where the 44-digit range runs out)
- * 'K'-'z' P = 1.001e-3 (17.2× *harder* than claimed, 40 of the 58 symbols)
- *
- * Measured against the uniform model on the live inventory, the median address
- * was 17× harder to grind than its stored difficulty claimed, and patterns
- * leading with '2'-'H' were up to 1.75× easier. Since price and rarity tier are
- * both derived from difficulty, the whole book was mispriced in both directions.
- *
- * ── What this module computes ────────────────────────────────────────────────
- * `prefixProbability` is *exact*, not an approximation or a fitted table: it
- * counts, with BigInt interval arithmetic, how many of the 2²⁵⁶ possible keys
- * encode to a string with the requested prefix. It handles leading-zero bytes
- * (which encode as '1') and arbitrary prefix lengths.
- *
- * Trailing characters genuinely are uniform, the low-order digits of a huge
- * uniform integer are equidistributed to within O(58ⁿ / 2²⁴⁸), far below double
- * precision, so `suffixProbability` stays 58⁻ⁿ.
- *
- * Pure and isomorphic: no I/O, no crypto, identical in browser and server.
- * Pinned against direct sampling of real keypairs in test/base58.test.js.
- */
-
-export const BASE58_ALPHABET =
- '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-
-const INDEX = new Map([...BASE58_ALPHABET].map((c, i) => [c, i]));
-
-/** Solana public keys are 32 bytes; the encoded value space is [0, 2²⁵⁶). */
-const KEY_BYTES = 32;
-const TOTAL = 1n << BigInt(8 * KEY_BYTES);
-
-/** Powers of 58 up to the longest encoding a 32-byte value can produce. */
-const POW58 = [1n];
-for (let i = 1; i <= 64; i++) POW58.push(POW58[i - 1] * 58n);
-
-/**
- * Fixed-point scale for BigInt → Number conversion. 10²⁵ keeps ~16 significant
- * digits for probabilities as small as 58⁻⁶ × 1e-3 ≈ 3e-14, which is well past
- * the 6-character `MAX_PATTERN_LENGTH` ceiling.
- */
-const SCALE = 10n ** 25n;
-const SCALE_N = 1e25;
-
-/**
- * Count the 32-byte values whose Base58 encoding begins with `prefix`.
- * @param {string} prefix
- * @returns {bigint} number of matching values in [0, 2²⁵⁶)
- */
-function prefixCount(prefix) {
- if (!prefix) return TOTAL;
- for (const ch of prefix) {
- if (!INDEX.has(ch)) return 0n; // not a Base58 symbol, unreachable
- }
-
- // Leading '1's are leading *zero bytes*, not digits of the numeral.
- let zeros = 0;
- while (zeros < prefix.length && prefix[zeros] === '1') zeros++;
- if (zeros > KEY_BYTES) return 0n;
- const rest = prefix.slice(zeros);
-
- // All-'1' prefix: every value with at least that many leading zero bytes.
- if (rest === '') return TOTAL >> BigInt(8 * zeros);
-
- // Otherwise the zero-byte run must be *exactly* `zeros` long: the next
- // encoded character is rest[0], which is not '1'. So the remaining bytes
- // form a value with a non-zero leading byte.
- const width = KEY_BYTES - zeros;
- if (width < 1) return 0n;
- const lo = 1n << BigInt(8 * (width - 1));
- const hi = 1n << BigInt(8 * width);
-
- let value = 0n;
- for (const ch of rest) value = value * 58n + BigInt(INDEX.get(ch));
-
- // Strings of total length L that start with `rest` occupy the contiguous
- // integer range [value·58^(L-|rest|), (value+1)·58^(L-|rest|)). Those ranges
- // are disjoint across L, so the matches are their summed overlap with
- // [lo, hi). rest[0] ≠ '1' guarantees each range sits inside the band of
- // values that actually encode to length L, so no extra clamping is needed.
- let count = 0n;
- for (let pad = 0; pad + rest.length <= 64; pad++) {
- const unit = POW58[pad];
- const start = value * unit;
- if (start >= hi) break;
- const end = (value + 1n) * unit;
- const a = start > lo ? start : lo;
- const b = end < hi ? end : hi;
- if (b > a) count += b - a;
- }
- return count;
-}
-
-/**
- * Every Base58-valid case spelling of `pattern`.
- *
- * The alphabet omits `0 O I l`, so some letters have only one usable case:
- * a case-insensitive 'I' can only ever match a literal 'i'. Returns an empty
- * array when a character has no valid spelling at all.
- * @param {string} pattern
- * @returns {string[]}
- */
-export function caseVariants(pattern) {
- let out = [''];
- for (const ch of pattern) {
- const lower = ch.toLowerCase();
- const upper = ch.toUpperCase();
- const set = new Set();
- if (INDEX.has(ch)) set.add(ch);
- if (lower !== upper) {
- if (INDEX.has(lower)) set.add(lower);
- if (INDEX.has(upper)) set.add(upper);
- }
- if (set.size === 0) return [];
- const options = [...set];
- out = out.flatMap((head) => options.map((c) => head + c));
- }
- return out;
-}
-
-/**
- * Exact probability that a uniformly random Solana address starts with `prefix`.
- *
- * @param {string} prefix
- * @param {boolean} [ignoreCase=false]
- * @returns {number} probability in [0, 1]; 0 when the prefix is unreachable
- */
-export function prefixProbability(prefix, ignoreCase = false) {
- if (!prefix) return 1;
- const variants = ignoreCase ? caseVariants(prefix) : [prefix];
- if (variants.length === 0) return 0;
- // Distinct spellings match disjoint value sets, so the counts simply add.
- let count = 0n;
- for (const variant of variants) count += prefixCount(variant);
- if (count === 0n) return 0;
- return Number((count * SCALE) / TOTAL) / SCALE_N;
-}
-
-/**
- * Probability that a uniformly random Solana address ends with `suffix`.
- *
- * Unlike the prefix, this really is 58⁻ⁿ: the low-order digits of a uniform
- * 256-bit integer are equidistributed to within O(58ⁿ / 2²⁴⁸), which is ~1e-64
- * at the 6-character ceiling, far below double precision.
- *
- * @param {string} suffix
- * @param {boolean} [ignoreCase=false]
- * @returns {number} probability in [0, 1]
- */
-export function suffixProbability(suffix, ignoreCase = false) {
- if (!suffix) return 1;
- let p = 1;
- for (const ch of suffix) {
- const lower = ch.toLowerCase();
- const upper = ch.toUpperCase();
- const set = new Set();
- if (INDEX.has(ch)) set.add(ch);
- if (lower !== upper && ignoreCase) {
- if (INDEX.has(lower)) set.add(lower);
- if (INDEX.has(upper)) set.add(upper);
- }
- if (set.size === 0) return 0;
- p *= set.size / 58;
- }
- return p;
-}
-
-/**
- * Probability that a random address satisfies both ends of a vanity pattern.
- *
- * Prefix and suffix are treated as independent. For the 6-character ceiling on
- * each side that costs at most O(58¹² / 2²⁴⁸) ≈ 1e-53 of relative error.
- *
- * @param {object} pattern
- * @param {string} [pattern.prefix]
- * @param {string} [pattern.suffix]
- * @param {boolean} [pattern.ignoreCase=false]
- * @returns {number} probability in [0, 1]
- */
-export function patternProbability({ prefix = '', suffix = '', ignoreCase = false } = {}) {
- return prefixProbability(prefix || '', ignoreCase) * suffixProbability(suffix || '', ignoreCase);
-}
-
-/**
- * The per-character leading probability table, for docs, UI hints and tests.
- * Keys are the 58 alphabet symbols; values are exact probabilities summing to 1.
- * @type {Readonly<Record<string, number>>}
- */
-export const LEADING_CHAR_PROBABILITY = Object.freeze(
- Object.fromEntries([...BASE58_ALPHABET].map((c) => [c, prefixProbability(c, false)])),
-);
-
-/**
- * How much harder (>1) or easier (<1) a leading character is than the naive
- * uniform-1/58 model claims. Useful for explaining a quote to a buyer.
- * @param {string} ch
- * @returns {number}
- */
-export function leadingCharDifficultyRatio(ch) {
- const p = LEADING_CHAR_PROBABILITY[ch];
- if (!p) return Infinity;
- return (1 / 58) / p;
-}
diff --git a/sigil/packages/core/src/difficulty.js b/sigil/packages/core/src/difficulty.js
deleted file mode 100644
index dd04b66fb..000000000
--- a/sigil/packages/core/src/difficulty.js
+++ /dev/null
@@ -1,176 +0,0 @@
-/**
- * Difficulty, ETA and confidence math shared by every Sigil grinder.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- *
- * Grinding is a geometric process: each attempt is an independent Bernoulli
- * trial with success probability `p`, so the honest answers are
- *
- * expected attempts 1 / p
- * median (50% confidence) ln(0.5) / ln(1 - p)
- * n attempts get you 1 - (1 - p)ⁿ
- *
- * Most vanity tools show only the expected value and let users believe it is a
- * deadline. It is not: at the expected attempt count you have had a 63.2% chance
- * of finishing, and one run in twenty takes three times as long. Sigil reports
- * p50/p90/p99 alongside the mean everywhere, because a buyer deciding whether to
- * pay for a grind needs the tail, not the average.
- *
- * Models are versioned and named in every quote and certificate, so an
- * attestation issued under an older model still verifies against the model it
- * was issued under.
- */
-
-import { patternProbability as base58Probability } from './base58.js';
-import { patternProbability as hexProbability, caseSensitivityCost } from './hex.js';
-
-/** Difficulty model identifiers, embedded in quotes and certificates. */
-export const DIFFICULTY_MODELS = Object.freeze({
- solana: 'sigil-base58-exact/v1',
- evm: 'sigil-hex-uniform/v1',
-});
-
-/**
- * Exact probability that one random address in the pattern's space matches.
- * @param {import('./pattern.js').Pattern} pattern
- * @returns {number} probability in [0, 1]
- */
-export function probability(pattern) {
- if (!pattern) return 0;
- if (pattern.space === 'evm') {
- return hexProbability({
- prefix: pattern.prefix,
- suffix: pattern.suffix,
- caseSensitive: pattern.caseSensitive,
- });
- }
- return base58Probability({
- prefix: pattern.prefix,
- suffix: pattern.suffix,
- ignoreCase: !pattern.caseSensitive,
- });
-}
-
-/**
- * Mean number of attempts before a hit. `Infinity` for an unreachable pattern.
- * @param {number} p
- * @returns {number}
- */
-export function expectedAttempts(p) {
- if (!(p > 0)) return Infinity;
- return 1 / p;
-}
-
-/**
- * Attempts needed for a given probability of having found a match.
- * @param {number} p per-attempt probability
- * @param {number} confidence in (0, 1), e.g. 0.5 for the median
- * @returns {number}
- */
-export function attemptsForConfidence(p, confidence) {
- if (!(p > 0)) return Infinity;
- if (!(confidence > 0 && confidence < 1)) throw new RangeError('confidence must be in (0, 1)');
- if (p >= 1) return 1;
- return Math.log(1 - confidence) / Math.log(1 - p);
-}
-
-/**
- * Probability of having found a match after `attempts` tries.
- * @param {number} p
- * @param {number} attempts
- * @returns {number}
- */
-export function probabilityAfter(p, attempts) {
- if (!(p > 0)) return 0;
- if (!(attempts > 0)) return 0;
- return 1 - Math.pow(1 - p, attempts);
-}
-
-/**
- * Seconds to reach a confidence level at a measured hash rate.
- * @param {number} p
- * @param {number} attemptsPerSecond
- * @param {number} [confidence=0.5]
- * @returns {number}
- */
-export function etaSeconds(p, attemptsPerSecond, confidence = 0.5) {
- if (!(attemptsPerSecond > 0)) return Infinity;
- return attemptsForConfidence(p, confidence) / attemptsPerSecond;
-}
-
-/**
- * The full difficulty picture for a pattern, ready to render.
- *
- * @param {import('./pattern.js').Pattern} pattern
- * @param {object} [opts]
- * @param {number} [opts.attemptsPerSecond] measured rate, to add wall-clock ETAs
- * @returns {{
- * model: string, probability: number, expectedAttempts: number,
- * p50: number, p90: number, p99: number,
- * caseCost: number,
- * eta?: { p50: number, p90: number, p99: number, attemptsPerSecond: number }
- * }}
- */
-export function difficulty(pattern, opts = {}) {
- const p = probability(pattern);
- const out = {
- model: DIFFICULTY_MODELS[pattern.space] || DIFFICULTY_MODELS.solana,
- probability: p,
- expectedAttempts: expectedAttempts(p),
- p50: attemptsForConfidence(p, 0.5),
- p90: attemptsForConfidence(p, 0.9),
- p99: attemptsForConfidence(p, 0.99),
- caseCost: pattern.space === 'evm' && pattern.caseSensitive
- ? caseSensitivityCost({ prefix: pattern.prefix, suffix: pattern.suffix })
- : 1,
- };
- const rate = opts.attemptsPerSecond;
- if (rate > 0) {
- out.eta = {
- attemptsPerSecond: rate,
- p50: out.p50 / rate,
- p90: out.p90 / rate,
- p99: out.p99 / rate,
- };
- }
- return out;
-}
-
-const UNITS = [
- [1, 'second'], [60, 'minute'], [3600, 'hour'], [86400, 'day'],
- [86400 * 365.25, 'year'], [86400 * 365.25 * 1000, 'millennium'],
-];
-
-/**
- * Human duration: "12 seconds", "3.4 hours", "longer than the universe".
- * @param {number} seconds
- * @returns {string}
- */
-export function formatDuration(seconds) {
- if (!Number.isFinite(seconds)) return 'never';
- if (seconds < 1) return 'under a second';
- if (seconds > 86400 * 365.25 * 13.8e9) return 'longer than the universe has existed';
- let unit = UNITS[0];
- for (const u of UNITS) if (seconds >= u[0]) unit = u;
- const value = seconds / unit[0];
- const rounded = value >= 100 ? Math.round(value) : Number(value.toPrecision(2));
- const label = unit[1] === 'millennium' ? (rounded === 1 ? 'millennium' : 'millennia') : unit[1];
- return `${rounded.toLocaleString('en-US')} ${label}${unit[1] !== 'millennium' && rounded !== 1 ? 's' : ''}`;
-}
-
-/**
- * Human attempt count: "65.5 thousand", "1.2 billion".
- * @param {number} n
- * @returns {string}
- */
-export function formatAttempts(n) {
- if (!Number.isFinite(n)) return 'unreachable';
- const steps = [
- [1e18, 'quintillion'], [1e15, 'quadrillion'], [1e12, 'trillion'],
- [1e9, 'billion'], [1e6, 'million'], [1e3, 'thousand'],
- ];
- for (const [size, label] of steps) {
- if (n >= size) return `${Number((n / size).toPrecision(3)).toLocaleString('en-US')} ${label}`;
- }
- return Math.round(n).toLocaleString('en-US');
-}
diff --git a/sigil/packages/core/src/hex.js b/sigil/packages/core/src/hex.js
deleted file mode 100644
index 281fdd054..000000000
--- a/sigil/packages/core/src/hex.js
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * The probability distribution of hex-encoded EVM addresses.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- *
- * ── Why this is simpler than Base58 ──────────────────────────────────────────
- * A Solana address is a *numeral* (a 256-bit integer rendered in Base58), so its
- * leading character is not uniform. An EVM address is not a numeral: it is the
- * low 20 bytes of a Keccak-256 digest, rendered as a fixed 40-character hex
- * string with no length variance and no leading-zero stripping. Every one of the
- * 40 nibbles is independently uniform over 16 symbols, at both ends. So the
- * honest model here really is 16⁻ⁿ, and `0x0000…` is exactly as hard as
- * `0xdead…`: 65 536 expected attempts for four nibbles, either way.
- *
- * That holds for all three EVM address derivations Sigil grinds:
- *
- * EOA address = keccak256(uncompressed pubkey[1:])[12:]
- * CREATE address = keccak256(rlp([sender, nonce]))[12:]
- * CREATE2 address = keccak256(0xff ‖ deployer ‖ salt ‖ initCodeHash)[12:]
- *
- * ── The case dimension (EIP-55) ──────────────────────────────────────────────
- * EIP-55 re-cases the hex letters of an address using bits of
- * keccak256(lowercase address), which behave as fair coin flips. Asking for a
- * *specific* case spelling therefore costs an extra factor of two per letter in
- * the pattern: `dead` (4 letters) is 16 times harder to hit as `dEaD` than as
- * any-case `dead`. Digits 0-9 carry no case and cost nothing extra.
- *
- * That is the single most misquoted number in EVM vanity tooling: a mixed-case
- * request is not "the same speed", it is 2^letters harder, and Sigil prices and
- * ETAs say so.
- *
- * Pure and isomorphic: no I/O, no crypto, identical in browser and server.
- */
-
-export const HEX_ALPHABET = '0123456789abcdef';
-
-const HEX_SET = new Set([...'0123456789abcdefABCDEF']);
-const LETTER_SET = new Set([...'abcdefABCDEF']);
-
-/** Every EVM address is 20 bytes = 40 hex nibbles. */
-export const EVM_ADDRESS_NIBBLES = 40;
-
-/** @param {string} s @returns {boolean} */
-export function isHexPattern(s) {
- if (typeof s !== 'string') return false;
- for (const ch of s) if (!HEX_SET.has(ch)) return false;
- return true;
-}
-
-/**
- * Count the case-carrying characters (a-f) in a pattern. Each one doubles the
- * work when the match is case-sensitive (EIP-55).
- * @param {string} pattern
- * @returns {number}
- */
-export function letterCount(pattern) {
- let n = 0;
- for (const ch of pattern || '') if (LETTER_SET.has(ch)) n++;
- return n;
-}
-
-/**
- * Probability that a uniformly random EVM address starts with `prefix`.
- * @param {string} prefix hex characters, without the `0x`
- * @param {boolean} [caseSensitive=false] match EIP-55 casing exactly
- * @returns {number} probability in [0, 1]; 0 when the prefix is unreachable
- */
-export function prefixProbability(prefix, caseSensitive = false) {
- return sideProbability(prefix, caseSensitive);
-}
-
-/**
- * Probability that a uniformly random EVM address ends with `suffix`.
- * Identical model to the prefix: every nibble is uniform.
- * @param {string} suffix hex characters, without the `0x`
- * @param {boolean} [caseSensitive=false]
- * @returns {number} probability in [0, 1]
- */
-export function suffixProbability(suffix, caseSensitive = false) {
- return sideProbability(suffix, caseSensitive);
-}
-
-/**
- * @param {string} side
- * @param {boolean} caseSensitive
- * @returns {number}
- */
-function sideProbability(side, caseSensitive) {
- if (!side) return 1;
- if (!isHexPattern(side)) return 0;
- if (side.length > EVM_ADDRESS_NIBBLES) return 0;
- const base = Math.pow(16, -side.length);
- return caseSensitive ? base * Math.pow(2, -letterCount(side)) : base;
-}
-
-/**
- * Probability that a random EVM address satisfies both ends of a pattern.
- *
- * Prefix and suffix cover disjoint nibbles as long as they fit inside the 40
- * available, so the two probabilities simply multiply. A pattern longer than the
- * address is unreachable and scores 0.
- *
- * @param {object} pattern
- * @param {string} [pattern.prefix]
- * @param {string} [pattern.suffix]
- * @param {boolean} [pattern.caseSensitive=false]
- * @returns {number} probability in [0, 1]
- */
-export function patternProbability({ prefix = '', suffix = '', caseSensitive = false } = {}) {
- if ((prefix?.length || 0) + (suffix?.length || 0) > EVM_ADDRESS_NIBBLES) return 0;
- return sideProbability(prefix || '', caseSensitive) * sideProbability(suffix || '', caseSensitive);
-}
-
-/**
- * How much harder a case-sensitive (EIP-55) spelling is than the any-case one.
- * @param {object} pattern
- * @param {string} [pattern.prefix]
- * @param {string} [pattern.suffix]
- * @returns {number} multiplier ≥ 1
- */
-export function caseSensitivityCost({ prefix = '', suffix = '' } = {}) {
- return Math.pow(2, letterCount(prefix) + letterCount(suffix));
-}
diff --git a/sigil/packages/core/src/index.js b/sigil/packages/core/src/index.js
deleted file mode 100644
index dcdc8b070..000000000
--- a/sigil/packages/core/src/index.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * @three-ws/sigil-core: the shared math behind every Sigil grinder.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- *
- * ```js
- * import { quote } from '@three-ws/sigil-core';
- *
- * const q = quote({ space: 'solana', prefix: 'sig', suffix: 'il' });
- * q.rarity.label; // 'Epic'
- * q.difficulty.p90; // attempts for a 90% chance
- * ```
- */
-
-export {
- BASE58_ALPHABET,
- caseVariants,
- prefixProbability as base58PrefixProbability,
- suffixProbability as base58SuffixProbability,
- patternProbability as base58PatternProbability,
- LEADING_CHAR_PROBABILITY,
- leadingCharDifficultyRatio,
-} from './base58.js';
-
-export {
- HEX_ALPHABET,
- EVM_ADDRESS_NIBBLES,
- isHexPattern,
- letterCount,
- prefixProbability as hexPrefixProbability,
- suffixProbability as hexSuffixProbability,
- patternProbability as hexPatternProbability,
- caseSensitivityCost,
-} from './hex.js';
-
-export {
- SPACES,
- MAX_PATTERN_LENGTH,
- parsePattern,
- createMatcher,
- patternKey,
- parsePatternKey,
- describePattern,
-} from './pattern.js';
-
-export {
- DIFFICULTY_MODELS,
- probability,
- expectedAttempts,
- attemptsForConfidence,
- probabilityAfter,
- etaSeconds,
- difficulty,
- formatDuration,
- formatAttempts,
-} from './difficulty.js';
-
-export { TIERS, tierFor, rarityScore, machineCost, rarity } from './rarity.js';
-
-import { parsePattern, describePattern, patternKey } from './pattern.js';
-import { difficulty } from './difficulty.js';
-import { rarity } from './rarity.js';
-
-/**
- * Parse a request and price it in one call: the shape every Sigil surface
- * (site, CLI, MCP tool, HTTP API) hands back.
- *
- * @param {object} input see {@link parsePattern}
- * @param {object} [opts]
- * @param {number} [opts.attemptsPerSecond] measured rate, adds wall-clock ETAs
- * @param {number} [opts.usdPerCoreHour]
- * @returns {{ ok: boolean, errors: string[], pattern: import('./pattern.js').Pattern,
- * key: string, describe: string,
- * difficulty: ReturnType<typeof difficulty>, rarity: ReturnType<typeof rarity> }}
- */
-export function quote(input, opts = {}) {
- const parsed = parsePattern(input);
- const d = difficulty(parsed.pattern, opts);
- return {
- ok: parsed.ok,
- errors: parsed.errors,
- pattern: parsed.pattern,
- key: patternKey(parsed.pattern),
- describe: describePattern(parsed.pattern),
- difficulty: d,
- rarity: rarity(d, opts),
- };
-}
diff --git a/sigil/packages/core/src/pattern.js b/sigil/packages/core/src/pattern.js
deleted file mode 100644
index c03585cee..000000000
--- a/sigil/packages/core/src/pattern.js
+++ /dev/null
@@ -1,179 +0,0 @@
-/**
- * One pattern object for every chain Sigil grinds.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- *
- * A vanity request is always the same four facts: which address space, what the
- * address should start with, what it should end with, and whether the casing has
- * to match exactly. The two address spaces disagree on everything else. Base58
- * has a non-uniform leading character and an alphabet with holes (`0 O I l` are
- * absent), hex is uniform and only 16 wide but carries EIP-55 casing, so this
- * module normalizes the request once and every other package consumes the
- * normalized form.
- *
- * `parsePattern` never throws: it returns `errors`, so a UI can render the
- * problem next to the field the user is typing in rather than in a try/catch.
- */
-
-import { BASE58_ALPHABET, caseVariants } from './base58.js';
-import { isHexPattern, letterCount, EVM_ADDRESS_NIBBLES } from './hex.js';
-
-/** The address spaces Sigil can grind. */
-export const SPACES = /** @type {const} */ (['solana', 'evm']);
-
-/**
- * Practical ceilings. Above these a browser grind is measured in years, so the
- * UI refuses rather than showing a progress bar that will never finish; the
- * distributed/pool path lifts them.
- */
-export const MAX_PATTERN_LENGTH = Object.freeze({ solana: 8, evm: 12 });
-
-const BASE58_SET = new Set([...BASE58_ALPHABET]);
-
-/**
- * @typedef {object} Pattern
- * @property {'solana'|'evm'} space
- * @property {string} prefix normalized (EVM: lowercase unless caseSensitive)
- * @property {string} suffix
- * @property {boolean} caseSensitive
- * @property {number} length prefix.length + suffix.length
- */
-
-/**
- * @typedef {object} ParsedPattern
- * @property {boolean} ok
- * @property {string[]} errors
- * @property {Pattern} pattern
- */
-
-/**
- * Normalize and validate a vanity request.
- *
- * @param {object} input
- * @param {'solana'|'evm'} [input.space='solana']
- * @param {string} [input.prefix]
- * @param {string} [input.suffix]
- * @param {boolean} [input.caseSensitive] EVM defaults to "sensitive iff the
- * pattern contains an uppercase letter"; Solana defaults to true, because
- * Base58 casing is part of the symbol.
- * @returns {ParsedPattern}
- */
-export function parsePattern(input = {}) {
- const space = input.space === 'evm' ? 'evm' : 'solana';
- const errors = [];
-
- let prefix = String(input.prefix ?? '').trim();
- let suffix = String(input.suffix ?? '').trim();
-
- if (space === 'evm') {
- prefix = prefix.replace(/^0x/i, '');
- suffix = suffix.replace(/^0x/i, '');
- }
-
- const hasUpper = /[A-Z]/.test(prefix + suffix);
- const caseSensitive = typeof input.caseSensitive === 'boolean'
- ? input.caseSensitive
- : (space === 'evm' ? hasUpper : true);
-
- if (space === 'evm' && !caseSensitive) {
- prefix = prefix.toLowerCase();
- suffix = suffix.toLowerCase();
- }
-
- if (!prefix && !suffix) errors.push('give a prefix, a suffix, or both');
-
- const max = MAX_PATTERN_LENGTH[space];
- if (prefix.length + suffix.length > max) {
- errors.push(`pattern is longer than ${max} characters for ${space}`);
- }
-
- if (space === 'solana') {
- for (const side of [prefix, suffix]) {
- for (const ch of side) {
- if (!BASE58_SET.has(ch)) {
- errors.push(`"${ch}" is not a Base58 character (0, O, I and l do not exist)`);
- break;
- }
- }
- }
- if (!caseSensitive) {
- if (prefix && caseVariants(prefix).length === 0) errors.push('prefix has no valid Base58 spelling');
- if (suffix && caseVariants(suffix).length === 0) errors.push('suffix has no valid Base58 spelling');
- }
- } else {
- if (prefix && !isHexPattern(prefix)) errors.push('prefix must be hex characters (0-9, a-f)');
- if (suffix && !isHexPattern(suffix)) errors.push('suffix must be hex characters (0-9, a-f)');
- if (prefix.length + suffix.length > EVM_ADDRESS_NIBBLES) errors.push('pattern is longer than an EVM address');
- }
-
- return {
- ok: errors.length === 0,
- errors,
- pattern: { space, prefix, suffix, caseSensitive, length: prefix.length + suffix.length },
- };
-}
-
-/**
- * Build a fast predicate for a normalized pattern.
- *
- * The returned function takes an address string in that space's canonical
- * rendering (Base58 for Solana, `0x`-prefixed hex for EVM, checksummed when the
- * pattern is case-sensitive) and answers whether it matches.
- *
- * @param {Pattern} pattern
- * @returns {(address: string) => boolean}
- */
-export function createMatcher(pattern) {
- const { space, caseSensitive } = pattern;
- const prefix = caseSensitive ? pattern.prefix : pattern.prefix.toLowerCase();
- const suffix = caseSensitive ? pattern.suffix : pattern.suffix.toLowerCase();
- const strip = space === 'evm';
-
- return (address) => {
- if (typeof address !== 'string') return false;
- let body = strip ? address.replace(/^0x/i, '') : address;
- if (!caseSensitive) body = body.toLowerCase();
- if (prefix && !body.startsWith(prefix)) return false;
- if (suffix && !body.endsWith(suffix)) return false;
- return true;
- };
-}
-
-/**
- * A stable, URL-safe string for a pattern. Used as a cache key, a bounty id
- * component, and the value signed inside a proof-of-grind certificate, so it
- * must round-trip exactly.
- * @param {Pattern} pattern
- * @returns {string}
- */
-export function patternKey(pattern) {
- const flags = pattern.caseSensitive ? 'cs' : 'ci';
- return `${pattern.space}:${pattern.prefix}:${pattern.suffix}:${flags}`;
-}
-
-/**
- * Parse a `patternKey` back into a pattern.
- * @param {string} key
- * @returns {ParsedPattern}
- */
-export function parsePatternKey(key) {
- const [space, prefix = '', suffix = '', flags = 'cs'] = String(key).split(':');
- return parsePattern({ space, prefix, suffix, caseSensitive: flags === 'cs' });
-}
-
-/**
- * Human summary of a pattern, e.g. `SoL…pump (case-sensitive)`.
- * @param {Pattern} pattern
- * @returns {string}
- */
-export function describePattern(pattern) {
- const head = pattern.prefix || '';
- const tail = pattern.suffix || '';
- const shape = pattern.space === 'evm'
- ? `0x${head || ''}${head && tail ? '…' : (head ? '…' : '…')}${tail}`
- : `${head}${head && tail ? '…' : (head ? '…' : '…')}${tail}`;
- return `${shape} (${pattern.caseSensitive ? 'case-sensitive' : 'any case'})`;
-}
-
-/** How many case-carrying characters a pattern has (EVM only; 0 for Solana). */
-export { letterCount };
diff --git a/sigil/packages/core/src/rarity.js b/sigil/packages/core/src/rarity.js
deleted file mode 100644
index fb6eb55ca..000000000
--- a/sigil/packages/core/src/rarity.js
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * Rarity tiers and a cross-chain rarity score.
- *
- * Part of Sigil (https://github.com/nirholas/sigil). Apache-2.0.
- *
- * Difficulty is the honest number, but "1 in 656 356 768" means nothing to a
- * buyer looking at two addresses side by side. The score below maps expected
- * attempts onto a 0-100 scale that is *comparable across address spaces*: a
- * Solana address and an EVM address with the same score cost the same expected
- * work, even though one is Base58 and the other hex.
- *
- * The scale is logarithmic because the underlying quantity is: every extra
- * character multiplies the work by 16 (hex) or ~58 (Base58), so a linear score
- * would put every interesting address in the top percent. 100 is pinned at
- * 10^18 expected attempts, roughly the point where a single machine cannot
- * finish inside a human lifetime and only a pool can.
- */
-
-/** @typedef {'common'|'uncommon'|'rare'|'epic'|'legendary'|'mythic'} Tier */
-
-/** Tier thresholds, in expected attempts. Ordered hardest-first for lookup. */
-export const TIERS = Object.freeze([
- { tier: 'mythic', minAttempts: 1e12, label: 'Mythic' },
- { tier: 'legendary', minAttempts: 1e9, label: 'Legendary' },
- { tier: 'epic', minAttempts: 1e7, label: 'Epic' },
- { tier: 'rare', minAttempts: 1e5, label: 'Rare' },
- { tier: 'uncommon', minAttempts: 1e3, label: 'Uncommon' },
- { tier: 'common', minAttempts: 0, label: 'Common' },
-]);
-
-/**
- * @param {number} expectedAttempts
- * @returns {{ tier: Tier, label: string, minAttempts: number }}
- */
-export function tierFor(expectedAttempts) {
- if (!Number.isFinite(expectedAttempts)) return { tier: 'mythic', label: 'Mythic', minAttempts: 1e12 };
- for (const t of TIERS) if (expectedAttempts >= t.minAttempts) return t;
- return TIERS[TIERS.length - 1];
-}
-
-/** The score at which the scale saturates: 10^18 expected attempts. */
-const SCORE_CEILING_LOG10 = 18;
-
-/**
- * A 0-100 rarity score, comparable across chains.
- * @param {number} expectedAttempts
- * @returns {number} rounded to one decimal
- */
-export function rarityScore(expectedAttempts) {
- if (!Number.isFinite(expectedAttempts) || expectedAttempts <= 1) return 0;
- const raw = (Math.log10(expectedAttempts) / SCORE_CEILING_LOG10) * 100;
- return Math.round(Math.min(100, Math.max(0, raw)) * 10) / 10;
-}
-
-/**
- * What the grind would cost in machine time, priced from a reference rate.
- *
- * Defaults describe one commodity cloud vCPU running the Sigil WASM grinder:
- * ~1.1 M attempts/second measured on a Cloud Run 1-vCPU instance, at the current
- * spot price for that vCPU-hour. Both are inputs, not hidden constants: pass
- * your own to price against your own fleet.
- *
- * @param {number} expectedAttempts
- * @param {object} [opts]
- * @param {number} [opts.attemptsPerSecond=1_100_000]
- * @param {number} [opts.usdPerCoreHour=0.0113]
- * @returns {{ coreHours: number, usd: number, attemptsPerSecond: number, usdPerCoreHour: number }}
- */
-export function machineCost(expectedAttempts, opts = {}) {
- const attemptsPerSecond = opts.attemptsPerSecond ?? 1_100_000;
- const usdPerCoreHour = opts.usdPerCoreHour ?? 0.0113;
- const coreHours = expectedAttempts / attemptsPerSecond / 3600;
- return {
- coreHours,
- usd: coreHours * usdPerCoreHour,
- attemptsPerSecond,
- usdPerCoreHour,
- };
-}
-
-/**
- * The full rarity picture for a difficulty result.
- * @param {{ expectedAttempts: number }} difficultyResult
- * @param {object} [costOpts] forwarded to {@link machineCost}
- * @returns {{ tier: Tier, label: string, score: number, expectedAttempts: number, cost: ReturnType<typeof machineCost> }}
- */
-export function rarity(difficultyResult, costOpts) {
- const attempts = difficultyResult.expectedAttempts;
- const t = tierFor(attempts);
- return {
- tier: t.tier,
- label: t.label,
- score: rarityScore(attempts),
- expectedAttempts: attempts,
- cost: machineCost(attempts, costOpts),
- };
-}