diff --git a/assets/auth.html b/assets/auth.html
index b3dd577..667ec10 100644
--- a/assets/auth.html
+++ b/assets/auth.html
@@ -5,1671 +5,1111 @@
"use strict"
// Set the header of the page.
document.title = "Lume Web: Login"
- const HASH_SIZE = 64
- var K = [
- 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b,
- 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242,
- 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe,
- 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
- 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc,
- 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f,
- 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967,
- 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
- 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1,
- 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218,
- 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08,
- 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
- 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814,
- 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915,
- 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f,
- 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
- 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be,
- 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
- ]
- function ts64(x, i, h, l) {
- x[i] = (h >> 24) & 0xff
- x[i + 1] = (h >> 16) & 0xff
- x[i + 2] = (h >> 8) & 0xff
- x[i + 3] = h & 0xff
- x[i + 4] = (l >> 24) & 0xff
- x[i + 5] = (l >> 16) & 0xff
- x[i + 6] = (l >> 8) & 0xff
- x[i + 7] = l & 0xff
- }
- function crypto_hashblocks_hl(hh, hl, m, n) {
- var wh = new Int32Array(16),
- wl = new Int32Array(16),
- bh0,
- bh1,
- bh2,
- bh3,
- bh4,
- bh5,
- bh6,
- bh7,
- bl0,
- bl1,
- bl2,
- bl3,
- bl4,
- bl5,
- bl6,
- bl7,
- th,
- tl,
- i,
- j,
- h,
- l,
- a,
- b,
- c,
- d
- var ah0 = hh[0],
- ah1 = hh[1],
- ah2 = hh[2],
- ah3 = hh[3],
- ah4 = hh[4],
- ah5 = hh[5],
- ah6 = hh[6],
- ah7 = hh[7],
- al0 = hl[0],
- al1 = hl[1],
- al2 = hl[2],
- al3 = hl[3],
- al4 = hl[4],
- al5 = hl[5],
- al6 = hl[6],
- al7 = hl[7]
- var pos = 0
- while (n >= 128) {
- for (i = 0; i < 16; i++) {
- j = 8 * i + pos
- wh[i] = (m[j + 0] << 24) | (m[j + 1] << 16) | (m[j + 2] << 8) | m[j + 3]
- wl[i] = (m[j + 4] << 24) | (m[j + 5] << 16) | (m[j + 6] << 8) | m[j + 7]
- }
- for (i = 0; i < 80; i++) {
- bh0 = ah0
- bh1 = ah1
- bh2 = ah2
- bh3 = ah3
- bh4 = ah4
- bh5 = ah5
- bh6 = ah6
- bh7 = ah7
- bl0 = al0
- bl1 = al1
- bl2 = al2
- bl3 = al3
- bl4 = al4
- bl5 = al5
- bl6 = al6
- bl7 = al7
- // add
- h = ah7
- l = al7
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- // Sigma1
- h =
- ((ah4 >>> 14) | (al4 << (32 - 14))) ^
- ((ah4 >>> 18) | (al4 << (32 - 18))) ^
- ((al4 >>> (41 - 32)) | (ah4 << (32 - (41 - 32))))
- l =
- ((al4 >>> 14) | (ah4 << (32 - 14))) ^
- ((al4 >>> 18) | (ah4 << (32 - 18))) ^
- ((ah4 >>> (41 - 32)) | (al4 << (32 - (41 - 32))))
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // Ch
- h = (ah4 & ah5) ^ (~ah4 & ah6)
- l = (al4 & al5) ^ (~al4 & al6)
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // K
- h = K[i * 2]
- l = K[i * 2 + 1]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // w
- h = wh[i % 16]
- l = wl[i % 16]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- th = (c & 0xffff) | (d << 16)
- tl = (a & 0xffff) | (b << 16)
- // add
- h = th
- l = tl
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- // Sigma0
- h =
- ((ah0 >>> 28) | (al0 << (32 - 28))) ^
- ((al0 >>> (34 - 32)) | (ah0 << (32 - (34 - 32)))) ^
- ((al0 >>> (39 - 32)) | (ah0 << (32 - (39 - 32))))
- l =
- ((al0 >>> 28) | (ah0 << (32 - 28))) ^
- ((ah0 >>> (34 - 32)) | (al0 << (32 - (34 - 32)))) ^
- ((ah0 >>> (39 - 32)) | (al0 << (32 - (39 - 32))))
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // Maj
- h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2)
- l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2)
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- bh7 = (c & 0xffff) | (d << 16)
- bl7 = (a & 0xffff) | (b << 16)
- // add
- h = bh3
- l = bl3
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = th
- l = tl
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- bh3 = (c & 0xffff) | (d << 16)
- bl3 = (a & 0xffff) | (b << 16)
- ah1 = bh0
- ah2 = bh1
- ah3 = bh2
- ah4 = bh3
- ah5 = bh4
- ah6 = bh5
- ah7 = bh6
- ah0 = bh7
- al1 = bl0
- al2 = bl1
- al3 = bl2
- al4 = bl3
- al5 = bl4
- al6 = bl5
- al7 = bl6
- al0 = bl7
- if (i % 16 === 15) {
- for (j = 0; j < 16; j++) {
- // add
- h = wh[j]
- l = wl[j]
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = wh[(j + 9) % 16]
- l = wl[(j + 9) % 16]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // sigma0
- th = wh[(j + 1) % 16]
- tl = wl[(j + 1) % 16]
- h = ((th >>> 1) | (tl << (32 - 1))) ^ ((th >>> 8) | (tl << (32 - 8))) ^ (th >>> 7)
- l = ((tl >>> 1) | (th << (32 - 1))) ^ ((tl >>> 8) | (th << (32 - 8))) ^ ((tl >>> 7) | (th << (32 - 7)))
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- // sigma1
- th = wh[(j + 14) % 16]
- tl = wl[(j + 14) % 16]
- h = ((th >>> 19) | (tl << (32 - 19))) ^ ((tl >>> (61 - 32)) | (th << (32 - (61 - 32)))) ^ (th >>> 6)
- l =
- ((tl >>> 19) | (th << (32 - 19))) ^
- ((th >>> (61 - 32)) | (tl << (32 - (61 - 32)))) ^
- ((tl >>> 6) | (th << (32 - 6)))
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- wh[j] = (c & 0xffff) | (d << 16)
- wl[j] = (a & 0xffff) | (b << 16)
- }
- }
- }
- // add
- h = ah0
- l = al0
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[0]
- l = hl[0]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[0] = ah0 = (c & 0xffff) | (d << 16)
- hl[0] = al0 = (a & 0xffff) | (b << 16)
- h = ah1
- l = al1
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[1]
- l = hl[1]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[1] = ah1 = (c & 0xffff) | (d << 16)
- hl[1] = al1 = (a & 0xffff) | (b << 16)
- h = ah2
- l = al2
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[2]
- l = hl[2]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[2] = ah2 = (c & 0xffff) | (d << 16)
- hl[2] = al2 = (a & 0xffff) | (b << 16)
- h = ah3
- l = al3
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[3]
- l = hl[3]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[3] = ah3 = (c & 0xffff) | (d << 16)
- hl[3] = al3 = (a & 0xffff) | (b << 16)
- h = ah4
- l = al4
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[4]
- l = hl[4]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[4] = ah4 = (c & 0xffff) | (d << 16)
- hl[4] = al4 = (a & 0xffff) | (b << 16)
- h = ah5
- l = al5
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[5]
- l = hl[5]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[5] = ah5 = (c & 0xffff) | (d << 16)
- hl[5] = al5 = (a & 0xffff) | (b << 16)
- h = ah6
- l = al6
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[6]
- l = hl[6]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[6] = ah6 = (c & 0xffff) | (d << 16)
- hl[6] = al6 = (a & 0xffff) | (b << 16)
- h = ah7
- l = al7
- a = l & 0xffff
- b = l >>> 16
- c = h & 0xffff
- d = h >>> 16
- h = hh[7]
- l = hl[7]
- a += l & 0xffff
- b += l >>> 16
- c += h & 0xffff
- d += h >>> 16
- b += a >>> 16
- c += b >>> 16
- d += c >>> 16
- hh[7] = ah7 = (c & 0xffff) | (d << 16)
- hl[7] = al7 = (a & 0xffff) | (b << 16)
- pos += 128
- n -= 128
- }
- return n
- }
- var sha512internal = function (out, m, n) {
- var hh = new Int32Array(8),
- hl = new Int32Array(8),
- x = new Uint8Array(256),
- i,
- b = n
- hh[0] = 0x6a09e667
- hh[1] = 0xbb67ae85
- hh[2] = 0x3c6ef372
- hh[3] = 0xa54ff53a
- hh[4] = 0x510e527f
- hh[5] = 0x9b05688c
- hh[6] = 0x1f83d9ab
- hh[7] = 0x5be0cd19
- hl[0] = 0xf3bcc908
- hl[1] = 0x84caa73b
- hl[2] = 0xfe94f82b
- hl[3] = 0x5f1d36f1
- hl[4] = 0xade682d1
- hl[5] = 0x2b3e6c1f
- hl[6] = 0xfb41bd6b
- hl[7] = 0x137e2179
- crypto_hashblocks_hl(hh, hl, m, n)
- n %= 128
- for (i = 0; i < n; i++) x[i] = m[b - n + i]
- x[n] = 128
- n = 256 - 128 * (n < 112 ? 1 : 0)
- x[n - 9] = 0
- ts64(x, n - 8, (b / 0x20000000) | 0, b << 3)
- crypto_hashblocks_hl(hh, hl, x, n)
- for (i = 0; i < 8; i++) ts64(out, 8 * i, hh[i], hl[i])
- return 0
- }
- // sha512 is the standard sha512 cryptographic hash function. This is the
- // default choice for Skynet operations, though many of the Sia protocol
- // standards use blake2b instead, so you will see both.
- var sha512 = function (m) {
- let out = new Uint8Array(64)
- sha512internal(out, m, m.length)
- return out
- }
- // addContextToErr is a helper function that standardizes the formatting of
- // adding context to an error. Within the world of go we discovered that being
- // very persistent about layering context onto errors is incredibly helpful
- // when debugging, even though it often creates comically verbose error
- // messages. Trust me, it's well worth the tradeoff.
- var addContextToErr = function (err, context) {
- return new Error(context + ": " + err.message)
- }
- // DICTIONARY_UNIQUE_PREFIX defines the number of characters that are
- // guaranteed to be unique for each word in the dictionary. The seed code only
- // looks at these three characters when parsing a word, allowing users to make
- // substitutions for words if they prefer or find it easier to memorize.
- const DICTIONARY_UNIQUE_PREFIX = 3
- // Define the number of entropy words used when generating the seed.
- const SEED_ENTROPY_WORDS = 13
- const SEED_CHECKSUM_WORDS = 2 // Not used, but left as documentation.
- const SEED_BYTES = 16
- // dictionary contains the word list for the mysky seed.
- const dictionary = [
- "abbey",
- "ablaze",
- "abort",
- "absorb",
- "abyss",
- "aces",
- "aching",
- "acidic",
- "across",
- "acumen",
- "adapt",
- "adept",
- "adjust",
- "adopt",
- "adult",
- "aerial",
- "afar",
- "affair",
- "afield",
- "afloat",
- "afoot",
- "afraid",
- "after",
- "agenda",
- "agile",
- "aglow",
- "agony",
- "agreed",
- "ahead",
- "aided",
- "aisle",
- "ajar",
- "akin",
- "alarms",
- "album",
- "alerts",
- "alley",
- "almost",
- "aloof",
- "alpine",
- "also",
- "alumni",
- "always",
- "amaze",
- "ambush",
- "amidst",
- "ammo",
- "among",
- "amply",
- "amused",
- "anchor",
- "angled",
- "ankle",
- "antics",
- "anvil",
- "apart",
- "apex",
- "aphid",
- "aplomb",
- "apply",
- "archer",
- "ardent",
- "arena",
- "argue",
- "arises",
- "army",
- "around",
- "arrow",
- "ascend",
- "aside",
- "asked",
- "asleep",
- "aspire",
- "asylum",
- "atlas",
- "atom",
- "atrium",
- "attire",
- "auburn",
- "audio",
- "august",
- "aunt",
- "autumn",
- "avatar",
- "avidly",
- "avoid",
- "awful",
- "awning",
- "awoken",
- "axes",
- "axis",
- "axle",
- "aztec",
- "azure",
- "baby",
- "bacon",
- "badge",
- "bailed",
- "bakery",
- "bamboo",
- "banjo",
- "basin",
- "batch",
- "bawled",
- "bays",
- "beer",
- "befit",
- "begun",
- "behind",
- "being",
- "below",
- "bested",
- "bevel",
- "beware",
- "beyond",
- "bias",
- "bids",
- "bikini",
- "birth",
- "bite",
- "blip",
- "boat",
- "bodies",
- "bogeys",
- "boil",
- "boldly",
- "bomb",
- "border",
- "boss",
- "both",
- "bovine",
- "boxes",
- "broken",
- "brunt",
- "bubble",
- "budget",
- "buffet",
- "bugs",
- "bulb",
- "bumper",
- "bunch",
- "butter",
- "buying",
- "buzzer",
- "byline",
- "bypass",
- "cabin",
- "cactus",
- "cadets",
- "cafe",
- "cage",
- "cajun",
- "cake",
- "camp",
- "candy",
- "casket",
- "catch",
- "cause",
- "cease",
- "cedar",
- "cell",
- "cement",
- "cent",
- "chrome",
- "cider",
- "cigar",
- "cinema",
- "circle",
- "claim",
- "click",
- "clue",
- "coal",
- "cobra",
- "cocoa",
- "code",
- "coffee",
- "cogs",
- "coils",
- "colony",
- "comb",
- "cool",
- "copy",
- "cousin",
- "cowl",
- "cube",
- "cuffs",
- "custom",
- "dads",
- "daft",
- "dagger",
- "daily",
- "damp",
- "dapper",
- "darted",
- "dash",
- "dating",
- "dawn",
- "dazed",
- "debut",
- "decay",
- "deftly",
- "deity",
- "dented",
- "depth",
- "desk",
- "devoid",
- "dice",
- "diet",
- "digit",
- "dilute",
- "dime",
- "dinner",
- "diode",
- "ditch",
- "divers",
- "dizzy",
- "doctor",
- "dodge",
- "does",
- "dogs",
- "doing",
- "donuts",
- "dosage",
- "dotted",
- "double",
- "dove",
- "down",
- "dozen",
- "dreams",
- "drinks",
- "drunk",
- "drying",
- "dual",
- "dubbed",
- "dude",
- "duets",
- "duke",
- "dummy",
- "dunes",
- "duplex",
- "dusted",
- "duties",
- "dwarf",
- "dwelt",
- "dying",
- "each",
- "eagle",
- "earth",
- "easy",
- "eating",
- "echo",
- "eden",
- "edgy",
- "edited",
- "eels",
- "eggs",
- "eight",
- "either",
- "eject",
- "elapse",
- "elbow",
- "eldest",
- "eleven",
- "elite",
- "elope",
- "else",
- "eluded",
- "emails",
- "ember",
- "emerge",
- "emit",
- "empty",
- "energy",
- "enigma",
- "enjoy",
- "enlist",
- "enmity",
- "enough",
- "ensign",
- "envy",
- "epoxy",
- "equip",
- "erase",
- "error",
- "estate",
- "etched",
- "ethics",
- "excess",
- "exhale",
- "exit",
- "exotic",
- "extra",
- "exult",
- "fading",
- "faked",
- "fall",
- "family",
- "fancy",
- "fatal",
- "faulty",
- "fawns",
- "faxed",
- "fazed",
- "feast",
- "feel",
- "feline",
- "fences",
- "ferry",
- "fever",
- "fewest",
- "fiat",
- "fibula",
- "fidget",
- "fierce",
- "fight",
- "films",
- "firm",
- "five",
- "fixate",
- "fizzle",
- "fleet",
- "flying",
- "foamy",
- "focus",
- "foes",
- "foggy",
- "foiled",
- "fonts",
- "fossil",
- "fowls",
- "foxes",
- "foyer",
- "framed",
- "frown",
- "fruit",
- "frying",
- "fudge",
- "fuel",
- "fully",
- "fuming",
- "fungal",
- "future",
- "fuzzy",
- "gables",
- "gadget",
- "gags",
- "gained",
- "galaxy",
- "gambit",
- "gang",
- "gasp",
- "gather",
- "gauze",
- "gave",
- "gawk",
- "gaze",
- "gecko",
- "geek",
- "gels",
- "germs",
- "geyser",
- "ghetto",
- "ghost",
- "giant",
- "giddy",
- "gifts",
- "gills",
- "ginger",
- "girth",
- "giving",
- "glass",
- "glide",
- "gnaw",
- "gnome",
- "goat",
- "goblet",
- "goes",
- "going",
- "gone",
- "gopher",
- "gossip",
- "gotten",
- "gown",
- "grunt",
- "guest",
- "guide",
- "gulp",
- "guru",
- "gusts",
- "gutter",
- "guys",
- "gypsy",
- "gyrate",
- "hairy",
- "having",
- "hawk",
- "hazard",
- "heels",
- "hefty",
- "height",
- "hence",
- "heron",
- "hiding",
- "hijack",
- "hiker",
- "hills",
- "hinder",
- "hippo",
- "hire",
- "hive",
- "hoax",
- "hobby",
- "hockey",
- "hold",
- "honked",
- "hookup",
- "hope",
- "hornet",
- "hotel",
- "hover",
- "howls",
- "huddle",
- "huge",
- "hull",
- "humid",
- "hunter",
- "huts",
- "hybrid",
- "hyper",
- "icing",
- "icon",
- "idiom",
- "idled",
- "idols",
- "igloo",
- "ignore",
- "iguana",
- "impel",
- "incur",
- "injury",
- "inline",
- "inmate",
- "input",
- "insult",
- "invoke",
- "ionic",
- "irate",
- "iris",
- "irony",
- "island",
- "issued",
- "itches",
- "items",
- "itself",
- "ivory",
- "jabbed",
- "jaded",
- "jagged",
- "jailed",
- "jargon",
- "jaunt",
- "jaws",
- "jazz",
- "jeans",
- "jeers",
- "jester",
- "jewels",
- "jigsaw",
- "jingle",
- "jive",
- "jobs",
- "jockey",
- "jogger",
- "joking",
- "jolted",
- "jostle",
- "joyous",
- "judge",
- "juicy",
- "july",
- "jump",
- "junk",
- "jury",
- "karate",
- "keep",
- "kennel",
- "kept",
- "kettle",
- "king",
- "kiosk",
- "kisses",
- "kiwi",
- "knee",
- "knife",
- "koala",
- "ladder",
- "lagoon",
- "lair",
- "lakes",
- "lamb",
- "laptop",
- "large",
- "last",
- "later",
- "lava",
- "layout",
- "lazy",
- "ledge",
- "leech",
- "left",
- "legion",
- "lemon",
- "lesson",
- "liar",
- "licks",
- "lids",
- "lied",
- "light",
- "lilac",
- "limits",
- "linen",
- "lion",
- "liquid",
- "listen",
- "lively",
- "loaded",
- "locker",
- "lodge",
- "lofty",
- "logic",
- "long",
- "lopped",
- "losing",
- "loudly",
- "love",
- "lower",
- "loyal",
- "lucky",
- "lumber",
- "lunar",
- "lurk",
- "lush",
- "luxury",
- "lymph",
- "lynx",
- "lyrics",
- "macro",
- "mailed",
- "major",
- "makeup",
- "malady",
- "mammal",
- "maps",
- "match",
- "maul",
- "mayor",
- "maze",
- "meant",
- "memoir",
- "menu",
- "merger",
- "mesh",
- "metro",
- "mews",
- "mice",
- "midst",
- "mighty",
- "mime",
- "mirror",
- "misery",
- "moat",
- "mobile",
- "mocked",
- "mohawk",
- "molten",
- "moment",
- "money",
- "moon",
- "mops",
- "morsel",
- "mostly",
- "mouth",
- "mowing",
- "much",
- "muddy",
- "muffin",
- "mugged",
- "mullet",
- "mumble",
- "muppet",
- "mural",
- "muzzle",
- "myriad",
- "myth",
- "nagged",
- "nail",
- "names",
- "nanny",
- "napkin",
- "nasty",
- "navy",
- "nearby",
- "needed",
- "neon",
- "nephew",
- "nerves",
- "nestle",
- "never",
- "newt",
- "nexus",
- "nibs",
- "niche",
- "niece",
- "nifty",
- "nimbly",
- "nobody",
- "nodes",
- "noises",
- "nomad",
- "noted",
- "nouns",
- "nozzle",
- "nuance",
- "nudged",
- "nugget",
- "null",
- "number",
- "nuns",
- "nurse",
- "nylon",
- "oaks",
- "oars",
- "oasis",
- "object",
- "occur",
- "ocean",
- "odds",
- "offend",
- "often",
- "okay",
- "older",
- "olive",
- "omega",
- "onion",
- "online",
- "onto",
- "onward",
- "oozed",
- "opened",
- "opus",
- "orange",
- "orbit",
- "orchid",
- "orders",
- "organs",
- "origin",
- "oscar",
- "otter",
- "ouch",
- "ought",
- "ounce",
- "oust",
- "oval",
- "oven",
- "owed",
- "owls",
- "owner",
- "oxygen",
- "oyster",
- "ozone",
- "pact",
- "pager",
- "palace",
- "paper",
- "pastry",
- "patio",
- "pause",
- "peeled",
- "pegs",
- "pencil",
- "people",
- "pepper",
- "pests",
- "petals",
- "phase",
- "phone",
- "piano",
- "picked",
- "pierce",
- "pimple",
- "pirate",
- "pivot",
- "pixels",
- "pizza",
- "pledge",
- "pliers",
- "plus",
- "poetry",
- "point",
- "poker",
- "polar",
- "ponies",
- "pool",
- "potato",
- "pouch",
- "powder",
- "pram",
- "pride",
- "pruned",
- "prying",
- "public",
- "puck",
- "puddle",
- "puffin",
- "pulp",
- "punch",
- "puppy",
- "purged",
- "push",
- "putty",
- "pylons",
- "python",
- "queen",
- "quick",
- "quote",
- "radar",
- "rafts",
- "rage",
- "raking",
- "rally",
- "ramped",
- "rapid",
- "rarest",
- "rash",
- "rated",
- "ravine",
- "rays",
- "razor",
- "react",
- "rebel",
- "recipe",
- "reduce",
- "reef",
- "refer",
- "reheat",
- "relic",
- "remedy",
- "repent",
- "reruns",
- "rest",
- "return",
- "revamp",
- "rewind",
- "rhino",
- "rhythm",
- "ribbon",
- "richly",
- "ridges",
- "rift",
- "rigid",
- "rims",
- "riots",
- "ripped",
- "rising",
- "ritual",
- "river",
- "roared",
- "robot",
- "rodent",
- "rogue",
- "roles",
- "roomy",
- "roped",
- "roster",
- "rotate",
- "rover",
- "royal",
- "ruby",
- "rudely",
- "rugged",
- "ruined",
- "ruling",
- "rumble",
- "runway",
- "rural",
- "sack",
- "safety",
- "saga",
- "sailor",
- "sake",
- "salads",
- "sample",
- "sanity",
- "sash",
- "satin",
- "saved",
- "scenic",
- "school",
- "scoop",
- "scrub",
- "scuba",
- "second",
- "sedan",
- "seeded",
- "setup",
- "sewage",
- "sieve",
- "silk",
- "sipped",
- "siren",
- "sizes",
- "skater",
- "skew",
- "skulls",
- "slid",
- "slower",
- "slug",
- "smash",
- "smog",
- "snake",
- "sneeze",
- "sniff",
- "snout",
- "snug",
- "soapy",
- "sober",
- "soccer",
- "soda",
- "soggy",
- "soil",
- "solved",
- "sonic",
- "soothe",
- "sorry",
- "sowed",
- "soya",
- "space",
- "speedy",
- "sphere",
- "spout",
- "sprig",
- "spud",
- "spying",
- "square",
- "stick",
- "subtly",
- "suede",
- "sugar",
- "summon",
- "sunken",
- "surfer",
- "sushi",
- "suture",
- "swept",
- "sword",
- "swung",
- "system",
- "taboo",
- "tacit",
- "tagged",
- "tail",
- "taken",
- "talent",
- "tamper",
- "tanks",
- "tasked",
- "tattoo",
- "taunts",
- "tavern",
- "tawny",
- "taxi",
- "tell",
- "tender",
- "tepid",
- "tether",
- "thaw",
- "thorn",
- "thumbs",
- "thwart",
- "ticket",
- "tidy",
- "tiers",
- "tiger",
- "tilt",
- "timber",
- "tinted",
- "tipsy",
- "tirade",
- "tissue",
- "titans",
- "today",
- "toffee",
- "toilet",
- "token",
- "tonic",
- "topic",
- "torch",
- "tossed",
- "total",
- "touchy",
- "towel",
- "toxic",
- "toyed",
- "trash",
- "trendy",
- "tribal",
- "truth",
- "trying",
- "tubes",
- "tucks",
- "tudor",
- "tufts",
- "tugs",
- "tulips",
- "tunnel",
- "turnip",
- "tusks",
- "tutor",
- "tuxedo",
- "twang",
- "twice",
- "tycoon",
- "typist",
- "tyrant",
- "ugly",
- "ulcers",
- "umpire",
- "uncle",
- "under",
- "uneven",
- "unfit",
- "union",
- "unmask",
- "unrest",
- "unsafe",
- "until",
- "unveil",
- "unwind",
- "unzip",
- "upbeat",
- "update",
- "uphill",
- "upkeep",
- "upload",
- "upon",
- "upper",
- "urban",
- "urgent",
- "usage",
- "useful",
- "usher",
- "using",
- "usual",
- "utmost",
- "utopia",
- "vague",
- "vain",
- "value",
- "vane",
- "vary",
- "vats",
- "vaults",
- "vector",
- "veered",
- "vegan",
- "vein",
- "velvet",
- "vessel",
- "vexed",
- "vials",
- "victim",
- "video",
- "viking",
- "violin",
- "vipers",
- "vitals",
- "vivid",
- "vixen",
- "vocal",
- "vogue",
- "voice",
- "vortex",
- "voted",
- "vowels",
- "voyage",
- "wade",
- "waffle",
- "waist",
- "waking",
- "wanted",
- "warped",
- "water",
- "waxing",
- "wedge",
- "weird",
- "went",
- "wept",
- "were",
- "whale",
- "when",
- "whole",
- "width",
- "wield",
- "wife",
- "wiggle",
- "wildly",
- "winter",
- "wiring",
- "wise",
- "wives",
- "wizard",
- "wobbly",
- "woes",
- "woken",
- "wolf",
- "woozy",
- "worry",
- "woven",
- "wrap",
- "wrist",
- "wrong",
- "yacht",
- "yahoo",
- "yanks",
- ]
- // seedToChecksumWords will compute the two checksum words for the provided
- // seed. The two return values are the two checksum words.
- var seedToChecksumWords = function (seed) {
- // Input validation.
- if (seed.length !== SEED_BYTES) {
- return [null, null, new Error(`seed has the wrong length: ${seed.length}`)]
- }
- // Get the hash.
- let h = sha512(seed)
- // Turn the hash into two words.
- let word1 = h[0] << 8
- word1 += h[1]
- word1 >>= 6
- let word2 = h[1] << 10
- word2 &= 0xffff
- word2 += h[2] << 2
- word2 >>= 6
- return [dictionary[word1], dictionary[word2], null]
- }
- // validSeedPhrase checks whether the provided seed phrase is valid, returning
- // an error if not. If the seed phrase is valid, the full seed will be returned
- // as a Uint8Array.
- var validSeedPhrase = function (seedPhrase) {
- // Create a helper function to make the below code more readable.
- let prefix = function (s) {
- return s.slice(0, DICTIONARY_UNIQUE_PREFIX)
- }
- // Pull the seed into its respective parts.
- let seedWordsAndChecksum = seedPhrase.split(" ")
- let seedWords = seedWordsAndChecksum.slice(0, SEED_ENTROPY_WORDS)
- let checksumOne = seedWordsAndChecksum[SEED_ENTROPY_WORDS]
- let checksumTwo = seedWordsAndChecksum[SEED_ENTROPY_WORDS + 1]
- // Convert the seedWords to a seed.
- let [seed, err1] = seedWordsToSeed(seedWords)
- if (err1 !== null) {
- return [null, addContextToErr(err1, "unable to parse seed phrase")]
- }
- let [checksumOneVerify, checksumTwoVerify, err2] = seedToChecksumWords(seed)
- if (err2 !== null) {
- return [null, addContextToErr(err2, "could not compute checksum words")]
- }
- if (prefix(checksumOne) !== prefix(checksumOneVerify)) {
- return [null, new Error("first checksum word is invalid")]
- }
- if (prefix(checksumTwo) !== prefix(checksumTwoVerify)) {
- return [null, new Error("second checksum word is invalid")]
- }
- return [seed, null]
- }
- // seedWordsToSeed will convert a provided seed phrase to to a Uint8Array that
- // represents the cryptographic seed in bytes.
- var seedWordsToSeed = function (seedWords) {
- // Input checking.
- if (seedWords.length !== SEED_ENTROPY_WORDS) {
- return [
- null,
- new Error(`Seed words should have length ${SEED_ENTROPY_WORDS} but has length ${seedWords.length}`),
- ]
- }
- // We are getting 16 bytes of entropy.
- const bytes = new Uint8Array(SEED_BYTES)
- let curByte = 0
- let curBit = 0
- for (let i = 0; i < SEED_ENTROPY_WORDS; i++) {
- // Determine which number corresponds to the next word.
- let word = -1
- for (let j = 0; j < dictionary.length; j++) {
- if (seedWords[i].slice(0, DICTIONARY_UNIQUE_PREFIX) === dictionary[j].slice(0, DICTIONARY_UNIQUE_PREFIX)) {
- word = j
- break
- }
- }
- if (word === -1) {
- return [null, new Error(`word '${seedWords[i]}' at index ${i} not found in dictionary`)]
- }
- let wordBits = 10
- if (i === SEED_ENTROPY_WORDS - 1) {
- wordBits = 8
- }
- // Iterate over the bits of the 10- or 8-bit word.
- for (let j = 0; j < wordBits; j++) {
- const bitSet = (word & (1 << (wordBits - j - 1))) > 0
- if (bitSet) {
- bytes[curByte] |= 1 << (8 - curBit - 1)
- }
- curBit += 1
- if (curBit >= 8) {
- // Current byte has 8 bits, go to the next byte.
- curByte += 1
- curBit = 0
- }
- }
- }
- return [bytes, null]
- }
- // setErrorText sets the errorText item in the DOM. This function is mainly
- // used for readability.
- var setErrorText = function (t) {
- document.getElementById("errorText").textContent = t
- }
- // generateSeedPhrase will generate and verify a seed phrase for the user.
- var generateSeedPhrase = function () {
- // Get the random numbers for the seed phrase. Typically, you need to
- // have code that avoids bias by checking the random results and
- // re-rolling the random numbers if the result is outside of the range
- // of numbers that would produce no bias. Because the search space
- // (1024) evenly divides the random number space (2^16), we can skip
- // this step and just use a modulus instead. The result will have no
- // bias, but only because the search space is a power of 2.
- let randNums = new Uint16Array(SEED_ENTROPY_WORDS)
- crypto.getRandomValues(randNums)
- // Consistency check to verify the above statement.
- if (dictionary.length !== 1024) {
- setErrorText("ERROR: the dictionary is the wrong length!")
- return
- }
- // Generate the seed phrase from the randNums.
- let seedWords = []
- for (let i = 0; i < SEED_ENTROPY_WORDS; i++) {
- let wordIndex = randNums[i] % dictionary.length
- if (i === 12) {
- wordIndex = randNums[i] % (dictionary.length / 4)
- }
- seedWords.push(dictionary[wordIndex])
- }
- // Convert the seedWords to a seed.
- let [seed, err1] = seedWordsToSeed(seedWords)
- if (err1 !== null) {
- setErrorText("ERROR: Unable to parse generated seed: " + err1)
- return
- }
- // Compute the checksum.
- let [checksumOne, checksumTwo, err2] = seedToChecksumWords(seed)
- if (err2 !== null) {
- setErrorText("ERROR: Unable to compute checksum: " + err2)
- return
- }
- // Assemble the final seed phrase and set the text field.
- let allWords = [...seedWords, checksumOne, checksumTwo]
- let seedPhrase = allWords.join(" ")
- document.getElementById("seedText").textContent = seedPhrase
- return
- }
- function bufToHex(buf) {
- return [...buf].map((x) => x.toString(16).padStart(2, "0")).join("")
- }
+
+ const crypto_sign_BYTES = 64, crypto_sign_PUBLICKEYBYTES = 32, crypto_sign_SECRETKEYBYTES = 64, crypto_sign_SEEDBYTES = 32;
+ const nu8 = new Uint8Array(0);
+ const nkp = { publicKey: nu8, secretKey: nu8 };
+ const SHA512_HASH_SIZE = 64;
+ const K = [
+ 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f,
+ 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
+ 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242,
+ 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
+ 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235,
+ 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
+ 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275,
+ 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
+ 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f,
+ 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
+ 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc,
+ 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
+ 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6,
+ 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
+ 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218,
+ 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
+ 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99,
+ 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
+ 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc,
+ 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
+ 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915,
+ 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
+ 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba,
+ 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
+ 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc,
+ 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
+ 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
+ ];
+ function ed25519KeypairFromEntropy(seed) {
+ // Input checking.
+ const errU8 = checkAllUint8Array(seed);
+ if (errU8 !== null) {
+ return [nkp, addContextToErr(errU8, "seed is invalid")];
+ }
+ if (seed.length !== crypto_sign_SEEDBYTES) {
+ return [nkp, "bad seed size"];
+ }
+ // Build the keypair.
+ const pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
+ const sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
+ for (let i = 0; i < 32; i++) {
+ sk[i] = seed[i];
+ }
+ crypto_sign_keypair(pk, sk);
+ return [
+ {
+ publicKey: pk,
+ secretKey: sk,
+ },
+ null,
+ ];
+ }
+ function checkAllUint8Array(...args) {
+ for (let i = 0; i < args.length; i++) {
+ if (!(args[i] instanceof Uint8Array)) {
+ return "unexpected type, use Uint8Array";
+ }
+ }
+ return null;
+ }
+ function addContextToErr(err, context) {
+ if (err === null || err === undefined) {
+ err = "[no error provided]";
+ }
+ return objAsString(context) + ": " + objAsString(err);
+ }
+ function objAsString(obj) {
+ // Check for undefined input.
+ if (obj === undefined) {
+ return "[cannot convert undefined to string]";
+ }
+ if (obj === null) {
+ return "[cannot convert null to string]";
+ }
+ // Parse the error into a string.
+ if (typeof obj === "string") {
+ return obj;
+ }
+ // Check if the object is an error, and return the message of the error if
+ // so.
+ if (obj instanceof Error) {
+ return obj.message;
+ }
+ // Check if the object has a 'toString' method defined on it. To ensure
+ // that we don't crash or throw, check that the toString is a function, and
+ // also that the return value of toString is a string.
+ if (Object.prototype.hasOwnProperty.call(obj, "toString")) {
+ if (typeof obj.toString === "function") {
+ const str = obj.toString();
+ if (typeof str === "string") {
+ return str;
+ }
+ }
+ }
+ // If the object does not have a custom toString, attempt to perform a
+ // JSON.stringify. We use a lot of bigints in libskynet, and calling
+ // JSON.stringify on an object with a bigint will cause a throw, so we add
+ // some custom handling to allow bigint objects to still be encoded.
+ try {
+ return JSON.stringify(obj, (_, v) => {
+ if (typeof v === "bigint") {
+ return v.toString();
+ }
+ return v;
+ });
+ }
+ catch (err) {
+ if (err !== undefined && typeof err.message === "string") {
+ return `[stringify failed]: ${err.message}`;
+ }
+ return "[stringify failed]";
+ }
+ }
+
+ function crypto_sign_keypair(pk, sk) {
+ const d = new Uint8Array(64);
+ const p = [gf(), gf(), gf(), gf()];
+ let i;
+ sha512internal(d, sk, 32);
+ d[0] &= 248;
+ d[31] &= 127;
+ d[31] |= 64;
+ scalarbase(p, d);
+ pack(pk, p);
+ for (i = 0; i < 32; i++)
+ sk[i + 32] = pk[i];
+ return 0;
+ }
+ const gf = function () {
+ const r = new Float64Array(16);
+ return r;
+ };
+ const sha512internal = function (out, m, n) {
+ const hh = new Int32Array(8), hl = new Int32Array(8), x = new Uint8Array(256), b = n;
+ let i;
+ hh[0] = 0x6a09e667;
+ hh[1] = 0xbb67ae85;
+ hh[2] = 0x3c6ef372;
+ hh[3] = 0xa54ff53a;
+ hh[4] = 0x510e527f;
+ hh[5] = 0x9b05688c;
+ hh[6] = 0x1f83d9ab;
+ hh[7] = 0x5be0cd19;
+ hl[0] = 0xf3bcc908;
+ hl[1] = 0x84caa73b;
+ hl[2] = 0xfe94f82b;
+ hl[3] = 0x5f1d36f1;
+ hl[4] = 0xade682d1;
+ hl[5] = 0x2b3e6c1f;
+ hl[6] = 0xfb41bd6b;
+ hl[7] = 0x137e2179;
+ crypto_hashblocks_hl(hh, hl, m, n);
+ n %= 128;
+ for (i = 0; i < n; i++)
+ x[i] = m[b - n + i];
+ x[n] = 128;
+ n = 256 - 128 * (n < 112 ? 1 : 0);
+ x[n - 9] = 0;
+ ts64(x, n - 8, (b / 0x20000000) | 0, b << 3);
+ crypto_hashblocks_hl(hh, hl, x, n);
+ for (i = 0; i < 8; i++)
+ ts64(out, 8 * i, hh[i], hl[i]);
+ return 0;
+ };
+ function crypto_hashblocks_hl(hh, hl, m, n) {
+ const wh = new Int32Array(16), wl = new Int32Array(16);
+ let bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, th, tl, i, j, h, l, a, b, c, d;
+ let ah0 = hh[0], ah1 = hh[1], ah2 = hh[2], ah3 = hh[3], ah4 = hh[4], ah5 = hh[5], ah6 = hh[6], ah7 = hh[7], al0 = hl[0], al1 = hl[1], al2 = hl[2], al3 = hl[3], al4 = hl[4], al5 = hl[5], al6 = hl[6], al7 = hl[7];
+ let pos = 0;
+ while (n >= 128) {
+ for (i = 0; i < 16; i++) {
+ j = 8 * i + pos;
+ wh[i] = (m[j + 0] << 24) | (m[j + 1] << 16) | (m[j + 2] << 8) | m[j + 3];
+ wl[i] = (m[j + 4] << 24) | (m[j + 5] << 16) | (m[j + 6] << 8) | m[j + 7];
+ }
+ for (i = 0; i < 80; i++) {
+ bh0 = ah0;
+ bh1 = ah1;
+ bh2 = ah2;
+ bh3 = ah3;
+ bh4 = ah4;
+ bh5 = ah5;
+ bh6 = ah6;
+ bh7 = ah7;
+ bl0 = al0;
+ bl1 = al1;
+ bl2 = al2;
+ bl3 = al3;
+ bl4 = al4;
+ bl5 = al5;
+ bl6 = al6;
+ bl7 = al7;
+ // add
+ h = ah7;
+ l = al7;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ // Sigma1
+ h =
+ ((ah4 >>> 14) | (al4 << (32 - 14))) ^
+ ((ah4 >>> 18) | (al4 << (32 - 18))) ^
+ ((al4 >>> (41 - 32)) | (ah4 << (32 - (41 - 32))));
+ l =
+ ((al4 >>> 14) | (ah4 << (32 - 14))) ^
+ ((al4 >>> 18) | (ah4 << (32 - 18))) ^
+ ((ah4 >>> (41 - 32)) | (al4 << (32 - (41 - 32))));
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // Ch
+ h = (ah4 & ah5) ^ (~ah4 & ah6);
+ l = (al4 & al5) ^ (~al4 & al6);
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // K
+ h = K[i * 2];
+ l = K[i * 2 + 1];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // w
+ h = wh[i % 16];
+ l = wl[i % 16];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ th = (c & 0xffff) | (d << 16);
+ tl = (a & 0xffff) | (b << 16);
+ // add
+ h = th;
+ l = tl;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ // Sigma0
+ h =
+ ((ah0 >>> 28) | (al0 << (32 - 28))) ^
+ ((al0 >>> (34 - 32)) | (ah0 << (32 - (34 - 32)))) ^
+ ((al0 >>> (39 - 32)) | (ah0 << (32 - (39 - 32))));
+ l =
+ ((al0 >>> 28) | (ah0 << (32 - 28))) ^
+ ((ah0 >>> (34 - 32)) | (al0 << (32 - (34 - 32)))) ^
+ ((ah0 >>> (39 - 32)) | (al0 << (32 - (39 - 32))));
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // Maj
+ h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);
+ l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ bh7 = (c & 0xffff) | (d << 16);
+ bl7 = (a & 0xffff) | (b << 16);
+ // add
+ h = bh3;
+ l = bl3;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = th;
+ l = tl;
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ bh3 = (c & 0xffff) | (d << 16);
+ bl3 = (a & 0xffff) | (b << 16);
+ ah1 = bh0;
+ ah2 = bh1;
+ ah3 = bh2;
+ ah4 = bh3;
+ ah5 = bh4;
+ ah6 = bh5;
+ ah7 = bh6;
+ ah0 = bh7;
+ al1 = bl0;
+ al2 = bl1;
+ al3 = bl2;
+ al4 = bl3;
+ al5 = bl4;
+ al6 = bl5;
+ al7 = bl6;
+ al0 = bl7;
+ if (i % 16 === 15) {
+ for (j = 0; j < 16; j++) {
+ // add
+ h = wh[j];
+ l = wl[j];
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = wh[(j + 9) % 16];
+ l = wl[(j + 9) % 16];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // sigma0
+ th = wh[(j + 1) % 16];
+ tl = wl[(j + 1) % 16];
+ h =
+ ((th >>> 1) | (tl << (32 - 1))) ^
+ ((th >>> 8) | (tl << (32 - 8))) ^
+ (th >>> 7);
+ l =
+ ((tl >>> 1) | (th << (32 - 1))) ^
+ ((tl >>> 8) | (th << (32 - 8))) ^
+ ((tl >>> 7) | (th << (32 - 7)));
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ // sigma1
+ th = wh[(j + 14) % 16];
+ tl = wl[(j + 14) % 16];
+ h =
+ ((th >>> 19) | (tl << (32 - 19))) ^
+ ((tl >>> (61 - 32)) | (th << (32 - (61 - 32)))) ^
+ (th >>> 6);
+ l =
+ ((tl >>> 19) | (th << (32 - 19))) ^
+ ((th >>> (61 - 32)) | (tl << (32 - (61 - 32)))) ^
+ ((tl >>> 6) | (th << (32 - 6)));
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ wh[j] = (c & 0xffff) | (d << 16);
+ wl[j] = (a & 0xffff) | (b << 16);
+ }
+ }
+ }
+ // add
+ h = ah0;
+ l = al0;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[0];
+ l = hl[0];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[0] = ah0 = (c & 0xffff) | (d << 16);
+ hl[0] = al0 = (a & 0xffff) | (b << 16);
+ h = ah1;
+ l = al1;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[1];
+ l = hl[1];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[1] = ah1 = (c & 0xffff) | (d << 16);
+ hl[1] = al1 = (a & 0xffff) | (b << 16);
+ h = ah2;
+ l = al2;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[2];
+ l = hl[2];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[2] = ah2 = (c & 0xffff) | (d << 16);
+ hl[2] = al2 = (a & 0xffff) | (b << 16);
+ h = ah3;
+ l = al3;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[3];
+ l = hl[3];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[3] = ah3 = (c & 0xffff) | (d << 16);
+ hl[3] = al3 = (a & 0xffff) | (b << 16);
+ h = ah4;
+ l = al4;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[4];
+ l = hl[4];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[4] = ah4 = (c & 0xffff) | (d << 16);
+ hl[4] = al4 = (a & 0xffff) | (b << 16);
+ h = ah5;
+ l = al5;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[5];
+ l = hl[5];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[5] = ah5 = (c & 0xffff) | (d << 16);
+ hl[5] = al5 = (a & 0xffff) | (b << 16);
+ h = ah6;
+ l = al6;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[6];
+ l = hl[6];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[6] = ah6 = (c & 0xffff) | (d << 16);
+ hl[6] = al6 = (a & 0xffff) | (b << 16);
+ h = ah7;
+ l = al7;
+ a = l & 0xffff;
+ b = l >>> 16;
+ c = h & 0xffff;
+ d = h >>> 16;
+ h = hh[7];
+ l = hl[7];
+ a += l & 0xffff;
+ b += l >>> 16;
+ c += h & 0xffff;
+ d += h >>> 16;
+ b += a >>> 16;
+ c += b >>> 16;
+ d += c >>> 16;
+ hh[7] = ah7 = (c & 0xffff) | (d << 16);
+ hl[7] = al7 = (a & 0xffff) | (b << 16);
+ pos += 128;
+ n -= 128;
+ }
+ return n;
+ }
+
+
+ const gfi = function (init) {
+ let i;
+ const r = new Float64Array(16);
+ if (init)
+ for (i = 0; i < init.length; i++)
+ r[i] = init[i];
+ return r;
+ };
+
+ const gf0 = gf(), gf1 = gfi([1]), D = gfi([
+ 0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f,
+ 0x6cee, 0x5203,
+ ]), D2 = gfi([
+ 0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df,
+ 0xd9dc, 0x2406,
+ ]), X = gfi([
+ 0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e,
+ 0x36d3, 0x2169,
+ ]), Y = gfi([
+ 0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666,
+ 0x6666, 0x6666,
+ ]), I = gfi([
+ 0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1,
+ 0x2480, 0x2b83,
+ ]);
+ function A(o, a, b) {
+ for (let i = 0; i < 16; i++)
+ o[i] = a[i] + b[i];
+ }
+ function Z(o, a, b) {
+ for (let i = 0; i < 16; i++)
+ o[i] = a[i] - b[i];
+ }
+ function M(o, a, b) {
+ let v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0;
+ const b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
+ v = a[0];
+ t0 += v * b0;
+ t1 += v * b1;
+ t2 += v * b2;
+ t3 += v * b3;
+ t4 += v * b4;
+ t5 += v * b5;
+ t6 += v * b6;
+ t7 += v * b7;
+ t8 += v * b8;
+ t9 += v * b9;
+ t10 += v * b10;
+ t11 += v * b11;
+ t12 += v * b12;
+ t13 += v * b13;
+ t14 += v * b14;
+ t15 += v * b15;
+ v = a[1];
+ t1 += v * b0;
+ t2 += v * b1;
+ t3 += v * b2;
+ t4 += v * b3;
+ t5 += v * b4;
+ t6 += v * b5;
+ t7 += v * b6;
+ t8 += v * b7;
+ t9 += v * b8;
+ t10 += v * b9;
+ t11 += v * b10;
+ t12 += v * b11;
+ t13 += v * b12;
+ t14 += v * b13;
+ t15 += v * b14;
+ t16 += v * b15;
+ v = a[2];
+ t2 += v * b0;
+ t3 += v * b1;
+ t4 += v * b2;
+ t5 += v * b3;
+ t6 += v * b4;
+ t7 += v * b5;
+ t8 += v * b6;
+ t9 += v * b7;
+ t10 += v * b8;
+ t11 += v * b9;
+ t12 += v * b10;
+ t13 += v * b11;
+ t14 += v * b12;
+ t15 += v * b13;
+ t16 += v * b14;
+ t17 += v * b15;
+ v = a[3];
+ t3 += v * b0;
+ t4 += v * b1;
+ t5 += v * b2;
+ t6 += v * b3;
+ t7 += v * b4;
+ t8 += v * b5;
+ t9 += v * b6;
+ t10 += v * b7;
+ t11 += v * b8;
+ t12 += v * b9;
+ t13 += v * b10;
+ t14 += v * b11;
+ t15 += v * b12;
+ t16 += v * b13;
+ t17 += v * b14;
+ t18 += v * b15;
+ v = a[4];
+ t4 += v * b0;
+ t5 += v * b1;
+ t6 += v * b2;
+ t7 += v * b3;
+ t8 += v * b4;
+ t9 += v * b5;
+ t10 += v * b6;
+ t11 += v * b7;
+ t12 += v * b8;
+ t13 += v * b9;
+ t14 += v * b10;
+ t15 += v * b11;
+ t16 += v * b12;
+ t17 += v * b13;
+ t18 += v * b14;
+ t19 += v * b15;
+ v = a[5];
+ t5 += v * b0;
+ t6 += v * b1;
+ t7 += v * b2;
+ t8 += v * b3;
+ t9 += v * b4;
+ t10 += v * b5;
+ t11 += v * b6;
+ t12 += v * b7;
+ t13 += v * b8;
+ t14 += v * b9;
+ t15 += v * b10;
+ t16 += v * b11;
+ t17 += v * b12;
+ t18 += v * b13;
+ t19 += v * b14;
+ t20 += v * b15;
+ v = a[6];
+ t6 += v * b0;
+ t7 += v * b1;
+ t8 += v * b2;
+ t9 += v * b3;
+ t10 += v * b4;
+ t11 += v * b5;
+ t12 += v * b6;
+ t13 += v * b7;
+ t14 += v * b8;
+ t15 += v * b9;
+ t16 += v * b10;
+ t17 += v * b11;
+ t18 += v * b12;
+ t19 += v * b13;
+ t20 += v * b14;
+ t21 += v * b15;
+ v = a[7];
+ t7 += v * b0;
+ t8 += v * b1;
+ t9 += v * b2;
+ t10 += v * b3;
+ t11 += v * b4;
+ t12 += v * b5;
+ t13 += v * b6;
+ t14 += v * b7;
+ t15 += v * b8;
+ t16 += v * b9;
+ t17 += v * b10;
+ t18 += v * b11;
+ t19 += v * b12;
+ t20 += v * b13;
+ t21 += v * b14;
+ t22 += v * b15;
+ v = a[8];
+ t8 += v * b0;
+ t9 += v * b1;
+ t10 += v * b2;
+ t11 += v * b3;
+ t12 += v * b4;
+ t13 += v * b5;
+ t14 += v * b6;
+ t15 += v * b7;
+ t16 += v * b8;
+ t17 += v * b9;
+ t18 += v * b10;
+ t19 += v * b11;
+ t20 += v * b12;
+ t21 += v * b13;
+ t22 += v * b14;
+ t23 += v * b15;
+ v = a[9];
+ t9 += v * b0;
+ t10 += v * b1;
+ t11 += v * b2;
+ t12 += v * b3;
+ t13 += v * b4;
+ t14 += v * b5;
+ t15 += v * b6;
+ t16 += v * b7;
+ t17 += v * b8;
+ t18 += v * b9;
+ t19 += v * b10;
+ t20 += v * b11;
+ t21 += v * b12;
+ t22 += v * b13;
+ t23 += v * b14;
+ t24 += v * b15;
+ v = a[10];
+ t10 += v * b0;
+ t11 += v * b1;
+ t12 += v * b2;
+ t13 += v * b3;
+ t14 += v * b4;
+ t15 += v * b5;
+ t16 += v * b6;
+ t17 += v * b7;
+ t18 += v * b8;
+ t19 += v * b9;
+ t20 += v * b10;
+ t21 += v * b11;
+ t22 += v * b12;
+ t23 += v * b13;
+ t24 += v * b14;
+ t25 += v * b15;
+ v = a[11];
+ t11 += v * b0;
+ t12 += v * b1;
+ t13 += v * b2;
+ t14 += v * b3;
+ t15 += v * b4;
+ t16 += v * b5;
+ t17 += v * b6;
+ t18 += v * b7;
+ t19 += v * b8;
+ t20 += v * b9;
+ t21 += v * b10;
+ t22 += v * b11;
+ t23 += v * b12;
+ t24 += v * b13;
+ t25 += v * b14;
+ t26 += v * b15;
+ v = a[12];
+ t12 += v * b0;
+ t13 += v * b1;
+ t14 += v * b2;
+ t15 += v * b3;
+ t16 += v * b4;
+ t17 += v * b5;
+ t18 += v * b6;
+ t19 += v * b7;
+ t20 += v * b8;
+ t21 += v * b9;
+ t22 += v * b10;
+ t23 += v * b11;
+ t24 += v * b12;
+ t25 += v * b13;
+ t26 += v * b14;
+ t27 += v * b15;
+ v = a[13];
+ t13 += v * b0;
+ t14 += v * b1;
+ t15 += v * b2;
+ t16 += v * b3;
+ t17 += v * b4;
+ t18 += v * b5;
+ t19 += v * b6;
+ t20 += v * b7;
+ t21 += v * b8;
+ t22 += v * b9;
+ t23 += v * b10;
+ t24 += v * b11;
+ t25 += v * b12;
+ t26 += v * b13;
+ t27 += v * b14;
+ t28 += v * b15;
+ v = a[14];
+ t14 += v * b0;
+ t15 += v * b1;
+ t16 += v * b2;
+ t17 += v * b3;
+ t18 += v * b4;
+ t19 += v * b5;
+ t20 += v * b6;
+ t21 += v * b7;
+ t22 += v * b8;
+ t23 += v * b9;
+ t24 += v * b10;
+ t25 += v * b11;
+ t26 += v * b12;
+ t27 += v * b13;
+ t28 += v * b14;
+ t29 += v * b15;
+ v = a[15];
+ t15 += v * b0;
+ t16 += v * b1;
+ t17 += v * b2;
+ t18 += v * b3;
+ t19 += v * b4;
+ t20 += v * b5;
+ t21 += v * b6;
+ t22 += v * b7;
+ t23 += v * b8;
+ t24 += v * b9;
+ t25 += v * b10;
+ t26 += v * b11;
+ t27 += v * b12;
+ t28 += v * b13;
+ t29 += v * b14;
+ t30 += v * b15;
+ t0 += 38 * t16;
+ t1 += 38 * t17;
+ t2 += 38 * t18;
+ t3 += 38 * t19;
+ t4 += 38 * t20;
+ t5 += 38 * t21;
+ t6 += 38 * t22;
+ t7 += 38 * t23;
+ t8 += 38 * t24;
+ t9 += 38 * t25;
+ t10 += 38 * t26;
+ t11 += 38 * t27;
+ t12 += 38 * t28;
+ t13 += 38 * t29;
+ t14 += 38 * t30;
+ // t15 left as is
+ // first car
+ c = 1;
+ v = t0 + c + 65535;
+ c = Math.floor(v / 65536);
+ t0 = v - c * 65536;
+ v = t1 + c + 65535;
+ c = Math.floor(v / 65536);
+ t1 = v - c * 65536;
+ v = t2 + c + 65535;
+ c = Math.floor(v / 65536);
+ t2 = v - c * 65536;
+ v = t3 + c + 65535;
+ c = Math.floor(v / 65536);
+ t3 = v - c * 65536;
+ v = t4 + c + 65535;
+ c = Math.floor(v / 65536);
+ t4 = v - c * 65536;
+ v = t5 + c + 65535;
+ c = Math.floor(v / 65536);
+ t5 = v - c * 65536;
+ v = t6 + c + 65535;
+ c = Math.floor(v / 65536);
+ t6 = v - c * 65536;
+ v = t7 + c + 65535;
+ c = Math.floor(v / 65536);
+ t7 = v - c * 65536;
+ v = t8 + c + 65535;
+ c = Math.floor(v / 65536);
+ t8 = v - c * 65536;
+ v = t9 + c + 65535;
+ c = Math.floor(v / 65536);
+ t9 = v - c * 65536;
+ v = t10 + c + 65535;
+ c = Math.floor(v / 65536);
+ t10 = v - c * 65536;
+ v = t11 + c + 65535;
+ c = Math.floor(v / 65536);
+ t11 = v - c * 65536;
+ v = t12 + c + 65535;
+ c = Math.floor(v / 65536);
+ t12 = v - c * 65536;
+ v = t13 + c + 65535;
+ c = Math.floor(v / 65536);
+ t13 = v - c * 65536;
+ v = t14 + c + 65535;
+ c = Math.floor(v / 65536);
+ t14 = v - c * 65536;
+ v = t15 + c + 65535;
+ c = Math.floor(v / 65536);
+ t15 = v - c * 65536;
+ t0 += c - 1 + 37 * (c - 1);
+ // second car
+ c = 1;
+ v = t0 + c + 65535;
+ c = Math.floor(v / 65536);
+ t0 = v - c * 65536;
+ v = t1 + c + 65535;
+ c = Math.floor(v / 65536);
+ t1 = v - c * 65536;
+ v = t2 + c + 65535;
+ c = Math.floor(v / 65536);
+ t2 = v - c * 65536;
+ v = t3 + c + 65535;
+ c = Math.floor(v / 65536);
+ t3 = v - c * 65536;
+ v = t4 + c + 65535;
+ c = Math.floor(v / 65536);
+ t4 = v - c * 65536;
+ v = t5 + c + 65535;
+ c = Math.floor(v / 65536);
+ t5 = v - c * 65536;
+ v = t6 + c + 65535;
+ c = Math.floor(v / 65536);
+ t6 = v - c * 65536;
+ v = t7 + c + 65535;
+ c = Math.floor(v / 65536);
+ t7 = v - c * 65536;
+ v = t8 + c + 65535;
+ c = Math.floor(v / 65536);
+ t8 = v - c * 65536;
+ v = t9 + c + 65535;
+ c = Math.floor(v / 65536);
+ t9 = v - c * 65536;
+ v = t10 + c + 65535;
+ c = Math.floor(v / 65536);
+ t10 = v - c * 65536;
+ v = t11 + c + 65535;
+ c = Math.floor(v / 65536);
+ t11 = v - c * 65536;
+ v = t12 + c + 65535;
+ c = Math.floor(v / 65536);
+ t12 = v - c * 65536;
+ v = t13 + c + 65535;
+ c = Math.floor(v / 65536);
+ t13 = v - c * 65536;
+ v = t14 + c + 65535;
+ c = Math.floor(v / 65536);
+ t14 = v - c * 65536;
+ v = t15 + c + 65535;
+ c = Math.floor(v / 65536);
+ t15 = v - c * 65536;
+ t0 += c - 1 + 37 * (c - 1);
+ o[0] = t0;
+ o[1] = t1;
+ o[2] = t2;
+ o[3] = t3;
+ o[4] = t4;
+ o[5] = t5;
+ o[6] = t6;
+ o[7] = t7;
+ o[8] = t8;
+ o[9] = t9;
+ o[10] = t10;
+ o[11] = t11;
+ o[12] = t12;
+ o[13] = t13;
+ o[14] = t14;
+ o[15] = t15;
+ }
+ function S(o, a) {
+ M(o, a, a);
+ }
+ function cswap(p, q, b) {
+ let i;
+ for (i = 0; i < 4; i++) {
+ sel25519(p[i], q[i], b);
+ }
+ }
+ function sel25519(p, q, b) {
+ let t;
+ const c = ~(b - 1);
+ for (let i = 0; i < 16; i++) {
+ t = c & (p[i] ^ q[i]);
+ p[i] ^= t;
+ q[i] ^= t;
+ }
+ }
+ function add(p, q) {
+ const a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
+ Z(a, p[1], p[0]);
+ Z(t, q[1], q[0]);
+ M(a, a, t);
+ A(b, p[0], p[1]);
+ A(t, q[0], q[1]);
+ M(b, b, t);
+ M(c, p[3], q[3]);
+ M(c, c, D2);
+ M(d, p[2], q[2]);
+ A(d, d, d);
+ Z(e, b, a);
+ Z(f, d, c);
+ A(g, d, c);
+ A(h, b, a);
+ M(p[0], e, f);
+ M(p[1], h, g);
+ M(p[2], g, f);
+ M(p[3], e, h);
+ }
+ function pack(r, p) {
+ const tx = gf(), ty = gf(), zi = gf();
+ inv25519(zi, p[2]);
+ M(tx, p[0], zi);
+ M(ty, p[1], zi);
+ pack25519(r, ty);
+ r[31] ^= par25519(tx) << 7;
+ }
+ function pack25519(o, n) {
+ let i, j, b;
+ const m = gf(), t = gf();
+ for (i = 0; i < 16; i++)
+ t[i] = n[i];
+ car25519(t);
+ car25519(t);
+ car25519(t);
+ for (j = 0; j < 2; j++) {
+ m[0] = t[0] - 0xffed;
+ for (i = 1; i < 15; i++) {
+ m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1);
+ m[i - 1] &= 0xffff;
+ }
+ m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1);
+ b = (m[15] >> 16) & 1;
+ m[14] &= 0xffff;
+ sel25519(t, m, 1 - b);
+ }
+ for (i = 0; i < 16; i++) {
+ o[2 * i] = t[i] & 0xff;
+ o[2 * i + 1] = t[i] >> 8;
+ }
+ }
+
+ function inv25519(o, i) {
+ const c = gf();
+ let a;
+ for (a = 0; a < 16; a++)
+ c[a] = i[a];
+ for (a = 253; a >= 0; a--) {
+ S(c, c);
+ if (a !== 2 && a !== 4)
+ M(c, c, i);
+ }
+ for (a = 0; a < 16; a++)
+ o[a] = c[a];
+ }
+ function pow2523(o, i) {
+ const c = gf();
+ let a;
+ for (a = 0; a < 16; a++)
+ c[a] = i[a];
+ for (a = 250; a >= 0; a--) {
+ S(c, c);
+ if (a !== 1)
+ M(c, c, i);
+ }
+ for (a = 0; a < 16; a++)
+ o[a] = c[a];
+ }
+ function car25519(o) {
+ let i, v, c = 1;
+ for (i = 0; i < 16; i++) {
+ v = o[i] + c + 65535;
+ c = Math.floor(v / 65536);
+ o[i] = v - c * 65536;
+ }
+ o[0] += c - 1 + 37 * (c - 1);
+ }
+ function par25519(a) {
+ const d = new Uint8Array(32);
+ pack25519(d, a);
+ return d[0] & 1;
+ }
+ function ts64(x, i, h, l) {
+ x[i] = (h >> 24) & 0xff;
+ x[i + 1] = (h >> 16) & 0xff;
+ x[i + 2] = (h >> 8) & 0xff;
+ x[i + 3] = h & 0xff;
+ x[i + 4] = (l >> 24) & 0xff;
+ x[i + 5] = (l >> 16) & 0xff;
+ x[i + 6] = (l >> 8) & 0xff;
+ x[i + 7] = l & 0xff;
+ }
+ function scalarbase(p, s) {
+ const q = [gf(), gf(), gf(), gf()];
+ set25519(q[0], X);
+ set25519(q[1], Y);
+ set25519(q[2], gf1);
+ M(q[3], X, Y);
+ scalarmult(p, q, s);
+ }
+ function set25519(r, a) {
+ let i;
+ for (i = 0; i < 16; i++)
+ r[i] = a[i] | 0;
+ }
+ function scalarmult(p, q, s) {
+ let b, i;
+ set25519(p[0], gf0);
+ set25519(p[1], gf1);
+ set25519(p[2], gf1);
+ set25519(p[3], gf0);
+ for (i = 255; i >= 0; --i) {
+ b = (s[(i / 8) | 0] >> (i & 7)) & 1;
+ cswap(p, q, b);
+ add(q, p);
+ add(p, p);
+ cswap(p, q, b);
+ }
+ }
+
+ function bufToHex(buf) {
+ return [...buf].map((x) => x.toString(16).padStart(2, "0")).join("");
+ }
// authUser is a function which will inspect the value of the input field to
// find the seed, and then will set the user's local seed to that value.
- var authUser = function () {
- // Check that the user has provided a seed.
- var userSeed = document.getElementById("seedInput")
- if (userSeed === null) {
- setErrorText("ERROR: user seed field not found")
- return
- }
- // Validate the seed.
- let [seed, errVSP] = validSeedPhrase(userSeed.value)
- if (errVSP !== null) {
- setErrorText("Seed is not valid: " + errVSP)
- return
- }
- // Take the seed and store it in localStorage.
- let seedStr = bufToHex(seed)
- window.localStorage.setItem("v1-seed", seedStr)
- // If there was a window opener, we should send a message to
- // the opener indicating that auth was successful, and then close
- // this window. Otherwise, we should just refresh the page.
- if (window.opener) {
- // Send a postmessage back to the caller that auth was successful. This
- // is one of the few places where a wildcard can be used by the
- // postMessage because we are comfortable declaring to all pages that
- // the user has logged into the kernel.
- try {
- window.opener.postMessage({ kernelMethod: "authCompleted" }, "*")
- window.close()
- } catch (errC) {
- setErrorText("Unable to report that authentication suceeded: " + errC)
- }
- } else {
- location.reload()
- }
- }
var logOut = function () {
// Log out by clearing localstorage.
window.localStorage.clear()
@@ -1692,34 +1132,33 @@
}
}
+ function generateAccount(){
+ const vals = new Uint8Array(crypto_sign_SEEDBYTES);
+ crypto.getRandomValues(vals)
+ const [kp] = ed25519KeypairFromEntropy(vals);
+ let keyStr = bufToHex(kp.secretKey);
+ window.localStorage.setItem("v1-key", keyStr)
+ if (window.opener) {
+ window.close()
+ } else {
+ location.reload()
+ }
+ }
+
// Check localStorage for the user seed.
- let userSeedStr = window.localStorage.getItem("v1-seed")
- if (userSeedStr === null) {
+ let userKeyStr = window.localStorage.getItem("v1-key")
+ if (userKeyStr === null) {
// Create the auth form and perform authentication.
var banner = document.createElement("h1")
banner.textContent = "Login to Lume Web"
- var seedInput = document.createElement("input")
- seedInput.type = "text"
- seedInput.placeholder = "Enter seed phrase here"
- seedInput.id = "seedInput"
- var submitButton = document.createElement("input")
- submitButton.type = "button"
- submitButton.value = "Submit"
- submitButton.onclick = authUser
- var errorText = document.createElement("p")
- errorText.id = "errorText"
- errorText.textContent = ""
var generateSeedButton = document.createElement("input")
generateSeedButton.type = "button"
- generateSeedButton.value = "Generate Seed"
- generateSeedButton.onclick = generateSeedPhrase
+ generateSeedButton.value = "Generate Account"
+ generateSeedButton.onclick = generateAccount
var seedText = document.createElement("p")
seedText.id = "seedText"
seedText.textContent = ""
document.body.appendChild(banner)
- document.body.appendChild(seedInput)
- document.body.appendChild(submitButton)
- document.body.appendChild(errorText)
document.body.appendChild(generateSeedButton)
document.body.appendChild(seedText)
} else {
diff --git a/assets/manifest.json b/assets/manifest.json
index 10f5876..2030838 100644
--- a/assets/manifest.json
+++ b/assets/manifest.json
@@ -2,7 +2,7 @@
"description": "Lume Web is your decentralized gateway into the web3 internet, the web owned and controlled by its users",
"manifest_version": 2,
"name": "Lume Web",
- "version": "0.3.0",
+ "version": "0.3.0.3",
"homepage_url": "https://lumeweb.com",
"icons": {
"48": "icon.png",
@@ -24,7 +24,7 @@
"content_scripts": [
{
"matches": [
- "http://kernel.skynet/"
+ "http://kernel.lume/"
],
"js": [
"bootloader.js"
diff --git a/build.js b/build.js
index 15e4e22..6a9f8fc 100644
--- a/build.js
+++ b/build.js
@@ -16,7 +16,7 @@ esbuild.buildSync({
esbuild.buildSync({
entryPoints: ["src/main/bootloader.ts"],
outfile: "dist/bootloader.js",
- format: "esm",
+ format: "iife",
bundle: true,
legalComments: "external",
// minify: true
@@ -27,14 +27,14 @@ esbuild.buildSync({
esbuild.buildSync({
entryPoints: ["src/main/bridge.ts"],
outfile: "dist/bridge.js",
- format: "esm",
+ format: "iife",
bundle: true,
legalComments: "external",
// minify: true
define: {
global: "self",
},
-});
+}); /*
esbuild.buildSync({
entryPoints: ["src/main/crypto.ts"],
outfile: "dist/crypto.js",
@@ -58,3 +58,4 @@ esbuild.buildSync({
global: "window",
}
});
+*/
diff --git a/package.json b/package.json
index 6e80a4b..8f985e1 100644
--- a/package.json
+++ b/package.json
@@ -15,45 +15,45 @@
"author": "David Vorick",
"license": "MIT",
"devDependencies": {
- "@lumeweb/kernel-dns-client": "https://github.com/LumeWeb/kernel-dns-client.git",
- "@lumeweb/webextension-polyfill": "https://github.com/LumeWeb/webextension-polyfill.git",
+ "@helia/unixfs": "^1.2.1",
"@rollup/plugin-node-resolve": "^13.3.0",
- "@types/ejs": "^3.1.1",
+ "@types/ejs": "^3.1.2",
"@types/read": "^0.0.29",
- "@types/webextension-polyfill": "^0.9.0",
- "@typescript-eslint/eslint-plugin": "^5.18.0",
+ "@types/webextension-polyfill": "^0.9.2",
+ "@typescript-eslint/eslint-plugin": "^5.57.0",
"browserify-fs": "^1.0.0",
- "cpy-cli": "^4.1.0",
- "esbuild": "^0.14.51",
- "eslint": "^8.13.0",
+ "cpy-cli": "^4.2.0",
+ "esbuild": "^0.14.54",
+ "eslint": "^8.37.0",
"events": "^3.3.0",
"path-browserify": "^1.0.1",
- "prettier": "^2.6.2",
+ "prettier": "^2.8.7",
"process": "^0.11.10",
"rimraf": "^3.0.2",
- "rollup": "^2.75.6",
+ "rollup": "^2.79.1",
"stream": "^0.0.2",
- "typescript": "^4.6.3",
- "util": "^0.12.4",
+ "typescript": "^4.9.5",
+ "util": "^0.12.5",
"webextension-polyfill": "^0.9.0"
},
"dependencies": {
- "@lumeweb/kernel-dht-client": "https://github.com/LumeWeb/kernel-dht-client.git",
- "@lumeweb/kernel-ipfs-client": "https://github.com/LumeWeb/kernel-ipfs-client.git",
- "@lumeweb/libresolver": "https://github.com/LumeWeb/libresolver.git",
- "@lumeweb/tld-enum": "https://github.com/LumeWeb/list-of-top-level-domains.git",
- "@peculiar/webcrypto": "^1.4.0",
- "dexie": "^3.2.2",
- "ejs": "^3.1.8",
+ "@lumeweb/kernel-dns-client": "git+https://git.lumeweb.com/LumeWeb/kernel-dns-client.git",
+ "@lumeweb/kernel-ipfs-client": "git+https://git.lumeweb.com/LumeWeb/kernel-ipfs-client.git",
+ "@lumeweb/libresolver": "git+https://git.lumeweb.com/LumeWeb/libresolver.git",
+ "@lumeweb/tld-enum": "git+https://git.lumeweb.com/LumeWeb/list-of-top-level-domains.git",
+ "@lumeweb/webextension-polyfill": "git+https://git.lumeweb.com/LumeWeb/webextension-polyfill.git",
+ "@peculiar/webcrypto": "^1.4.3",
+ "@siaweb/libweb": "git+https://git.lumeweb.com/LumeWeb/libsiaweb.git",
+ "buffer": "^6.0.3",
"is-ipfs": "^6.0.2",
- "libkernel": "https://github.com/LumeWeb/libextension.git",
+ "libkernel": "^0.1.48",
"libskynet": "^0.0.62",
"node-cache": "^5.1.2"
},
"browser": {
- "libkmodule": false,
- "path": "path-browserify",
+ "crypto": "crypto-browserify",
"fs": "browserify-fs",
- "crypto": "crypto-browserify"
+ "libkmodule": false,
+ "path": "path-browserify"
}
}
diff --git a/src/clients.ts b/src/clients.ts
new file mode 100644
index 0000000..309e9d8
--- /dev/null
+++ b/src/clients.ts
@@ -0,0 +1,7 @@
+import { createClient as createDnsClient } from "@lumeweb/kernel-dns-client";
+import { createClient as createIpfsClient } from "@lumeweb/kernel-ipfs-client";
+
+const dnsClient = createDnsClient();
+const ipfsClient = createIpfsClient();
+
+export { dnsClient, ipfsClient };
diff --git a/src/contentProviders/ipfsProvider.ts b/src/contentProviders/ipfsProvider.ts
index cab84f8..db63964 100644
--- a/src/contentProviders/ipfsProvider.ts
+++ b/src/contentProviders/ipfsProvider.ts
@@ -7,86 +7,17 @@ import {
OnRequestDetailsType,
StreamFilter,
} from "../types.js";
-import { getRelayProxies, streamToArray } from "../util.js";
-import { ipfsPath, ipnsPath, path } from "is-ipfs";
-import {
- fetchIpfs,
- fetchIpns,
- statIpfs,
- statIpns,
-} from "@lumeweb/kernel-ipfs-client";
-import ejs from "ejs";
-import { cacheDb } from "../databases.js";
+import { getRelayProxies } from "../util.js";
+import { ipfsPath, ipnsPath, path as checkPath } from "is-ipfs";
+import { createClient } from "@lumeweb/kernel-ipfs-client";
import { DNS_RECORD_TYPE, DNSResult } from "@lumeweb/libresolver";
import RequestStream from "../requestStream.js";
import ContentFilterRegistry from "../contentFilterRegistry.js";
-
-const INDEX_HTML_FILES = ["index.html", "index.htm", "index.shtml"];
-
-const DIRECTORY_TEMPLATE = ejs.compile(`
-
-
-
-
- <%= path %>
-
-
-
-
-
-
-
-
- Index of <%= path %>
-
-
-
-
- |
-
- |
-
- ..
- |
- |
-
- <% links.forEach(function (link) { %>
-
- |
- <%= link.name %>
- | <%= link.size %> |
-
-
- <% }) %>
-
-
-
-