@neardefi/shade-agent-js
Version:
This library is intended to be used in conjunction with the [shade agent template](https://github.com/NearDeFi/shade-agent-template/).
22,696 lines • 710 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __commonJS = (cb, mod2) => function __require() {
return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
mod2
));
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
// node_modules/dotenv/package.json
var require_package = __commonJS({
"node_modules/dotenv/package.json"(exports2, module2) {
module2.exports = {
name: "dotenv",
version: "16.5.0",
description: "Loads environment variables from .env file",
main: "lib/main.js",
types: "lib/main.d.ts",
exports: {
".": {
types: "./lib/main.d.ts",
require: "./lib/main.js",
default: "./lib/main.js"
},
"./config": "./config.js",
"./config.js": "./config.js",
"./lib/env-options": "./lib/env-options.js",
"./lib/env-options.js": "./lib/env-options.js",
"./lib/cli-options": "./lib/cli-options.js",
"./lib/cli-options.js": "./lib/cli-options.js",
"./package.json": "./package.json"
},
scripts: {
"dts-check": "tsc --project tests/types/tsconfig.json",
lint: "standard",
pretest: "npm run lint && npm run dts-check",
test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
"test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",
prerelease: "npm test",
release: "standard-version"
},
repository: {
type: "git",
url: "git://github.com/motdotla/dotenv.git"
},
homepage: "https://github.com/motdotla/dotenv#readme",
funding: "https://dotenvx.com",
keywords: [
"dotenv",
"env",
".env",
"environment",
"variables",
"config",
"settings"
],
readmeFilename: "README.md",
license: "BSD-2-Clause",
devDependencies: {
"@types/node": "^18.11.3",
decache: "^4.6.2",
sinon: "^14.0.1",
standard: "^17.0.0",
"standard-version": "^9.5.0",
tap: "^19.2.0",
typescript: "^4.8.4"
},
engines: {
node: ">=12"
},
browser: {
fs: false
}
};
}
});
// node_modules/dotenv/lib/main.js
var require_main = __commonJS({
"node_modules/dotenv/lib/main.js"(exports2, module2) {
var fs = require("fs");
var path = require("path");
var os = require("os");
var crypto4 = require("crypto");
var packageJson = require_package();
var version = packageJson.version;
var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
function parse(src) {
const obj = {};
let lines = src.toString();
lines = lines.replace(/\r\n?/mg, "\n");
let match;
while ((match = LINE.exec(lines)) != null) {
const key = match[1];
let value = match[2] || "";
value = value.trim();
const maybeQuote = value[0];
value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
if (maybeQuote === '"') {
value = value.replace(/\\n/g, "\n");
value = value.replace(/\\r/g, "\r");
}
obj[key] = value;
}
return obj;
}
function _parseVault(options) {
const vaultPath = _vaultPath(options);
const result = DotenvModule.configDotenv({ path: vaultPath });
if (!result.parsed) {
const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
err.code = "MISSING_DATA";
throw err;
}
const keys = _dotenvKey(options).split(",");
const length = keys.length;
let decrypted;
for (let i = 0; i < length; i++) {
try {
const key = keys[i].trim();
const attrs = _instructions(result, key);
decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
break;
} catch (error) {
if (i + 1 >= length) {
throw error;
}
}
}
return DotenvModule.parse(decrypted);
}
function _warn(message) {
console.log(`[dotenv@${version}][WARN] ${message}`);
}
function _debug(message) {
console.log(`[dotenv@${version}][DEBUG] ${message}`);
}
function _dotenvKey(options) {
if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
return options.DOTENV_KEY;
}
if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
return process.env.DOTENV_KEY;
}
return "";
}
function _instructions(result, dotenvKey) {
let uri;
try {
uri = new URL(dotenvKey);
} catch (error) {
if (error.code === "ERR_INVALID_URL") {
const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
throw error;
}
const key = uri.password;
if (!key) {
const err = new Error("INVALID_DOTENV_KEY: Missing key part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environment = uri.searchParams.get("environment");
if (!environment) {
const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
err.code = "INVALID_DOTENV_KEY";
throw err;
}
const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
const ciphertext = result.parsed[environmentKey];
if (!ciphertext) {
const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
throw err;
}
return { ciphertext, key };
}
function _vaultPath(options) {
let possibleVaultPath = null;
if (options && options.path && options.path.length > 0) {
if (Array.isArray(options.path)) {
for (const filepath of options.path) {
if (fs.existsSync(filepath)) {
possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
}
}
} else {
possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
}
} else {
possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
}
if (fs.existsSync(possibleVaultPath)) {
return possibleVaultPath;
}
return null;
}
function _resolveHome(envPath) {
return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
}
function _configVault(options) {
const debug = Boolean(options && options.debug);
if (debug) {
_debug("Loading env from encrypted .env.vault");
}
const parsed = DotenvModule._parseVault(options);
let processEnv = process.env;
if (options && options.processEnv != null) {
processEnv = options.processEnv;
}
DotenvModule.populate(processEnv, parsed, options);
return { parsed };
}
function configDotenv(options) {
const dotenvPath = path.resolve(process.cwd(), ".env");
let encoding = "utf8";
const debug = Boolean(options && options.debug);
if (options && options.encoding) {
encoding = options.encoding;
} else {
if (debug) {
_debug("No encoding is specified. UTF-8 is used by default");
}
}
let optionPaths = [dotenvPath];
if (options && options.path) {
if (!Array.isArray(options.path)) {
optionPaths = [_resolveHome(options.path)];
} else {
optionPaths = [];
for (const filepath of options.path) {
optionPaths.push(_resolveHome(filepath));
}
}
}
let lastError;
const parsedAll = {};
for (const path2 of optionPaths) {
try {
const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
DotenvModule.populate(parsedAll, parsed, options);
} catch (e) {
if (debug) {
_debug(`Failed to load ${path2} ${e.message}`);
}
lastError = e;
}
}
let processEnv = process.env;
if (options && options.processEnv != null) {
processEnv = options.processEnv;
}
DotenvModule.populate(processEnv, parsedAll, options);
if (lastError) {
return { parsed: parsedAll, error: lastError };
} else {
return { parsed: parsedAll };
}
}
function config3(options) {
if (_dotenvKey(options).length === 0) {
return DotenvModule.configDotenv(options);
}
const vaultPath = _vaultPath(options);
if (!vaultPath) {
_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
return DotenvModule.configDotenv(options);
}
return DotenvModule._configVault(options);
}
function decrypt(encrypted, keyStr) {
const key = Buffer.from(keyStr.slice(-64), "hex");
let ciphertext = Buffer.from(encrypted, "base64");
const nonce = ciphertext.subarray(0, 12);
const authTag = ciphertext.subarray(-16);
ciphertext = ciphertext.subarray(12, -16);
try {
const aesgcm = crypto4.createDecipheriv("aes-256-gcm", key, nonce);
aesgcm.setAuthTag(authTag);
return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
} catch (error) {
const isRange = error instanceof RangeError;
const invalidKeyLength = error.message === "Invalid key length";
const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
if (isRange || invalidKeyLength) {
const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
err.code = "INVALID_DOTENV_KEY";
throw err;
} else if (decryptionFailed) {
const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
err.code = "DECRYPTION_FAILED";
throw err;
} else {
throw error;
}
}
}
function populate(processEnv, parsed, options = {}) {
const debug = Boolean(options && options.debug);
const override = Boolean(options && options.override);
if (typeof parsed !== "object") {
const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
err.code = "OBJECT_REQUIRED";
throw err;
}
for (const key of Object.keys(parsed)) {
if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
if (override === true) {
processEnv[key] = parsed[key];
}
if (debug) {
if (override === true) {
_debug(`"${key}" is already defined and WAS overwritten`);
} else {
_debug(`"${key}" is already defined and was NOT overwritten`);
}
}
} else {
processEnv[key] = parsed[key];
}
}
}
var DotenvModule = {
configDotenv,
_configVault,
_parseVault,
config: config3,
decrypt,
parse,
populate
};
module2.exports.configDotenv = DotenvModule.configDotenv;
module2.exports._configVault = DotenvModule._configVault;
module2.exports._parseVault = DotenvModule._parseVault;
module2.exports.config = DotenvModule.config;
module2.exports.decrypt = DotenvModule.decrypt;
module2.exports.parse = DotenvModule.parse;
module2.exports.populate = DotenvModule.populate;
module2.exports = DotenvModule;
}
});
// node_modules/create-hash/index.js
var require_create_hash = __commonJS({
"node_modules/create-hash/index.js"(exports2, module2) {
module2.exports = require("crypto").createHash;
}
});
// node_modules/pbkdf2/lib/precondition.js
var require_precondition = __commonJS({
"node_modules/pbkdf2/lib/precondition.js"(exports2, module2) {
var MAX_ALLOC = Math.pow(2, 30) - 1;
module2.exports = function(iterations, keylen) {
if (typeof iterations !== "number") {
throw new TypeError("Iterations not a number");
}
if (iterations < 0) {
throw new TypeError("Bad iterations");
}
if (typeof keylen !== "number") {
throw new TypeError("Key length not a number");
}
if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
throw new TypeError("Bad key length");
}
};
}
});
// node_modules/pbkdf2/lib/default-encoding.js
var require_default_encoding = __commonJS({
"node_modules/pbkdf2/lib/default-encoding.js"(exports2, module2) {
var defaultEncoding;
if (global.process && global.process.browser) {
defaultEncoding = "utf-8";
} else if (global.process && global.process.version) {
pVersionMajor = parseInt(process.version.split(".")[0].slice(1), 10);
defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary";
} else {
defaultEncoding = "utf-8";
}
var pVersionMajor;
module2.exports = defaultEncoding;
}
});
// node_modules/safe-buffer/index.js
var require_safe_buffer = __commonJS({
"node_modules/safe-buffer/index.js"(exports2, module2) {
var buffer = require("buffer");
var Buffer2 = buffer.Buffer;
function copyProps(src, dst) {
for (var key in src) {
dst[key] = src[key];
}
}
if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
module2.exports = buffer;
} else {
copyProps(buffer, exports2);
exports2.Buffer = SafeBuffer;
}
function SafeBuffer(arg, encodingOrOffset, length) {
return Buffer2(arg, encodingOrOffset, length);
}
SafeBuffer.prototype = Object.create(Buffer2.prototype);
copyProps(Buffer2, SafeBuffer);
SafeBuffer.from = function(arg, encodingOrOffset, length) {
if (typeof arg === "number") {
throw new TypeError("Argument must not be a number");
}
return Buffer2(arg, encodingOrOffset, length);
};
SafeBuffer.alloc = function(size, fill, encoding) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
var buf = Buffer2(size);
if (fill !== void 0) {
if (typeof encoding === "string") {
buf.fill(fill, encoding);
} else {
buf.fill(fill);
}
} else {
buf.fill(0);
}
return buf;
};
SafeBuffer.allocUnsafe = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return Buffer2(size);
};
SafeBuffer.allocUnsafeSlow = function(size) {
if (typeof size !== "number") {
throw new TypeError("Argument must be a number");
}
return buffer.SlowBuffer(size);
};
}
});
// node_modules/pbkdf2/lib/to-buffer.js
var require_to_buffer = __commonJS({
"node_modules/pbkdf2/lib/to-buffer.js"(exports2, module2) {
var Buffer2 = require_safe_buffer().Buffer;
module2.exports = function(thing, encoding, name) {
if (Buffer2.isBuffer(thing)) {
return thing;
} else if (typeof thing === "string") {
return Buffer2.from(thing, encoding);
} else if (ArrayBuffer.isView(thing)) {
return Buffer2.from(thing.buffer);
} else {
throw new TypeError(name + " must be a string, a Buffer, a typed array or a DataView");
}
};
}
});
// node_modules/create-hmac/index.js
var require_create_hmac = __commonJS({
"node_modules/create-hmac/index.js"(exports2, module2) {
module2.exports = require("crypto").createHmac;
}
});
// node_modules/pbkdf2/lib/sync.js
var require_sync = __commonJS({
"node_modules/pbkdf2/lib/sync.js"(exports2, module2) {
var sizes = {
md5: 16,
sha1: 20,
sha224: 28,
sha256: 32,
sha384: 48,
sha512: 64,
rmd160: 20,
ripemd160: 20
};
var createHmac = require_create_hmac();
var Buffer2 = require_safe_buffer().Buffer;
var checkParameters = require_precondition();
var defaultEncoding = require_default_encoding();
var toBuffer = require_to_buffer();
function pbkdf2(password, salt, iterations, keylen, digest) {
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(salt, defaultEncoding, "Salt");
digest = digest || "sha1";
var DK = Buffer2.allocUnsafe(keylen);
var block1 = Buffer2.allocUnsafe(salt.length + 4);
salt.copy(block1, 0, 0, salt.length);
var destPos = 0;
var hLen = sizes[digest];
var l = Math.ceil(keylen / hLen);
for (var i = 1; i <= l; i++) {
block1.writeUInt32BE(i, salt.length);
var T = createHmac(digest, password).update(block1).digest();
var U = T;
for (var j = 1; j < iterations; j++) {
U = createHmac(digest, password).update(U).digest();
for (var k = 0; k < hLen; k++) T[k] ^= U[k];
}
T.copy(DK, destPos);
destPos += hLen;
}
return DK;
}
module2.exports = pbkdf2;
}
});
// node_modules/pbkdf2/lib/async.js
var require_async = __commonJS({
"node_modules/pbkdf2/lib/async.js"(exports2, module2) {
var Buffer2 = require_safe_buffer().Buffer;
var checkParameters = require_precondition();
var defaultEncoding = require_default_encoding();
var sync = require_sync();
var toBuffer = require_to_buffer();
var ZERO_BUF;
var subtle = global.crypto && global.crypto.subtle;
var toBrowser = {
sha: "SHA-1",
"sha-1": "SHA-1",
sha1: "SHA-1",
sha256: "SHA-256",
"sha-256": "SHA-256",
sha384: "SHA-384",
"sha-384": "SHA-384",
"sha-512": "SHA-512",
sha512: "SHA-512"
};
var checks = [];
function checkNative(algo) {
if (global.process && !global.process.browser) {
return Promise.resolve(false);
}
if (!subtle || !subtle.importKey || !subtle.deriveBits) {
return Promise.resolve(false);
}
if (checks[algo] !== void 0) {
return checks[algo];
}
ZERO_BUF = ZERO_BUF || Buffer2.alloc(8);
var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function() {
return true;
}).catch(function() {
return false;
});
checks[algo] = prom;
return prom;
}
var nextTick;
function getNextTick() {
if (nextTick) {
return nextTick;
}
if (global.process && global.process.nextTick) {
nextTick = global.process.nextTick;
} else if (global.queueMicrotask) {
nextTick = global.queueMicrotask;
} else if (global.setImmediate) {
nextTick = global.setImmediate;
} else {
nextTick = global.setTimeout;
}
return nextTick;
}
function browserPbkdf2(password, salt, iterations, length, algo) {
return subtle.importKey(
"raw",
password,
{ name: "PBKDF2" },
false,
["deriveBits"]
).then(function(key) {
return subtle.deriveBits({
name: "PBKDF2",
salt,
iterations,
hash: {
name: algo
}
}, key, length << 3);
}).then(function(res) {
return Buffer2.from(res);
});
}
function resolvePromise(promise, callback) {
promise.then(function(out) {
getNextTick()(function() {
callback(null, out);
});
}, function(e) {
getNextTick()(function() {
callback(e);
});
});
}
module2.exports = function(password, salt, iterations, keylen, digest, callback) {
if (typeof digest === "function") {
callback = digest;
digest = void 0;
}
digest = digest || "sha1";
var algo = toBrowser[digest.toLowerCase()];
if (!algo || typeof global.Promise !== "function") {
getNextTick()(function() {
var out;
try {
out = sync(password, salt, iterations, keylen, digest);
} catch (e) {
return callback(e);
}
callback(null, out);
});
return;
}
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(salt, defaultEncoding, "Salt");
if (typeof callback !== "function") throw new Error("No callback provided to pbkdf2");
resolvePromise(checkNative(algo).then(function(resp) {
if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo);
return sync(password, salt, iterations, keylen, digest);
}), callback);
};
}
});
// node_modules/pbkdf2/index.js
var require_pbkdf2 = __commonJS({
"node_modules/pbkdf2/index.js"(exports2) {
var native = require("crypto");
var checkParameters = require_precondition();
var defaultEncoding = require_default_encoding();
var toBuffer = require_to_buffer();
function nativePBKDF2(password, salt, iterations, keylen, digest, callback) {
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(salt, defaultEncoding, "Salt");
if (typeof digest === "function") {
callback = digest;
digest = "sha1";
}
if (typeof callback !== "function") throw new Error("No callback provided to pbkdf2");
return native.pbkdf2(password, salt, iterations, keylen, digest, callback);
}
function nativePBKDF2Sync(password, salt, iterations, keylen, digest) {
checkParameters(iterations, keylen);
password = toBuffer(password, defaultEncoding, "Password");
salt = toBuffer(salt, defaultEncoding, "Salt");
digest = digest || "sha1";
return native.pbkdf2Sync(password, salt, iterations, keylen, digest);
}
if (!native.pbkdf2Sync || native.pbkdf2Sync.toString().indexOf("keylen, digest") === -1) {
exports2.pbkdf2Sync = require_sync();
exports2.pbkdf2 = require_async();
} else {
exports2.pbkdf2Sync = nativePBKDF2Sync;
exports2.pbkdf2 = nativePBKDF2;
}
}
});
// node_modules/bip39-light/wordlists/english.json
var require_english = __commonJS({
"node_modules/bip39-light/wordlists/english.json"(exports2, module2) {
module2.exports = [
"abandon",
"ability",
"able",
"about",
"above",
"absent",
"absorb",
"abstract",
"absurd",
"abuse",
"access",
"accident",
"account",
"accuse",
"achieve",
"acid",
"acoustic",
"acquire",
"across",
"act",
"action",
"actor",
"actress",
"actual",
"adapt",
"add",
"addict",
"address",
"adjust",
"admit",
"adult",
"advance",
"advice",
"aerobic",
"affair",
"afford",
"afraid",
"again",
"age",
"agent",
"agree",
"ahead",
"aim",
"air",
"airport",
"aisle",
"alarm",
"album",
"alcohol",
"alert",
"alien",
"all",
"alley",
"allow",
"almost",
"alone",
"alpha",
"already",
"also",
"alter",
"always",
"amateur",
"amazing",
"among",
"amount",
"amused",
"analyst",
"anchor",
"ancient",
"anger",
"angle",
"angry",
"animal",
"ankle",
"announce",
"annual",
"another",
"answer",
"antenna",
"antique",
"anxiety",
"any",
"apart",
"apology",
"appear",
"apple",
"approve",
"april",
"arch",
"arctic",
"area",
"arena",
"argue",
"arm",
"armed",
"armor",
"army",
"around",
"arrange",
"arrest",
"arrive",
"arrow",
"art",
"artefact",
"artist",
"artwork",
"ask",
"aspect",
"assault",
"asset",
"assist",
"assume",
"asthma",
"athlete",
"atom",
"attack",
"attend",
"attitude",
"attract",
"auction",
"audit",
"august",
"aunt",
"author",
"auto",
"autumn",
"average",
"avocado",
"avoid",
"awake",
"aware",
"away",
"awesome",
"awful",
"awkward",
"axis",
"baby",
"bachelor",
"bacon",
"badge",
"bag",
"balance",
"balcony",
"ball",
"bamboo",
"banana",
"banner",
"bar",
"barely",
"bargain",
"barrel",
"base",
"basic",
"basket",
"battle",
"beach",
"bean",
"beauty",
"because",
"become",
"beef",
"before",
"begin",
"behave",
"behind",
"believe",
"below",
"belt",
"bench",
"benefit",
"best",
"betray",
"better",
"between",
"beyond",
"bicycle",
"bid",
"bike",
"bind",
"biology",
"bird",
"birth",
"bitter",
"black",
"blade",
"blame",
"blanket",
"blast",
"bleak",
"bless",
"blind",
"blood",
"blossom",
"blouse",
"blue",
"blur",
"blush",
"board",
"boat",
"body",
"boil",
"bomb",
"bone",
"bonus",
"book",
"boost",
"border",
"boring",
"borrow",
"boss",
"bottom",
"bounce",
"box",
"boy",
"bracket",
"brain",
"brand",
"brass",
"brave",
"bread",
"breeze",
"brick",
"bridge",
"brief",
"bright",
"bring",
"brisk",
"broccoli",
"broken",
"bronze",
"broom",
"brother",
"brown",
"brush",
"bubble",
"buddy",
"budget",
"buffalo",
"build",
"bulb",
"bulk",
"bullet",
"bundle",
"bunker",
"burden",
"burger",
"burst",
"bus",
"business",
"busy",
"butter",
"buyer",
"buzz",
"cabbage",
"cabin",
"cable",
"cactus",
"cage",
"cake",
"call",
"calm",
"camera",
"camp",
"can",
"canal",
"cancel",
"candy",
"cannon",
"canoe",
"canvas",
"canyon",
"capable",
"capital",
"captain",
"car",
"carbon",
"card",
"cargo",
"carpet",
"carry",
"cart",
"case",
"cash",
"casino",
"castle",
"casual",
"cat",
"catalog",
"catch",
"category",
"cattle",
"caught",
"cause",
"caution",
"cave",
"ceiling",
"celery",
"cement",
"census",
"century",
"cereal",
"certain",
"chair",
"chalk",
"champion",
"change",
"chaos",
"chapter",
"charge",
"chase",
"chat",
"cheap",
"check",
"cheese",
"chef",
"cherry",
"chest",
"chicken",
"chief",
"child",
"chimney",
"choice",
"choose",
"chronic",
"chuckle",
"chunk",
"churn",
"cigar",
"cinnamon",
"circle",
"citizen",
"city",
"civil",
"claim",
"clap",
"clarify",
"claw",
"clay",
"clean",
"clerk",
"clever",
"click",
"client",
"cliff",
"climb",
"clinic",
"clip",
"clock",
"clog",
"close",
"cloth",
"cloud",
"clown",
"club",
"clump",
"cluster",
"clutch",
"coach",
"coast",
"coconut",
"code",
"coffee",
"coil",
"coin",
"collect",
"color",
"column",
"combine",
"come",
"comfort",
"comic",
"common",
"company",
"concert",
"conduct",
"confirm",
"congress",
"connect",
"consider",
"control",
"convince",
"cook",
"cool",
"copper",
"copy",
"coral",
"core",
"corn",
"correct",
"cost",
"cotton",
"couch",
"country",
"couple",
"course",
"cousin",
"cover",
"coyote",
"crack",
"cradle",
"craft",
"cram",
"crane",
"crash",
"crater",
"crawl",
"crazy",
"cream",
"credit",
"creek",
"crew",
"cricket",
"crime",
"crisp",
"critic",
"crop",
"cross",
"crouch",
"crowd",
"crucial",
"cruel",
"cruise",
"crumble",
"crunch",
"crush",
"cry",
"crystal",
"cube",
"culture",
"cup",
"cupboard",
"curious",
"current",
"curtain",
"curve",
"cushion",
"custom",
"cute",
"cycle",
"dad",
"damage",
"damp",
"dance",
"danger",
"daring",
"dash",
"daughter",
"dawn",
"day",
"deal",
"debate",
"debris",
"decade",
"december",
"decide",
"decline",
"decorate",
"decrease",
"deer",
"defense",
"define",
"defy",
"degree",
"delay",
"deliver",
"demand",
"demise",
"denial",
"dentist",
"deny",
"depart",
"depend",
"deposit",
"depth",
"deputy",
"derive",
"describe",
"desert",
"design",
"desk",
"despair",
"destroy",
"detail",
"detect",
"develop",
"device",
"devote",
"diagram",
"dial",
"diamond",
"diary",
"dice",
"diesel",
"diet",
"differ",
"digital",
"dignity",
"dilemma",
"dinner",
"dinosaur",
"direct",
"dirt",
"disagree",
"discover",
"disease",
"dish",
"dismiss",
"disorder",
"display",
"distance",
"divert",
"divide",
"divorce",
"dizzy",
"doctor",
"document",
"dog",
"doll",
"dolphin",
"domain",
"donate",
"donkey",
"donor",
"door",
"dose",
"double",
"dove",
"draft",
"dragon",
"drama",
"drastic",
"draw",
"dream",
"dress",
"drift",
"drill",
"drink",
"drip",
"drive",
"drop",
"drum",
"dry",
"duck",
"dumb",
"dune",
"during",
"dust",
"dutch",
"duty",
"dwarf",
"dynamic",
"eager",
"eagle",
"early",
"earn",
"earth",
"easily",
"east",
"easy",
"echo",
"ecology",
"economy",
"edge",
"edit",
"educate",
"effort",
"egg",
"eight",
"either",
"elbow",
"elder",
"electric",
"elegant",
"element",
"elephant",
"elevator",
"elite",
"else",
"embark",
"embody",
"embrace",
"emerge",
"emotion",
"employ",
"empower",
"empty",
"enable",
"enact",
"end",
"endless",
"endorse",
"enemy",
"energy",
"enforce",
"engage",
"engine",
"enhance",
"enjoy",
"enlist",
"enough",
"enrich",
"enroll",
"ensure",
"enter",
"entire",
"entry",
"envelope",
"episode",
"equal",
"equip",
"era",
"erase",
"erode",
"erosion",
"error",
"erupt",
"escape",
"essay",
"essence",
"estate",
"eternal",
"ethics",
"evidence",
"evil",
"evoke",
"evolve",
"exact",
"example",
"excess",
"exchange",
"excite",
"exclude",
"excuse",
"execute",
"exercise",
"exhaust",
"exhibit",
"exile",
"exist",
"exit",
"exotic",
"expand",
"expect",
"expire",
"explain",
"expose",
"express",
"extend",
"extra",
"eye",
"eyebrow",
"fabric",
"face",
"faculty",
"fade",
"faint",
"faith",
"fall",
"false",
"fame",
"family",
"famous",
"fan",
"fancy",
"fantasy",
"farm",
"fashion",
"fat",
"fatal",
"father",
"fatigue",
"fault",
"favorite",
"feature",
"february",
"federal",
"fee",
"feed",
"feel",
"female",
"fence",
"festival",
"fetch",
"fever",
"few",
"fiber",
"fiction",
"field",
"figure",
"file",
"film",
"filter",
"final",
"find",
"fine",
"finger",
"finish",
"fire",
"firm",
"first",
"fiscal",
"fish",
"fit",
"fitness",
"fix",
"flag",
"flame",
"flash",
"flat",
"flavor",
"flee",
"flight",
"flip",
"float",
"flock",
"floor",
"flower",
"fluid",
"flush",
"fly",
"foam",
"focus",
"fog",
"foil",
"fold",
"follow",
"food",
"foot",
"force",
"forest",
"forget",
"fork",
"fortune",
"forum",
"forward",
"fossil",
"foster",
"found",
"fox",
"fragile",
"frame",
"frequent",
"fresh",
"friend",
"fringe",
"frog",
"front",
"frost",
"frown",
"frozen",
"fruit",
"fuel",
"fun",
"funny",
"furnace",
"fury",
"future",
"gadget",
"gain",
"galaxy",
"gallery",
"game",
"gap",
"garage",
"garbage",
"garden",
"garlic",
"garment",
"gas",
"gasp",
"gate",
"gather",
"gauge",
"gaze",
"general",
"genius",
"genre",
"gentle",
"genuine",
"gesture",
"ghost",
"giant",
"gift",
"giggle",
"ginger",
"giraffe",
"girl",
"give",
"glad",
"glance",
"glare",
"glass",
"glide",
"glimpse",
"globe",
"gloom",
"glory",
"glove",
"glow",
"glue",
"goat",
"goddess",
"gold",
"good",
"goose",
"gorilla",
"gospel",
"gossip",
"govern",
"gown",
"grab",
"grace",
"grain",
"grant",
"grape",
"grass",
"gravity",
"great",
"green",
"grid",
"grief",
"grit",
"grocery",
"group",
"grow",
"grunt",
"guard",
"guess",
"guide",
"guilt",
"guitar",
"gun",
"gym",
"habit",
"hair",
"half",
"hammer",
"hamster",
"hand",
"happy",
"harbor",
"hard",
"harsh",
"harvest",
"hat",
"have",
"hawk",
"hazard",
"head",
"health",
"heart",
"heavy",
"hedgehog",
"height",
"hello",
"helmet",
"help",
"hen",
"hero",
"hidden",
"high",
"hill",
"hint",
"hip",
"hire",
"history",
"hobby",
"hockey",
"hold",
"hole",
"holiday",
"hollow",
"home",
"honey",
"hood",
"hope",
"horn",
"horror",
"horse",
"hospital",
"host",
"hotel",
"hour",
"hover",
"hub",
"huge",
"human",
"humble",
"humor",
"hundred",
"hungry",
"hunt",
"hurdle",
"hurry",
"hurt",
"husband",
"hybrid",
"ice",
"icon",
"idea",
"identify",
"idle",
"ignore",
"ill",
"illegal",
"illness",
"image",
"imitate",
"immense",
"immune",
"impact",
"impose",
"improve",
"impulse",
"inch",
"include",
"income",
"increase",
"index",
"indicate",
"indoor",
"industry",
"infant",
"inflict",
"inform",
"inhale",
"inherit",
"initial",
"inject",
"injury",
"inmate",
"inner",
"innocent",
"input",
"inquiry",
"insane",
"insect",
"inside",
"inspire",
"install",
"intact",
"interest",
"into",
"invest",
"invite",
"involve",
"iron",
"island",
"isolate",
"issue",
"item",
"ivory",
"jacket",
"jaguar",
"jar",
"jazz",
"jealous",
"jeans",
"jelly",
"jewel",
"job",
"join",
"joke",
"journey",
"joy",
"judge",
"juice",
"jump",
"jungle",
"junior",
"junk",
"just",
"kangaroo",
"keen",
"keep",
"ketchup",
"key",
"kick",
"kid",
"kidney",
"kind",
"kingdom",
"kiss",
"kit",
"kitchen",
"kite",
"kitten",
"kiwi",
"knee",
"knife",
"knock",
"know",
"lab",
"label",
"labor",
"ladder",
"lady",
"lake",
"lamp",
"language",
"laptop",
"large",
"later",
"latin",
"laugh",
"laundry",
"lava",
"law",
"lawn",
"lawsuit",
"layer",
"lazy",
"leader",
"leaf",
"learn",
"leave",
"lecture",
"left",
"leg",
"legal",
"legend",
"leisure",
"lemon",
"lend",
"length",
"lens",
"leopard",
"lesson",
"letter",
"level",
"liar",
"liberty",
"library",
"license",
"life",
"lift",
"light",
"like",
"limb",
"limit",
"link",
"lion",
"liquid",
"list",
"little",
"live",
"lizard",
"load",
"loan",
"lobster",
"local",
"lock",
"logic",
"lonely",
"long",
"loop",
"lottery",
"loud",
"lounge",
"love",
"loyal",
"lucky",
"luggage",
"lumber",
"lunar",
"lunch",
"luxury",
"lyrics",
"machine",
"mad",
"magic",
"magnet",
"maid",
"mail",
"main",
"major",
"make",
"mammal",
"man",
"manage",
"mandate",
"mango",
"mansion",
"manual",
"maple",
"marble",
"march",
"margin",
"marine",
"market",
"marriage",
"mask",
"mass",
"master",
"match",
"material",
"math",
"matrix",
"matter",
"maximum",
"maze",
"meadow",
"mean",
"measure",
"meat",
"mechanic",
"medal",
"media",
"melody",
"melt",
"member",
"memory",
"mention",
"menu",
"mercy",
"merge",
"merit",
"merry",
"mesh",
"message",
"metal",
"method",
"middle",
"midnight",
"milk",
"million",
"mimic",
"mind",
"minimum",
"minor",
"minute",
"miracle",
"mirror",
"misery",
"miss",
"mistake",
"mix",
"mixed",
"mixture",
"mobile",
"model",
"modify",
"mom",
"moment",
"monitor",
"monkey",
"monster",
"month",
"moon",
"moral",
"more",
"morning",
"mosquito",
"mother",
"motion",
"motor",
"mountain",
"mouse",
"move",
"movie",
"much",
"muffin",
"mule",
"multiply",
"muscle",
"museum",
"mushroom",
"music",
"must",
"mutual",
"myself",
"mystery",
"myth",
"naive",
"name",
"napkin",
"narrow",
"nasty",
"nation",
"nature",
"near",
"neck",
"need",
"negative",
"neglect",
"neither",
"nephew",
"nerve",
"nest",
"net",
"network",
"neutral",
"never",
"news",
"next",
"nice",
"night",
"noble",
"noise",
"nominee",
"noodle",
"normal",
"north",
"nose",
"notable",
"note",
"nothing",
"notice",
"novel",
"now",
"nuclear",
"number",
"nurse",
"nut",
"oak",
"obey",
"object",
"oblige",
"obscure",
"observe",
"obtain",
"obvious",
"occur",
"ocean",
"october",
"odor",
"off",
"offer",
"office",
"often",
"oil",
"okay",
"old",
"olive",
"olympic",
"omit",
"once",
"one",
"onion",
"online",
"only",
"open",
"opera",
"opinion",
"oppose",
"option",
"orange",
"orbit",
"orchard",
"order",
"ordinary",
"organ",
"orient",
"original",
"orphan",
"ostrich",
"other",
"outdoor",
"outer",
"output",
"outside",
"oval",
"oven",
"over",
"own",
"owner",
"oxygen",
"oyster",
"ozone",
"pact",
"paddle",
"page",
"pair",
"palace",
"palm",
"panda",
"panel",
"panic",
"panther",
"paper",
"parade",
"parent",
"park",
"parrot",
"party",
"pass",
"patch",
"path",
"patient",
"patrol",
"pattern",
"pause",
"pave",
"payment",
"peace",
"peanut",
"pear",
"peasant",
"pelican",
"pen",
"penalty",
"pencil",
"people",
"pepper",
"perfect",
"permit",
"person",
"pet",
"phone",
"photo",
"phrase",
"physical",
"piano",
"picnic",
"picture",
"piece",
"pig",
"pigeon",
"pill",
"pilot",
"pink",
"pioneer",
"pipe",
"pistol",
"pitch",
"pizza",
"place",
"planet",
"plastic",
"plate",
"play",
"please",
"pledge",
"pluck",
"plug",
"plunge",
"poem",
"poet",
"point",
"polar",
"pole",
"police",
"pond",
"pony",
"pool",
"popular",
"portion",
"position",
"possible",
"post",
"potato",
"pottery",
"poverty",
"powder",
"power",
"practice",
"praise",
"predict",
"prefer",
"prepare",
"present",
"pretty",
"prevent",
"price",
"pride",
"primary",
"print",
"priority",
"prison",
"private",
"prize",
"problem",
"process",
"produce",
"profit",
"program",
"project",
"promote",
"proof",
"property",
"prosper",
"protect",
"proud",
"provide",
"public",
"pudding",
"pull",
"pulp",
"pulse",
"pumpkin",
"punch",
"pupil",
"puppy",
"purchase",
"purity",
"purpose",
"purse",
"push",
"put",
"puzzle",
"pyramid",
"quality",
"quantum",
"quarter",
"question",
"quick",
"quit",
"quiz",
"quote",
"rabbit",
"raccoon",
"race",
"rack",
"radar",
"radio",
"rail",
"rain",
"raise",
"rally",
"ramp",
"ranch",
"random",
"range",
"rapid",
"rare",
"rate",
"rather",
"raven",
"raw",
"razor",
"ready",
"real",
"reason",
"rebel",
"rebuild",
"recall",
"receive",
"recipe",
"record",
"recycle",
"reduce",
"reflect",
"reform",
"refuse",
"region",
"regret",
"regular",
"reject",
"relax",
"release",
"relief",
"rely",
"remain",
"remember",
"remind",
"remove",
"render",
"renew",
"rent",
"reopen",
"repair",
"repeat",
"replace",
"report",
"require",
"rescue",
"resemble",
"resist",
"resource",
"response",
"result",
"retire",
"retreat",
"return",
"reunion",
"reveal",
"review",
"reward",
"rhythm",
"rib",
"ribbon",
"rice",
"rich",
"ride",
"ridge",
"rifle",
"right",
"rigid",
"ring",
"riot",
"ripple",
"risk",
"ritual",
"rival",
"river",
"road",
"roast",
"robot",
"robust",
"rocket",
"romance",
"roof",
"rookie",
"room",
"rose",
"rotate",
"rough",
"round",
"route",
"royal",
"rubber",
"rude",
"rug",
"rule",
"run",
"runway",
"rural",
"sad",
"saddle",
"sadness",
"safe",
"sail",
"salad",
"salmon",
"salon",
"salt",
"salute",
"same",
"sample",
"sand",
"satisfy",
"satoshi",
"sauce",
"sausage",
"save",
"say",
"scale",
"scan",
"scare",
"scatter",
"scene",
"scheme",
"school",
"science",
"scissors",
"scorpion",
"scout",
"scrap",
"screen",
"script",
"scrub",
"sea",
"search",
"season",
"seat",
"second",
"secret",
"section",
"security",
"seed",
"seek",
"segment",
"select",
"sell",
"seminar",
"senior",
"sense",
"sentence",
"series",
"service",
"session",
"settle",
"setup",
"seven",
"shadow",
"shaft",
"shallow",
"share",
"shed",
"shell",
"sheriff",
"shield",
"shift",
"shine",
"ship",
"shiver",
"shock",
"shoe",
"shoot",
"shop",
"short",
"shoulder",
"shove",
"shrimp",
"shrug",
"shuffle",
"shy",
"sibling",
"sick",
"side",
"siege",
"sight",
"sign",
"silent",
"silk",
"silly",
"silver",
"similar",
"simple",
"since",
"sing",
"siren",
"sister",
"situate",
"six",
"size",
"skate",
"sketch",
"ski",
"skill",
"skin",
"skirt",
"skull",
"slab",
"slam",
"sleep",
"slender",
"slice",
"slide",
"slight",
"slim",
"slogan",
"slot",
"slow",
"slush",
"small",
"smart",
"smile",
"smoke",
"smooth",
"snack",
"snake",
"snap",
"sniff",
"snow",
"soap",
"soccer",
"social",
"sock",
"soda",
"soft",
"solar",
"soldier",
"solid",
"solution",
"solve",
"someone",
"song",
"soon",
"sorry",
"sort",
"soul",
"sound",
"soup",
"source",
"south",
"space",
"spare",
"spatial",
"spawn",
"speak",
"special",
"speed",
"spell",
"spend",
"sphere",
"spice",
"spider",
"spike",
"spin",
"spirit",
"split",
"spoil",
"sponsor",
"spoon",
"sport",
"spot",
"spray",
"spread",
"spring",
"spy",
"square",
"squeeze",
"squirrel",
"stable",
"stadium",
"staff",
"stage",
"stairs",
"stamp",
"stand",
"start",
"state",
"stay",
"steak",
"steel",
"stem",
"step",
"stereo",
"stick",
"still",
"sting",
"stock",
"stomach",
"stone",
"stool",
"story",
"stove",
"strategy",
"street",
"strike",
"strong",
"struggle",
"student",
"stuff",
"stumble",
"style",
"subject",
"submit",
"subway",
"success",
"such",
"sudden",
"suffer",
"sugar",
"suggest",
"suit",
"summer",
"sun",
"sunny",
"sunset",
"super",
"supply",
"supreme",
"sure",
"surface",
"surge",
"surprise",
"surround",
"survey",
"suspect",
"sustain",
"swallow",
"swamp",
"swap",
"swarm",
"swear",
"sweet",
"swift",
"swim",
"swing",
"switch",
"sword",
"symbol",
"symptom",
"syrup",
"system",
"table",
"tackle",
"tag",
"tail",
"talent",
"talk",
"tank",
"tape",
"target",
"task",
"taste",
"tattoo",
"taxi",
"teach",
"team",
"tell",
"ten",
"tenant",
"tennis",
"tent",
"term",
"test",
"text",
"thank",
"that",
"theme",
"then",
"theory",
"there",
"they",
"thing",
"this",
"thought",
"three",
"thrive",
"throw",
"thumb",
"thunder",
"ticket",
"tide",
"tiger",
"tilt",
"timber",
"time",
"tiny",
"tip",
"tired",
"tissue",
"title",
"toast",
"tobacco",
"today",
"toddler",
"toe",
"together",
"toilet",
"token",
"tomato",
"tomorrow",
"tone",
"tongue",
"tonight",
"tool",
"tooth",
"top",
"topic",
"topple",
"torch",
"tornado",
"tortoise",
"toss",
"total",
"tourist",
"toward",
"tower",
"town",
"toy",
"track",
"trade",
"traffic",
"tragic",
"train",
"transfer",
"trap",
"trash",
"travel",
"tray",
"treat",
"tree",
"trend",
"trial",
"tribe",
"trick",
"trigger",
"trim",
"trip",
"trophy",
"trouble",
"truck",
"true",
"truly",
"trumpet",
"trust",
"truth",
"try",
"tube",
"tuition",
"tumble",
"tuna",
"tunnel",
"turkey",
"turn",
"turtle",
"twelve",
"twenty",
"twice",
"twin",
"twist",
"two",
"type",
"typical",
"ugly",
"umbrella",
"unable",
"unaware",
"uncle",
"uncover",
"under",
"undo",
"unfair",
"unfold",
"unhappy",
"uniform",
"unique",
"unit",
"universe",
"unknown",
"unlock",
"until",
"unusual",
"unveil",
"update",
"upgrade",
"uphold",
"upon",
"upper",
"upset",
"urban",
"urge",
"usage",
"use",
"used",
"useful",
"useless",
"usual",
"utility",
"vacant",
"vacuum",
"vague",
"valid",
"valley",
"valve",
"van",
"vanish",
"vapor",
"various",
"vast",
"vault",
"vehicle",
"velvet",
"vendor",
"venture",
"venue",
"verb",
"verify",
"version",
"very",
"vessel",
"veteran",
"viable",
"vibrant",
"vicious",
"victory",
"video",
"view",
"village",
"vintage",
"violin",
"virtual",
"virus",
"visa",
"visit",
"visual",
"vital",
"vivid",
"vocal",
"voice",
"void",
"volcano",
"volume",
"vote",
"voyage",
"wage",
"wagon",
"wait",
"walk",
"wall",
"walnut",
"want",
"warfare",
"warm",
"warrior",
"wash",
"wasp",
"waste",
"water",
"wave",
"way",
"wealth",
"weapon",
"wear",
"weasel",
"weather",
"web",
"wedding",
"weekend",
"weird",
"welcome",
"west",
"wet",
"whale",
"what",
"wheat",
"wheel",
"when",
"where",
"whip",
"whisper",
"wide",
"width",
"wife",
"wild",
"will",
"win",
"window",
"wine",
"wing",
"wink",
"winner",
"winter",
"wire",
"wisdom",
"wise",
"wish",
"witness",
"wolf",
"woman",
"wonder",
"wood",
"wool",
"word",
"work",
"world",
"worry",
"worth",
"wrap",
"wreck",
"wrestle",
"wrist",
"write",
"wrong",
"yard",
"year",
"yellow",
"you",
"young",
"youth",
"zebra",
"zero",
"zone",
"zoo"
];
}
});
// node_modules/bip39-light/index.js
var require_bip39_light = __commonJS({
"node_modules/bip39-light/index.js"(exports2, module2) {
var randomBytes2;
if (typeof window !== "undefined" && window.crypto) {
randomBytes2 = function(len) {
var array = new Uint32Array(len);
return Buffer.from(window.crypto.getRandomValues(array));
};
} else {
randomBytes2 = require("crypto").randomBytes;
}
var createHash = require_create_hash();
var pbkdf2 = require_pbkdf2().pbkdf2Sync;
var ENGLISH_WORDLIST = require_english();
var DEFAULT_WORDLIST = ENGLISH_WORDLIST;
var INVALID_MNEMONIC = "Invalid mnemonic";
var INVALID_ENTROPY = "Invalid entropy";
var INVALID_CHECKSUM = "Invalid mnemonic checksum";
function lpad(str, padString, length) {
while (str.length < length) str = padString + str;
return str;
}
function binaryToByte(bin) {
return parseInt(bin, 2);
}
function bytesToBinary(bytes) {
return bytes.map(function(x) {
return lpad(x.toString(2), "0", 8);
}).join("");
}
function deriveChecksumBits(entropyBuffer) {
var ENT = entropyBuffer.length * 8;
var CS = ENT / 32;
var hash = createHash("sha256").update(entropyBuffer).digest();
return bytesToBinary([].slice.call(hash)).slice(0, CS);
}
function salt(password) {
return "mnemonic" + (password || "");
}
function mnemonicToSeed(mnemonic, password) {
var mnemonicBuffer = Buffer.from(mnemonic, "utf8");
var saltBuffer = Buffer.from(salt(password), "utf8");
return pbkdf2(mnemonicBuffer, saltBuffer, 2048, 64, "sha512");
}
function mnemonicToSeedHex(mnemonic, password) {
return mnemonicToSeed(mnemonic, password).toString("hex");
}
function mnemonicToEntropy(mnemonic, wordlist) {
wordlist = wordlist || DEFAULT_WORDLIST;
var words = mnemonic.split(" ");
if (words.length % 3 !== 0) throw new Error(INVALID_MNEMONIC);
var bits = words.map(function(word) {
var index = wordlist.indexOf(word);
if (index === -1) throw new Error(INVALID_MNEMONIC);
return lpad(index.toString(2), "0", 11);
}).join("");
var dividerIndex = Math.floor(bits.length / 33) * 32;
var entropyBits = bits.slice(0, dividerIndex);
var checksumBits = bits.slice(dividerIndex);
var entropyBytes = entropyBits.match(/(.{1,8})/g).map(binaryToByte);
if (entropyBytes.length < 16) throw new Error(INVALID_ENTROPY);
if (entropyBytes.length > 32) throw new Error(INVALID_ENTROPY);
if (entropyBytes.length % 4 !== 0) throw new Error(INVALID_ENTROPY);
var entropy = Buffer.from(entropyBytes);
var newChecksum = deriveChecksumBits(entropy);
if (newChecksum !== checksumBits) throw new Error(INVALID_CHECKSUM);
return entropy.toString("hex");
}
function entropyToMnemonic(entropy, wordlist) {
if (!Buffer.isBuffer(entropy)) entropy = Buffer.from(entropy, "hex");
wordlist = wordlist || DEFAULT_WORDLIST;
if (entropy.length < 16) throw new TypeError(INVALID_ENTROPY);
if (entropy.length > 32) throw new TypeError(INVALID_ENTROPY);
if (entropy.length % 4 !== 0) throw new TypeError(INVALID_ENTROPY);
var entropyBits = bytesToBinary([].slice.call(entropy));
var checksumBits = deriveChecksumBits(entropy);
var bits = entropyBits + checksumBits;
var chunks = bits.match(/(.{1,11})/g);
var words = chunks.map(function(binary) {
var index = binaryToByte(binary);
return wordlist[index];
});
return words.join(" ");
}
function generateMnemonic(strength, rng, wordlist) {
strength = strength || 128;
if (strength % 32 !== 0) throw new TypeError(INVALID_ENTROPY);
rng = rng || randomBytes2;
return entropyToMnemonic(rng(strength / 8), wordlist);
}
function validateMnemonic(mnemonic, wordlist) {
try {
mnemonicToEntropy(mnemonic, wordlist);
} catch (e) {
return false;
}
return true;
}
module2.exports = {
mnemonicToSeed,
mnemonicToSeedHex,
mnemonicToEntropy,
entropyToMnemonic,
generateMnemonic,
validateMnemonic,
wordlists: {
EN: ENGLISH_WORDLIST
}
};
}
});
// node_modules/tweetnacl/nacl-fast.js
var require_nacl_fast = __commonJS({
"node_modules/tweetnacl/nacl-fast.js"(exports2, module2) {
(function(nacl) {
"use strict";
var gf = function(init) {
var i, r = new Float64Array(16);
if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
return r;
};
var randombytes3 = function() {
throw new Error("no PRNG");
};
var _0 = new Uint8Array(16);
var _9 = new Uint8Array(32);
_9[0] = 9;
var gf0 = gf(), gf1 = gf([1]), _121665 = gf([56129, 1]), D = gf([30883, 4953, 19914, 30187, 55467, 16705, 2637, 112, 59544, 30585, 16505, 36039, 65139, 11119, 27886, 20995]), D2 = gf([61785, 9906, 39828, 60374, 45398, 33411, 5274, 224, 53552, 61171, 33010, 6542, 64743, 22239, 55772, 9222]), X = gf([54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412, 64982, 57905, 49316, 21502, 52590, 14035, 8553]), Y = gf([26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214]), I = gf([41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207, 15867, 153, 11085, 57099, 20417, 9344, 11139]);
function ts64(x, i, h, l) {
x[i] = h >> 24 & 255;
x[i + 1] = h >> 16 & 255;
x[i + 2] = h >> 8 & 255;
x[i + 3] = h & 255;
x[i + 4] = l >> 24 & 255;
x[i + 5] = l >> 16 & 255;
x[i + 6] = l >> 8 & 255;
x[i + 7] = l & 255;
}
function vn(x, xi, y, yi, n) {
var i, d = 0;
for (i = 0; i < n; i++) d |= x[xi + i] ^ y[yi + i];
return (1 & d - 1 >>> 8) - 1;
}
function crypto_verify_16(x, xi, y, yi) {
return vn(x, xi, y, yi, 16);
}
function crypto_verify_32(x, xi, y, yi) {
return vn(x, xi, y, yi, 32);
}
function core_salsa20(o, p, k, c) {
var j0 = c[0] & 255 | (c[1] & 255) << 8 | (c[2] & 255) << 16 | (c[3] & 255) << 24, j1 = k[0] & 255 | (k[1] & 255) << 8 | (k[2] & 255) << 16 | (k[3] & 255) << 24, j2 = k[4] & 255 | (k[5] & 255) << 8 | (k[6] & 255) << 16 | (k[7] & 255) << 24, j3 = k[8] & 255 | (k[9] & 255) << 8 | (k[10] & 255) << 16 | (k[11] & 255) << 24, j4 = k[12] & 255 | (k[13] & 255) << 8 | (k[14] & 255) << 16 | (k[15] & 255) << 24, j5 = c[4] & 255 | (c[5] & 255) << 8 | (c[6] & 255) << 16 | (c[7] & 255) << 24, j6 = p[0] & 255 | (p[1] & 255) << 8 | (p[2] & 255) << 16 | (p[3] & 255) << 24, j7 = p[4] & 255 | (p[5] & 255) << 8 | (p[6] & 255) << 16 | (p[7] & 255) << 24, j8 = p[8] & 255 | (p[9] & 255) << 8 | (p[10] & 255) << 16 | (p[11] & 255) << 24, j9 = p[12] & 255 | (p[13] & 255) << 8 | (p[14] & 255) << 16 | (p[15] & 255) << 24, j10 = c[8] & 255 | (c[9] & 255) << 8 | (c[10] & 255) << 16 | (c[11] & 255) << 24, j11 = k[16] & 255 | (k[17] & 255) << 8 | (k[18] & 255) << 16 | (k[19] & 255) << 24, j12 = k[20] & 255 | (k[21] & 255) << 8 | (k[22] & 255) << 16 | (k[23] & 255) << 24, j13 = k[24] & 255 | (k[25] & 255) << 8 | (k[26] & 255) << 16 | (k[27] & 255) << 24, j14 = k[28] & 255 | (k[29] & 255) << 8 | (k[30] & 255) << 16 | (k[31] & 255) << 24, j15 = c[12] & 255 | (c[13] & 255) << 8 | (c[14] & 255) << 16 | (c[15] & 255) << 24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u << 7 | u >>> 32 - 7;
u = x4 + x0 | 0;
x8 ^= u << 9 | u >>> 32 - 9;
u = x8 + x4 | 0;
x12 ^= u << 13 | u >>> 32 - 13;
u = x12 + x8 | 0;
x0 ^= u << 18 | u >>> 32 - 18;
u = x5 + x1 | 0;
x9 ^= u << 7 | u >>> 32 - 7;
u = x9 + x5 | 0;
x13 ^= u << 9 | u >>> 32 - 9;
u = x13 + x9 | 0;
x1 ^= u << 13 | u >>> 32 - 13;
u = x1 + x13 | 0;
x5 ^= u << 18 | u >>> 32 - 18;
u = x10 + x6 | 0;
x14 ^= u << 7 | u >>> 32 - 7;
u = x14 + x10 | 0;
x2 ^= u << 9 | u >>> 32 - 9;
u = x2 + x14 | 0;
x6 ^= u << 13 | u >>> 32 - 13;
u = x6 + x2 | 0;
x10 ^= u << 18 | u >>> 32 - 18;
u = x15 + x11 | 0;
x3 ^= u << 7 | u >>> 32 - 7;
u = x3 + x15 | 0;
x7 ^= u << 9 | u >>> 32 - 9;
u = x7 + x3 | 0;
x11 ^= u << 13 | u >>> 32 - 13;
u = x11 + x7 | 0;
x15 ^= u << 18 | u >>> 32 - 18;
u = x0 + x3 | 0;
x1 ^= u << 7 | u >>> 32 - 7;
u = x1 + x0 | 0;
x2 ^= u << 9 | u >>> 32 - 9;
u = x2 + x1 | 0;
x3 ^= u << 13 | u >>> 32 - 13;
u = x3 + x2 | 0;
x0 ^= u << 18 | u >>> 32 - 18;
u = x5 + x4 | 0;
x6 ^= u << 7 | u >>> 32 - 7;
u = x6 + x5 | 0;
x7 ^= u << 9 | u >>> 32 - 9;
u = x7 + x6 | 0;
x4 ^= u << 13 | u >>> 32 - 13;
u = x4 + x7 | 0;
x5 ^= u << 18 | u >>> 32 - 18;
u = x10 + x9 | 0;
x11 ^= u << 7 | u >>> 32 - 7;
u = x11 + x10 | 0;
x8 ^= u << 9 | u >>> 32 - 9;
u = x8 + x11 | 0;
x9 ^= u << 13 | u >>> 32 - 13;
u = x9 + x8 | 0;
x10 ^= u << 18 | u >>> 32 - 18;
u = x15 + x14 | 0;
x12 ^= u << 7 | u >>> 32 - 7;
u = x12 + x15 | 0;
x13 ^= u << 9 | u >>> 32 - 9;
u = x13 + x12 | 0;
x14 ^= u << 13 | u >>> 32 - 13;
u = x14 + x13 | 0;
x15 ^= u << 18 | u >>> 32 - 18;
}
x0 = x0 + j0 | 0;
x1 = x1 + j1 | 0;
x2 = x2 + j2 | 0;
x3 = x3 + j3 | 0;
x4 = x4 + j4 | 0;
x5 = x5 + j5 | 0;
x6 = x6 + j6 | 0;
x7 = x7 + j7 | 0;
x8 = x8 + j8 | 0;
x9 = x9 + j9 | 0;
x10 = x10 + j10 | 0;
x11 = x11 + j11 | 0;
x12 = x12 + j12 | 0;
x13 = x13 + j13 | 0;
x14 = x14 + j14 | 0;
x15 = x15 + j15 | 0;
o[0] = x0 >>> 0 & 255;
o[1] = x0 >>> 8 & 255;
o[2] = x0 >>> 16 & 255;
o[3] = x0 >>> 24 & 255;
o[4] = x1 >>> 0 & 255;
o[5] = x1 >>> 8 & 255;
o[6] = x1 >>> 16 & 255;
o[7] = x1 >>> 24 & 255;
o[8] = x2 >>> 0 & 255;
o[9] = x2 >>> 8 & 255;
o[10] = x2 >>> 16 & 255;
o[11] = x2 >>> 24 & 255;
o[12] = x3 >>> 0 & 255;
o[13] = x3 >>> 8 & 255;
o[14] = x3 >>> 16 & 255;
o[15] = x3 >>> 24 & 255;
o[16] = x4 >>> 0 & 255;
o[17] = x4 >>> 8 & 255;
o[18] = x4 >>> 16 & 255;
o[19] = x4 >>> 24 & 255;
o[20] = x5 >>> 0 & 255;
o[21] = x5 >>> 8 & 255;
o[22] = x5 >>> 16 & 255;
o[23] = x5 >>> 24 & 255;
o[24] = x6 >>> 0 & 255;
o[25] = x6 >>> 8 & 255;
o[26] = x6 >>> 16 & 255;
o[27] = x6 >>> 24 & 255;
o[28] = x7 >>> 0 & 255;
o[29] = x7 >>> 8 & 255;
o[30] = x7 >>> 16 & 255;
o[31] = x7 >>> 24 & 255;
o[32] = x8 >>> 0 & 255;
o[33] = x8 >>> 8 & 255;
o[34] = x8 >>> 16 & 255;
o[35] = x8 >>> 24 & 255;
o[36] = x9 >>> 0 & 255;
o[37] = x9 >>> 8 & 255;
o[38] = x9 >>> 16 & 255;
o[39] = x9 >>> 24 & 255;
o[40] = x10 >>> 0 & 255;
o[41] = x10 >>> 8 & 255;
o[42] = x10 >>> 16 & 255;
o[43] = x10 >>> 24 & 255;
o[44] = x11 >>> 0 & 255;
o[45] = x11 >>> 8 & 255;
o[46] = x11 >>> 16 & 255;
o[47] = x11 >>> 24 & 255;
o[48] = x12 >>> 0 & 255;
o[49] = x12 >>> 8 & 255;
o[50] = x12 >>> 16 & 255;
o[51] = x12 >>> 24 & 255;
o[52] = x13 >>> 0 & 255;
o[53] = x13 >>> 8 & 255;
o[54] = x13 >>> 16 & 255;
o[55] = x13 >>> 24 & 255;
o[56] = x14 >>> 0 & 255;
o[57] = x14 >>> 8 & 255;
o[58] = x14 >>> 16 & 255;
o[59] = x14 >>> 24 & 255;
o[60] = x15 >>> 0 & 255;
o[61] = x15 >>> 8 & 255;
o[62] = x15 >>> 16 & 255;
o[63] = x15 >>> 24 & 255;
}
function core_hsalsa20(o, p, k, c) {
var j0 = c[0] & 255 | (c[1] & 255) << 8 | (c[2] & 255) << 16 | (c[3] & 255) << 24, j1 = k[0] & 255 | (k[1] & 255) << 8 | (k[2] & 255) << 16 | (k[3] & 255) << 24, j2 = k[4] & 255 | (k[5] & 255) << 8 | (k[6] & 255) << 16 | (k[7] & 255) << 24, j3 = k[8] & 255 | (k[9] & 255) << 8 | (k[10] & 255) << 16 | (k[11] & 255) << 24, j4 = k[12] & 255 | (k[13] & 255) << 8 | (k[14] & 255) << 16 | (k[15] & 255) << 24, j5 = c[4] & 255 | (c[5] & 255) << 8 | (c[6] & 255) << 16 | (c[7] & 255) << 24, j6 = p[0] & 255 | (p[1] & 255) << 8 | (p[2] & 255) << 16 | (p[3] & 255) << 24, j7 = p[4] & 255 | (p[5] & 255) << 8 | (p[6] & 255) << 16 | (p[7] & 255) << 24, j8 = p[8] & 255 | (p[9] & 255) << 8 | (p[10] & 255) << 16 | (p[11] & 255) << 24, j9 = p[12] & 255 | (p[13] & 255) << 8 | (p[14] & 255) << 16 | (p[15] & 255) << 24, j10 = c[8] & 255 | (c[9] & 255) << 8 | (c[10] & 255) << 16 | (c[11] & 255) << 24, j11 = k[16] & 255 | (k[17] & 255) << 8 | (k[18] & 255) << 16 | (k[19] & 255) << 24, j12 = k[20] & 255 | (k[21] & 255) << 8 | (k[22] & 255) << 16 | (k[23] & 255) << 24, j13 = k[24] & 255 | (k[25] & 255) << 8 | (k[26] & 255) << 16 | (k[27] & 255) << 24, j14 = k[28] & 255 | (k[29] & 255) << 8 | (k[30] & 255) << 16 | (k[31] & 255) << 24, j15 = c[12] & 255 | (c[13] & 255) << 8 | (c[14] & 255) << 16 | (c[15] & 255) << 24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u << 7 | u >>> 32 - 7;
u = x4 + x0 | 0;
x8 ^= u << 9 | u >>> 32 - 9;
u = x8 + x4 | 0;
x12 ^= u << 13 | u >>> 32 - 13;
u = x12 + x8 | 0;
x0 ^= u << 18 | u >>> 32 - 18;
u = x5 + x1 | 0;
x9 ^= u << 7 | u >>> 32 - 7;
u = x9 + x5 | 0;
x13 ^= u << 9 | u >>> 32 - 9;
u = x13 + x9 | 0;
x1 ^= u << 13 | u >>> 32 - 13;
u = x1 + x13 | 0;
x5 ^= u << 18 | u >>> 32 - 18;
u = x10 + x6 | 0;
x14 ^= u << 7 | u >>> 32 - 7;
u = x14 + x10 | 0;
x2 ^= u << 9 | u >>> 32 - 9;
u = x2 + x14 | 0;
x6 ^= u << 13 | u >>> 32 - 13;
u = x6 + x2 | 0;
x10 ^= u << 18 | u >>> 32 - 18;
u = x15 + x11 | 0;
x3 ^= u << 7 | u >>> 32 - 7;
u = x3 + x15 | 0;
x7 ^= u << 9 | u >>> 32 - 9;
u = x7 + x3 | 0;
x11 ^= u << 13 | u >>> 32 - 13;
u = x11 + x7 | 0;
x15 ^= u << 18 | u >>> 32 - 18;
u = x0 + x3 | 0;
x1 ^= u << 7 | u >>> 32 - 7;
u = x1 + x0 | 0;
x2 ^= u << 9 | u >>> 32 - 9;
u = x2 + x1 | 0;
x3 ^= u << 13 | u >>> 32 - 13;
u = x3 + x2 | 0;
x0 ^= u << 18 | u >>> 32 - 18;
u = x5 + x4 | 0;
x6 ^= u << 7 | u >>> 32 - 7;
u = x6 + x5 | 0;
x7 ^= u << 9 | u >>> 32 - 9;
u = x7 + x6 | 0;
x4 ^= u << 13 | u >>> 32 - 13;
u = x4 + x7 | 0;
x5 ^= u << 18 | u >>> 32 - 18;
u = x10 + x9 | 0;
x11 ^= u << 7 | u >>> 32 - 7;
u = x11 + x10 | 0;
x8 ^= u << 9 | u >>> 32 - 9;
u = x8 + x11 | 0;
x9 ^= u << 13 | u >>> 32 - 13;
u = x9 + x8 | 0;
x10 ^= u << 18 | u >>> 32 - 18;
u = x15 + x14 | 0;
x12 ^= u << 7 | u >>> 32 - 7;
u = x12 + x15 | 0;
x13 ^= u << 9 | u >>> 32 - 9;
u = x13 + x12 | 0;
x14 ^= u << 13 | u >>> 32 - 13;
u = x14 + x13 | 0;
x15 ^= u << 18 | u >>> 32 - 18;
}
o[0] = x0 >>> 0 & 255;
o[1] = x0 >>> 8 & 255;
o[2] = x0 >>> 16 & 255;
o[3] = x0 >>> 24 & 255;
o[4] = x5 >>> 0 & 255;
o[5] = x5 >>> 8 & 255;
o[6] = x5 >>> 16 & 255;
o[7] = x5 >>> 24 & 255;
o[8] = x10 >>> 0 & 255;
o[9] = x10 >>> 8 & 255;
o[10] = x10 >>> 16 & 255;
o[11] = x10 >>> 24 & 255;
o[12] = x15 >>> 0 & 255;
o[13] = x15 >>> 8 & 255;
o[14] = x15 >>> 16 & 255;
o[15] = x15 >>> 24 & 255;
o[16] = x6 >>> 0 & 255;
o[17] = x6 >>> 8 & 255;
o[18] = x6 >>> 16 & 255;
o[19] = x6 >>> 24 & 255;
o[20] = x7 >>> 0 & 255;
o[21] = x7 >>> 8 & 255;
o[22] = x7 >>> 16 & 255;
o[23] = x7 >>> 24 & 255;
o[24] = x8 >>> 0 & 255;
o[25] = x8 >>> 8 & 255;
o[26] = x8 >>> 16 & 255;
o[27] = x8 >>> 24 & 255;
o[28] = x9 >>> 0 & 255;
o[29] = x9 >>> 8 & 255;
o[30] = x9 >>> 16 & 255;
o[31] = x9 >>> 24 & 255;
}
function crypto_core_salsa20(out, inp, k, c) {
core_salsa20(out, inp, k, c);
}
function crypto_core_hsalsa20(out, inp, k, c) {
core_hsalsa20(out, inp, k, c);
}
var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x, z, k, sigma);
for (i = 0; i < 64; i++) c[cpos + i] = m[mpos + i] ^ x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 255) | 0;
z[i] = u & 255;
u >>>= 8;
}
b -= 64;
cpos += 64;
mpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x, z, k, sigma);
for (i = 0; i < b; i++) c[cpos + i] = m[mpos + i] ^ x[i];
}
return 0;
}
function crypto_stream_salsa20(c, cpos, b, n, k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x, z, k, sigma);
for (i = 0; i < 64; i++) c[cpos + i] = x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 255) | 0;
z[i] = u & 255;
u >>>= 8;
}
b -= 64;
cpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x, z, k, sigma);
for (i = 0; i < b; i++) c[cpos + i] = x[i];
}
return 0;
}
function crypto_stream(c, cpos, d, n, k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s, n, k, sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
return crypto_stream_salsa20(c, cpos, d, sn, s);
}
function crypto_stream_xor(c, cpos, m, mpos, d, n, k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s, n, k, sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i + 16];
return crypto_stream_salsa20_xor(c, cpos, m, mpos, d, sn, s);
}
var poly1305 = function(key) {
this.buffer = new Uint8Array(16);
this.r = new Uint16Array(10);
this.h = new Uint16Array(10);
this.pad = new Uint16Array(8);
this.leftover = 0;
this.fin = 0;
var t0, t1, t2, t3, t4, t5, t6, t7;
t0 = key[0] & 255 | (key[1] & 255) << 8;
this.r[0] = t0 & 8191;
t1 = key[2] & 255 | (key[3] & 255) << 8;
this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
t2 = key[4] & 255 | (key[5] & 255) << 8;
this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
t3 = key[6] & 255 | (key[7] & 255) << 8;
this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
t4 = key[8] & 255 | (key[9] & 255) << 8;
this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
this.r[5] = t4 >>> 1 & 8190;
t5 = key[10] & 255 | (key[11] & 255) << 8;
this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
t6 = key[12] & 255 | (key[13] & 255) << 8;
this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
t7 = key[14] & 255 | (key[15] & 255) << 8;
this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
this.r[9] = t7 >>> 5 & 127;
this.pad[0] = key[16] & 255 | (key[17] & 255) << 8;
this.pad[1] = key[18] & 255 | (key[19] & 255) << 8;
this.pad[2] = key[20] & 255 | (key[21] & 255) << 8;
this.pad[3] = key[22] & 255 | (key[23] & 255) << 8;
this.pad[4] = key[24] & 255 | (key[25] & 255) << 8;
this.pad[5] = key[26] & 255 | (key[27] & 255) << 8;
this.pad[6] = key[28] & 255 | (key[29] & 255) << 8;
this.pad[7] = key[30] & 255 | (key[31] & 255) << 8;
};
poly1305.prototype.blocks = function(m, mpos, bytes) {
var hibit = this.fin ? 0 : 1 << 11;
var t0, t1, t2, t3, t4, t5, t6, t7, c;
var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
var h0 = this.h[0], h1 = this.h[1], h2 = this.h[2], h3 = this.h[3], h4 = this.h[4], h5 = this.h[5], h6 = this.h[6], h7 = this.h[7], h8 = this.h[8], h9 = this.h[9];
var r0 = this.r[0], r1 = this.r[1], r2 = this.r[2], r3 = this.r[3], r4 = this.r[4], r5 = this.r[5], r6 = this.r[6], r7 = this.r[7], r8 = this.r[8], r9 = this.r[9];
while (bytes >= 16) {
t0 = m[mpos + 0] & 255 | (m[mpos + 1] & 255) << 8;
h0 += t0 & 8191;
t1 = m[mpos + 2] & 255 | (m[mpos + 3] & 255) << 8;
h1 += (t0 >>> 13 | t1 << 3) & 8191;
t2 = m[mpos + 4] & 255 | (m[mpos + 5] & 255) << 8;
h2 += (t1 >>> 10 | t2 << 6) & 8191;
t3 = m[mpos + 6] & 255 | (m[mpos + 7] & 255) << 8;
h3 += (t2 >>> 7 | t3 << 9) & 8191;
t4 = m[mpos + 8] & 255 | (m[mpos + 9] & 255) << 8;
h4 += (t3 >>> 4 | t4 << 12) & 8191;
h5 += t4 >>> 1 & 8191;
t5 = m[mpos + 10] & 255 | (m[mpos + 11] & 255) << 8;
h6 += (t4 >>> 14 | t5 << 2) & 8191;
t6 = m[mpos + 12] & 255 | (m[mpos + 13] & 255) << 8;
h7 += (t5 >>> 11 | t6 << 5) & 8191;
t7 = m[mpos + 14] & 255 | (m[mpos + 15] & 255) << 8;
h8 += (t6 >>> 8 | t7 << 8) & 8191;
h9 += t7 >>> 5 | hibit;
c = 0;
d0 = c;
d0 += h0 * r0;
d0 += h1 * (5 * r9);
d0 += h2 * (5 * r8);
d0 += h3 * (5 * r7);
d0 += h4 * (5 * r6);
c = d0 >>> 13;
d0 &= 8191;
d0 += h5 * (5 * r5);
d0 += h6 * (5 * r4);
d0 += h7 * (5 * r3);
d0 += h8 * (5 * r2);
d0 += h9 * (5 * r1);
c += d0 >>> 13;
d0 &= 8191;
d1 = c;
d1 += h0 * r1;
d1 += h1 * r0;
d1 += h2 * (5 * r9);
d1 += h3 * (5 * r8);
d1 += h4 * (5 * r7);
c = d1 >>> 13;
d1 &= 8191;
d1 += h5 * (5 * r6);
d1 += h6 * (5 * r5);
d1 += h7 * (5 * r4);
d1 += h8 * (5 * r3);
d1 += h9 * (5 * r2);
c += d1 >>> 13;
d1 &= 8191;
d2 = c;
d2 += h0 * r2;
d2 += h1 * r1;
d2 += h2 * r0;
d2 += h3 * (5 * r9);
d2 += h4 * (5 * r8);
c = d2 >>> 13;
d2 &= 8191;
d2 += h5 * (5 * r7);
d2 += h6 * (5 * r6);
d2 += h7 * (5 * r5);
d2 += h8 * (5 * r4);
d2 += h9 * (5 * r3);
c += d2 >>> 13;
d2 &= 8191;
d3 = c;
d3 += h0 * r3;
d3 += h1 * r2;
d3 += h2 * r1;
d3 += h3 * r0;
d3 += h4 * (5 * r9);
c = d3 >>> 13;
d3 &= 8191;
d3 += h5 * (5 * r8);
d3 += h6 * (5 * r7);
d3 += h7 * (5 * r6);
d3 += h8 * (5 * r5);
d3 += h9 * (5 * r4);
c += d3 >>> 13;
d3 &= 8191;
d4 = c;
d4 += h0 * r4;
d4 += h1 * r3;
d4 += h2 * r2;
d4 += h3 * r1;
d4 += h4 * r0;
c = d4 >>> 13;
d4 &= 8191;
d4 += h5 * (5 * r9);
d4 += h6 * (5 * r8);
d4 += h7 * (5 * r7);
d4 += h8 * (5 * r6);
d4 += h9 * (5 * r5);
c += d4 >>> 13;
d4 &= 8191;
d5 = c;
d5 += h0 * r5;
d5 += h1 * r4;
d5 += h2 * r3;
d5 += h3 * r2;
d5 += h4 * r1;
c = d5 >>> 13;
d5 &= 8191;
d5 += h5 * r0;
d5 += h6 * (5 * r9);
d5 += h7 * (5 * r8);
d5 += h8 * (5 * r7);
d5 += h9 * (5 * r6);
c += d5 >>> 13;
d5 &= 8191;
d6 = c;
d6 += h0 * r6;
d6 += h1 * r5;
d6 += h2 * r4;
d6 += h3 * r3;
d6 += h4 * r2;
c = d6 >>> 13;
d6 &= 8191;
d6 += h5 * r1;
d6 += h6 * r0;
d6 += h7 * (5 * r9);
d6 += h8 * (5 * r8);
d6 += h9 * (5 * r7);
c += d6 >>> 13;
d6 &= 8191;
d7 = c;
d7 += h0 * r7;
d7 += h1 * r6;
d7 += h2 * r5;
d7 += h3 * r4;
d7 += h4 * r3;
c = d7 >>> 13;
d7 &= 8191;
d7 += h5 * r2;
d7 += h6 * r1;
d7 += h7 * r0;
d7 += h8 * (5 * r9);
d7 += h9 * (5 * r8);
c += d7 >>> 13;
d7 &= 8191;
d8 = c;
d8 += h0 * r8;
d8 += h1 * r7;
d8 += h2 * r6;
d8 += h3 * r5;
d8 += h4 * r4;
c = d8 >>> 13;
d8 &= 8191;
d8 += h5 * r3;
d8 += h6 * r2;
d8 += h7 * r1;
d8 += h8 * r0;
d8 += h9 * (5 * r9);
c += d8 >>> 13;
d8 &= 8191;
d9 = c;
d9 += h0 * r9;
d9 += h1 * r8;
d9 += h2 * r7;
d9 += h3 * r6;
d9 += h4 * r5;
c = d9 >>> 13;
d9 &= 8191;
d9 += h5 * r4;
d9 += h6 * r3;
d9 += h7 * r2;
d9 += h8 * r1;
d9 += h9 * r0;
c += d9 >>> 13;
d9 &= 8191;
c = (c << 2) + c | 0;
c = c + d0 | 0;
d0 = c & 8191;
c = c >>> 13;
d1 += c;
h0 = d0;
h1 = d1;
h2 = d2;
h3 = d3;
h4 = d4;
h5 = d5;
h6 = d6;
h7 = d7;
h8 = d8;
h9 = d9;
mpos += 16;
bytes -= 16;
}
this.h[0] = h0;
this.h[1] = h1;
this.h[2] = h2;
this.h[3] = h3;
this.h[4] = h4;
this.h[5] = h5;
this.h[6] = h6;
this.h[7] = h7;
this.h[8] = h8;
this.h[9] = h9;
};
poly1305.prototype.finish = function(mac, macpos) {
var g = new Uint16Array(10);
var c, mask, f, i;
if (this.leftover) {
i = this.leftover;
this.buffer[i++] = 1;
for (; i < 16; i++) this.buffer[i] = 0;
this.fin = 1;
this.blocks(this.buffer, 0, 16);
}
c = this.h[1] >>> 13;
this.h[1] &= 8191;
for (i = 2; i < 10; i++) {
this.h[i] += c;
c = this.h[i] >>> 13;
this.h[i] &= 8191;
}
this.h[0] += c * 5;
c = this.h[0] >>> 13;
this.h[0] &= 8191;
this.h[1] += c;
c = this.h[1] >>> 13;
this.h[1] &= 8191;
this.h[2] += c;
g[0] = this.h[0] + 5;
c = g[0] >>> 13;
g[0] &= 8191;
for (i = 1; i < 10; i++) {
g[i] = this.h[i] + c;
c = g[i] >>> 13;
g[i] &= 8191;
}
g[9] -= 1 << 13;
mask = (c ^ 1) - 1;
for (i = 0; i < 10; i++) g[i] &= mask;
mask = ~mask;
for (i = 0; i < 10; i++) this.h[i] = this.h[i] & mask | g[i];
this.h[0] = (this.h[0] | this.h[1] << 13) & 65535;
this.h[1] = (this.h[1] >>> 3 | this.h[2] << 10) & 65535;
this.h[2] = (this.h[2] >>> 6 | this.h[3] << 7) & 65535;
this.h[3] = (this.h[3] >>> 9 | this.h[4] << 4) & 65535;
this.h[4] = (this.h[4] >>> 12 | this.h[5] << 1 | this.h[6] << 14) & 65535;
this.h[5] = (this.h[6] >>> 2 | this.h[7] << 11) & 65535;
this.h[6] = (this.h[7] >>> 5 | this.h[8] << 8) & 65535;
this.h[7] = (this.h[8] >>> 8 | this.h[9] << 5) & 65535;
f = this.h[0] + this.pad[0];
this.h[0] = f & 65535;
for (i = 1; i < 8; i++) {
f = (this.h[i] + this.pad[i] | 0) + (f >>> 16) | 0;
this.h[i] = f & 65535;
}
mac[macpos + 0] = this.h[0] >>> 0 & 255;
mac[macpos + 1] = this.h[0] >>> 8 & 255;
mac[macpos + 2] = this.h[1] >>> 0 & 255;
mac[macpos + 3] = this.h[1] >>> 8 & 255;
mac[macpos + 4] = this.h[2] >>> 0 & 255;
mac[macpos + 5] = this.h[2] >>> 8 & 255;
mac[macpos + 6] = this.h[3] >>> 0 & 255;
mac[macpos + 7] = this.h[3] >>> 8 & 255;
mac[macpos + 8] = this.h[4] >>> 0 & 255;
mac[macpos + 9] = this.h[4] >>> 8 & 255;
mac[macpos + 10] = this.h[5] >>> 0 & 255;
mac[macpos + 11] = this.h[5] >>> 8 & 255;
mac[macpos + 12] = this.h[6] >>> 0 & 255;
mac[macpos + 13] = this.h[6] >>> 8 & 255;
mac[macpos + 14] = this.h[7] >>> 0 & 255;
mac[macpos + 15] = this.h[7] >>> 8 & 255;
};
poly1305.prototype.update = function(m, mpos, bytes) {
var i, want;
if (this.leftover) {
want = 16 - this.leftover;
if (want > bytes)
want = bytes;
for (i = 0; i < want; i++)
this.buffer[this.leftover + i] = m[mpos + i];
bytes -= want;
mpos += want;
this.leftover += want;
if (this.leftover < 16)
return;
this.blocks(this.buffer, 0, 16);
this.leftover = 0;
}
if (bytes >= 16) {
want = bytes - bytes % 16;
this.blocks(m, mpos, want);
mpos += want;
bytes -= want;
}
if (bytes) {
for (i = 0; i < bytes; i++)
this.buffer[this.leftover + i] = m[mpos + i];
this.leftover += bytes;
}
};
function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
var s = new poly1305(k);
s.update(m, mpos, n);
s.finish(out, outpos);
return 0;
}
function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
var x = new Uint8Array(16);
crypto_onetimeauth(x, 0, m, mpos, n, k);
return crypto_verify_16(h, hpos, x, 0);
}
function crypto_secretbox(c, m, d, n, k) {
var i;
if (d < 32) return -1;
crypto_stream_xor(c, 0, m, 0, d, n, k);
crypto_onetimeauth(c, 16, c, 32, d - 32, c);
for (i = 0; i < 16; i++) c[i] = 0;
return 0;
}
function crypto_secretbox_open(m, c, d, n, k) {
var i;
var x = new Uint8Array(32);
if (d < 32) return -1;
crypto_stream(x, 0, 32, n, k);
if (crypto_onetimeauth_verify(c, 16, c, 32, d - 32, x) !== 0) return -1;
crypto_stream_xor(m, 0, c, 0, d, n, k);
for (i = 0; i < 32; i++) m[i] = 0;
return 0;
}
function set25519(r, a) {
var i;
for (i = 0; i < 16; i++) r[i] = a[i] | 0;
}
function car25519(o) {
var 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 sel25519(p, q, b) {
var t, c = ~(b - 1);
for (var i = 0; i < 16; i++) {
t = c & (p[i] ^ q[i]);
p[i] ^= t;
q[i] ^= t;
}
}
function pack25519(o, n) {
var i, j, b;
var 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] - 65517;
for (i = 1; i < 15; i++) {
m[i] = t[i] - 65535 - (m[i - 1] >> 16 & 1);
m[i - 1] &= 65535;
}
m[15] = t[15] - 32767 - (m[14] >> 16 & 1);
b = m[15] >> 16 & 1;
m[14] &= 65535;
sel25519(t, m, 1 - b);
}
for (i = 0; i < 16; i++) {
o[2 * i] = t[i] & 255;
o[2 * i + 1] = t[i] >> 8;
}
}
function neq25519(a, b) {
var c = new Uint8Array(32), d = new Uint8Array(32);
pack25519(c, a);
pack25519(d, b);
return crypto_verify_32(c, 0, d, 0);
}
function par25519(a) {
var d = new Uint8Array(32);
pack25519(d, a);
return d[0] & 1;
}
function unpack25519(o, n) {
var i;
for (i = 0; i < 16; i++) o[i] = n[2 * i] + (n[2 * i + 1] << 8);
o[15] &= 32767;
}
function A(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
}
function Z(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
}
function M(o, a, b) {
var 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, 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;
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);
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 inv25519(o, i) {
var c = gf();
var 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) {
var c = gf();
var 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 crypto_scalarmult(q, n, p) {
var z = new Uint8Array(32);
var x = new Float64Array(80), r, i;
var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf();
for (i = 0; i < 31; i++) z[i] = n[i];
z[31] = n[31] & 127 | 64;
z[0] &= 248;
unpack25519(x, p);
for (i = 0; i < 16; i++) {
b[i] = x[i];
d[i] = a[i] = c[i] = 0;
}
a[0] = d[0] = 1;
for (i = 254; i >= 0; --i) {
r = z[i >>> 3] >>> (i & 7) & 1;
sel25519(a, b, r);
sel25519(c, d, r);
A(e, a, c);
Z(a, a, c);
A(c, b, d);
Z(b, b, d);
S(d, e);
S(f, a);
M(a, c, a);
M(c, b, e);
A(e, a, c);
Z(a, a, c);
S(b, a);
Z(c, d, f);
M(a, c, _121665);
A(a, a, d);
M(c, c, a);
M(a, d, f);
M(d, b, x);
S(b, e);
sel25519(a, b, r);
sel25519(c, d, r);
}
for (i = 0; i < 16; i++) {
x[i + 16] = a[i];
x[i + 32] = c[i];
x[i + 48] = b[i];
x[i + 64] = d[i];
}
var x32 = x.subarray(32);
var x16 = x.subarray(16);
inv25519(x32, x32);
M(x16, x16, x32);
pack25519(q, x16);
return 0;
}
function crypto_scalarmult_base(q, n) {
return crypto_scalarmult(q, n, _9);
}
function crypto_box_keypair(y, x) {
randombytes3(x, 32);
return crypto_scalarmult_base(y, x);
}
function crypto_box_beforenm(k, y, x) {
var s = new Uint8Array(32);
crypto_scalarmult(s, x, y);
return crypto_core_hsalsa20(k, _0, s, sigma);
}
var crypto_box_afternm = crypto_secretbox;
var crypto_box_open_afternm = crypto_secretbox_open;
function crypto_box(c, m, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_afternm(c, m, d, n, k);
}
function crypto_box_open(m, c, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_open_afternm(m, c, d, n, k);
}
var K = [
1116352408,
3609767458,
1899447441,
602891725,
3049323471,
3964484399,
3921009573,
2173295548,
961987163,
4081628472,
1508970993,
3053834265,
2453635748,
2937671579,
2870763221,
3664609560,
3624381080,
2734883394,
310598401,
1164996542,
607225278,
1323610764,
1426881987,
3590304994,
1925078388,
4068182383,
2162078206,
991336113,
2614888103,
633803317,
3248222580,
3479774868,
3835390401,
2666613458,
4022224774,
944711139,
264347078,
2341262773,
604807628,
2007800933,
770255983,
1495990901,
1249150122,
1856431235,
1555081692,
3175218132,
1996064986,
2198950837,
2554220882,
3999719339,
2821834349,
766784016,
2952996808,
2566594879,
3210313671,
3203337956,
3336571891,
1034457026,
3584528711,
2466948901,
113926993,
3758326383,
338241895,
168717936,
666307205,
1188179964,
773529912,
1546045734,
1294757372,
1522805485,
1396182291,
2643833823,
1695183700,
2343527390,
1986661051,
1014477480,
2177026350,
1206759142,
2456956037,
344077627,
2730485921,
1290863460,
2820302411,
3158454273,
3259730800,
3505952657,
3345764771,
106217008,
3516065817,
3606008344,
3600352804,
1432725776,
4094571909,
1467031594,
275423344,
851169720,
430227734,
3100823752,
506948616,
1363258195,
659060556,
3750685593,
883997877,
3785050280,
958139571,
3318307427,
1322822218,
3812723403,
1537002063,
2003034995,
1747873779,
3602036899,
1955562222,
1575990012,
2024104815,
1125592928,
2227730452,
2716904306,
2361852424,
442776044,
2428436474,
593698344,
2756734187,
3733110249,
3204031479,
2999351573,
3329325298,
3815920427,
3391569614,
3928383900,
3515267271,
566280711,
3940187606,
3454069534,
4118630271,
4000239992,
116418474,
1914138554,
174292421,
2731055270,
289380356,
3203993006,
460393269,
320620315,
685471733,
587496836,
852142971,
1086792851,
1017036298,
365543100,
1126000580,
2618297676,
1288033470,
3409855158,
1501505948,
4234509866,
1607167915,
987167468,
1816402316,
1246189591
];
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;
h = ah7;
l = al7;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
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 & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
h = ah4 & ah5 ^ ~ah4 & ah6;
l = al4 & al5 ^ ~al4 & al6;
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
h = K[i * 2];
l = K[i * 2 + 1];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
h = wh[i % 16];
l = wl[i % 16];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
th = c & 65535 | d << 16;
tl = a & 65535 | b << 16;
h = th;
l = tl;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
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 & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
h = ah0 & ah1 ^ ah0 & ah2 ^ ah1 & ah2;
l = al0 & al1 ^ al0 & al2 ^ al1 & al2;
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
bh7 = c & 65535 | d << 16;
bl7 = a & 65535 | b << 16;
h = bh3;
l = bl3;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = th;
l = tl;
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
bh3 = c & 65535 | d << 16;
bl3 = a & 65535 | 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++) {
h = wh[j];
l = wl[j];
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = wh[(j + 9) % 16];
l = wl[(j + 9) % 16];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
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 & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
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 & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
wh[j] = c & 65535 | d << 16;
wl[j] = a & 65535 | b << 16;
}
}
}
h = ah0;
l = al0;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[0];
l = hl[0];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[0] = ah0 = c & 65535 | d << 16;
hl[0] = al0 = a & 65535 | b << 16;
h = ah1;
l = al1;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[1];
l = hl[1];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[1] = ah1 = c & 65535 | d << 16;
hl[1] = al1 = a & 65535 | b << 16;
h = ah2;
l = al2;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[2];
l = hl[2];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[2] = ah2 = c & 65535 | d << 16;
hl[2] = al2 = a & 65535 | b << 16;
h = ah3;
l = al3;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[3];
l = hl[3];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[3] = ah3 = c & 65535 | d << 16;
hl[3] = al3 = a & 65535 | b << 16;
h = ah4;
l = al4;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[4];
l = hl[4];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[4] = ah4 = c & 65535 | d << 16;
hl[4] = al4 = a & 65535 | b << 16;
h = ah5;
l = al5;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[5];
l = hl[5];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[5] = ah5 = c & 65535 | d << 16;
hl[5] = al5 = a & 65535 | b << 16;
h = ah6;
l = al6;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[6];
l = hl[6];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[6] = ah6 = c & 65535 | d << 16;
hl[6] = al6 = a & 65535 | b << 16;
h = ah7;
l = al7;
a = l & 65535;
b = l >>> 16;
c = h & 65535;
d = h >>> 16;
h = hh[7];
l = hl[7];
a += l & 65535;
b += l >>> 16;
c += h & 65535;
d += h >>> 16;
b += a >>> 16;
c += b >>> 16;
d += c >>> 16;
hh[7] = ah7 = c & 65535 | d << 16;
hl[7] = al7 = a & 65535 | b << 16;
pos += 128;
n -= 128;
}
return n;
}
function crypto_hash(out, m, n) {
var hh = new Int32Array(8), hl = new Int32Array(8), x = new Uint8Array(256), i, b = n;
hh[0] = 1779033703;
hh[1] = 3144134277;
hh[2] = 1013904242;
hh[3] = 2773480762;
hh[4] = 1359893119;
hh[5] = 2600822924;
hh[6] = 528734635;
hh[7] = 1541459225;
hl[0] = 4089235720;
hl[1] = 2227873595;
hl[2] = 4271175723;
hl[3] = 1595750129;
hl[4] = 2917565137;
hl[5] = 725511199;
hl[6] = 4215389547;
hl[7] = 327033209;
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 / 536870912 | 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 add2(p, q) {
var 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 cswap(p, q, b) {
var i;
for (i = 0; i < 4; i++) {
sel25519(p[i], q[i], b);
}
}
function pack(r, p) {
var 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 scalarmult(p, q, s) {
var 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);
add2(q, p);
add2(p, p);
cswap(p, q, b);
}
}
function scalarbase(p, s) {
var 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 crypto_sign_keypair(pk, sk, seeded) {
var d = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()];
var i;
if (!seeded) randombytes3(sk, 32);
crypto_hash(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;
}
var L = new Float64Array([237, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16]);
function modL(r, x) {
var carry, i, j, k;
for (i = 63; i >= 32; --i) {
carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
carry = Math.floor((x[j] + 128) / 256);
x[j] -= carry * 256;
}
x[j] += carry;
x[i] = 0;
}
carry = 0;
for (j = 0; j < 32; j++) {
x[j] += carry - (x[31] >> 4) * L[j];
carry = x[j] >> 8;
x[j] &= 255;
}
for (j = 0; j < 32; j++) x[j] -= carry * L[j];
for (i = 0; i < 32; i++) {
x[i + 1] += x[i] >> 8;
r[i] = x[i] & 255;
}
}
function reduce(r) {
var x = new Float64Array(64), i;
for (i = 0; i < 64; i++) x[i] = r[i];
for (i = 0; i < 64; i++) r[i] = 0;
modL(r, x);
}
function crypto_sign(sm, m, n, sk) {
var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
var i, j, x = new Float64Array(64);
var p = [gf(), gf(), gf(), gf()];
crypto_hash(d, sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
var smlen = n + 64;
for (i = 0; i < n; i++) sm[64 + i] = m[i];
for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
crypto_hash(r, sm.subarray(32), n + 32);
reduce(r);
scalarbase(p, r);
pack(sm, p);
for (i = 32; i < 64; i++) sm[i] = sk[i];
crypto_hash(h, sm, n + 64);
reduce(h);
for (i = 0; i < 64; i++) x[i] = 0;
for (i = 0; i < 32; i++) x[i] = r[i];
for (i = 0; i < 32; i++) {
for (j = 0; j < 32; j++) {
x[i + j] += h[i] * d[j];
}
}
modL(sm.subarray(32), x);
return smlen;
}
function unpackneg(r, p) {
var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
set25519(r[2], gf1);
unpack25519(r[1], p);
S(num, r[1]);
M(den, num, D);
Z(num, num, r[2]);
A(den, r[2], den);
S(den2, den);
S(den4, den2);
M(den6, den4, den2);
M(t, den6, num);
M(t, t, den);
pow2523(t, t);
M(t, t, num);
M(t, t, den);
M(t, t, den);
M(r[0], t, den);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) M(r[0], r[0], I);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) return -1;
if (par25519(r[0]) === p[31] >> 7) Z(r[0], gf0, r[0]);
M(r[3], r[0], r[1]);
return 0;
}
function crypto_sign_open(m, sm, n, pk) {
var i;
var t = new Uint8Array(32), h = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()], q = [gf(), gf(), gf(), gf()];
if (n < 64) return -1;
if (unpackneg(q, pk)) return -1;
for (i = 0; i < n; i++) m[i] = sm[i];
for (i = 0; i < 32; i++) m[i + 32] = pk[i];
crypto_hash(h, m, n);
reduce(h);
scalarmult(p, q, h);
scalarbase(q, sm.subarray(32));
add2(p, q);
pack(t, p);
n -= 64;
if (crypto_verify_32(sm, 0, t, 0)) {
for (i = 0; i < n; i++) m[i] = 0;
return -1;
}
for (i = 0; i < n; i++) m[i] = sm[i + 64];
return n;
}
var crypto_secretbox_KEYBYTES = 32, crypto_secretbox_NONCEBYTES = 24, crypto_secretbox_ZEROBYTES = 32, crypto_secretbox_BOXZEROBYTES = 16, crypto_scalarmult_BYTES = 32, crypto_scalarmult_SCALARBYTES = 32, crypto_box_PUBLICKEYBYTES = 32, crypto_box_SECRETKEYBYTES = 32, crypto_box_BEFORENMBYTES = 32, crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES, crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES, crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES, crypto_sign_BYTES = 64, crypto_sign_PUBLICKEYBYTES = 32, crypto_sign_SECRETKEYBYTES = 64, crypto_sign_SEEDBYTES = 32, crypto_hash_BYTES = 64;
nacl.lowlevel = {
crypto_core_hsalsa20,
crypto_stream_xor,
crypto_stream,
crypto_stream_salsa20_xor,
crypto_stream_salsa20,
crypto_onetimeauth,
crypto_onetimeauth_verify,
crypto_verify_16,
crypto_verify_32,
crypto_secretbox,
crypto_secretbox_open,
crypto_scalarmult,
crypto_scalarmult_base,
crypto_box_beforenm,
crypto_box_afternm,
crypto_box,
crypto_box_open,
crypto_box_keypair,
crypto_hash,
crypto_sign,
crypto_sign_keypair,
crypto_sign_open,
crypto_secretbox_KEYBYTES,
crypto_secretbox_NONCEBYTES,
crypto_secretbox_ZEROBYTES,
crypto_secretbox_BOXZEROBYTES,
crypto_scalarmult_BYTES,
crypto_scalarmult_SCALARBYTES,
crypto_box_PUBLICKEYBYTES,
crypto_box_SECRETKEYBYTES,
crypto_box_BEFORENMBYTES,
crypto_box_NONCEBYTES,
crypto_box_ZEROBYTES,
crypto_box_BOXZEROBYTES,
crypto_sign_BYTES,
crypto_sign_PUBLICKEYBYTES,
crypto_sign_SECRETKEYBYTES,
crypto_sign_SEEDBYTES,
crypto_hash_BYTES,
gf,
D,
L,
pack25519,
unpack25519,
M,
A,
S,
Z,
pow2523,
add: add2,
set25519,
modL,
scalarmult,
scalarbase
};
function checkLengths(k, n) {
if (k.length !== crypto_secretbox_KEYBYTES) throw new Error("bad key size");
if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error("bad nonce size");
}
function checkBoxLengths(pk, sk) {
if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error("bad public key size");
if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error("bad secret key size");
}
function checkArrayTypes() {
for (var i = 0; i < arguments.length; i++) {
if (!(arguments[i] instanceof Uint8Array))
throw new TypeError("unexpected type, use Uint8Array");
}
}
function cleanup(arr) {
for (var i = 0; i < arr.length; i++) arr[i] = 0;
}
nacl.randomBytes = function(n) {
var b = new Uint8Array(n);
randombytes3(b, n);
return b;
};
nacl.secretbox = function(msg, nonce, key) {
checkArrayTypes(msg, nonce, key);
checkLengths(key, nonce);
var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
var c = new Uint8Array(m.length);
for (var i = 0; i < msg.length; i++) m[i + crypto_secretbox_ZEROBYTES] = msg[i];
crypto_secretbox(c, m, m.length, nonce, key);
return c.subarray(crypto_secretbox_BOXZEROBYTES);
};
nacl.secretbox.open = function(box, nonce, key) {
checkArrayTypes(box, nonce, key);
checkLengths(key, nonce);
var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
var m = new Uint8Array(c.length);
for (var i = 0; i < box.length; i++) c[i + crypto_secretbox_BOXZEROBYTES] = box[i];
if (c.length < 32) return null;
if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
return m.subarray(crypto_secretbox_ZEROBYTES);
};
nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
nacl.scalarMult = function(n, p) {
checkArrayTypes(n, p);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error("bad n size");
if (p.length !== crypto_scalarmult_BYTES) throw new Error("bad p size");
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult(q, n, p);
return q;
};
nacl.scalarMult.base = function(n) {
checkArrayTypes(n);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error("bad n size");
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult_base(q, n);
return q;
};
nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
nacl.box = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox(msg, nonce, k);
};
nacl.box.before = function(publicKey, secretKey) {
checkArrayTypes(publicKey, secretKey);
checkBoxLengths(publicKey, secretKey);
var k = new Uint8Array(crypto_box_BEFORENMBYTES);
crypto_box_beforenm(k, publicKey, secretKey);
return k;
};
nacl.box.after = nacl.secretbox;
nacl.box.open = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox.open(msg, nonce, k);
};
nacl.box.open.after = nacl.secretbox.open;
nacl.box.keyPair = function() {
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
crypto_box_keypair(pk, sk);
return { publicKey: pk, secretKey: sk };
};
nacl.box.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_box_SECRETKEYBYTES)
throw new Error("bad secret key size");
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
crypto_scalarmult_base(pk, secretKey);
return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
};
nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
nacl.box.nonceLength = crypto_box_NONCEBYTES;
nacl.box.overheadLength = nacl.secretbox.overheadLength;
nacl.sign = function(msg, secretKey) {
checkArrayTypes(msg, secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error("bad secret key size");
var signedMsg = new Uint8Array(crypto_sign_BYTES + msg.length);
crypto_sign(signedMsg, msg, msg.length, secretKey);
return signedMsg;
};
nacl.sign.open = function(signedMsg, publicKey) {
checkArrayTypes(signedMsg, publicKey);
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error("bad public key size");
var tmp = new Uint8Array(signedMsg.length);
var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
if (mlen < 0) return null;
var m = new Uint8Array(mlen);
for (var i = 0; i < m.length; i++) m[i] = tmp[i];
return m;
};
nacl.sign.detached = function(msg, secretKey) {
var signedMsg = nacl.sign(msg, secretKey);
var sig = new Uint8Array(crypto_sign_BYTES);
for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
return sig;
};
nacl.sign.detached.verify = function(msg, sig, publicKey) {
checkArrayTypes(msg, sig, publicKey);
if (sig.length !== crypto_sign_BYTES)
throw new Error("bad signature size");
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error("bad public key size");
var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
var m = new Uint8Array(crypto_sign_BYTES + msg.length);
var i;
for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
for (i = 0; i < msg.length; i++) sm[i + crypto_sign_BYTES] = msg[i];
return crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
};
nacl.sign.keyPair = function() {
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
crypto_sign_keypair(pk, sk);
return { publicKey: pk, secretKey: sk };
};
nacl.sign.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error("bad secret key size");
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32 + i];
return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
};
nacl.sign.keyPair.fromSeed = function(seed) {
checkArrayTypes(seed);
if (seed.length !== crypto_sign_SEEDBYTES)
throw new Error("bad seed size");
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
for (var i = 0; i < 32; i++) sk[i] = seed[i];
crypto_sign_keypair(pk, sk, true);
return { publicKey: pk, secretKey: sk };
};
nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
nacl.sign.seedLength = crypto_sign_SEEDBYTES;
nacl.sign.signatureLength = crypto_sign_BYTES;
nacl.hash = function(msg) {
checkArrayTypes(msg);
var h = new Uint8Array(crypto_hash_BYTES);
crypto_hash(h, msg, msg.length);
return h;
};
nacl.hash.hashLength = crypto_hash_BYTES;
nacl.verify = function(x, y) {
checkArrayTypes(x, y);
if (x.length === 0 || y.length === 0) return false;
if (x.length !== y.length) return false;
return vn(x, 0, y, 0, x.length) === 0 ? true : false;
};
nacl.setPRNG = function(fn) {
randombytes3 = fn;
};
(function() {
var crypto4 = typeof self !== "undefined" ? self.crypto || self.msCrypto : null;
if (crypto4 && crypto4.getRandomValues) {
var QUOTA = 65536;
nacl.setPRNG(function(x, n) {
var i, v = new Uint8Array(n);
for (i = 0; i < n; i += QUOTA) {
crypto4.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
}
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
} else if (typeof require !== "undefined") {
crypto4 = require("crypto");
if (crypto4 && crypto4.randomBytes) {
nacl.setPRNG(function(x, n) {
var i, v = crypto4.randomBytes(n);
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
}
}
})();
})(typeof module2 !== "undefined" && module2.exports ? module2.exports : self.nacl = self.nacl || {});
}
});
// node_modules/near-hd-key/dist/utils.js
var require_utils = __commonJS({
"node_modules/near-hd-key/dist/utils.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.replaceDerive = exports2.pathRegex = void 0;
exports2.pathRegex = new RegExp("^m(\\/[0-9]+')+$");
exports2.replaceDerive = (val) => val.replace("'", "");
}
});
// node_modules/near-hd-key/dist/index.js
var require_dist = __commonJS({
"node_modules/near-hd-key/dist/index.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.derivePath = exports2.isValidPath = exports2.getPublicKey = exports2.getMasterKeyFromSeed = void 0;
var createHmac = require_create_hmac();
var nacl = require_nacl_fast();
var utils_1 = require_utils();
var ED25519_CURVE = "ed25519 seed";
var HARDENED_OFFSET = 2147483648;
exports2.getMasterKeyFromSeed = (seed) => {
const hmac = createHmac("sha512", ED25519_CURVE);
const I = hmac.update(Buffer.from(seed, "hex")).digest();
const IL = I.slice(0, 32);
const IR = I.slice(32);
return {
key: IL,
chainCode: IR
};
};
var CKDPriv = ({ key, chainCode }, index) => {
const indexBuffer = Buffer.allocUnsafe(4);
indexBuffer.writeUInt32BE(index, 0);
const data = Buffer.concat([Buffer.alloc(1, 0), key, indexBuffer]);
const I = createHmac("sha512", chainCode).update(data).digest();
const IL = I.slice(0, 32);
const IR = I.slice(32);
return {
key: IL,
chainCode: IR
};
};
exports2.getPublicKey = (privateKey, withZeroByte = true) => {
const keyPair = nacl.sign.keyPair.fromSeed(privateKey);
const signPk = keyPair.secretKey.subarray(32);
const zero = Buffer.alloc(1, 0);
return withZeroByte ? Buffer.concat([zero, Buffer.from(signPk)]) : Buffer.from(signPk);
};
exports2.isValidPath = (path) => {
if (!utils_1.pathRegex.test(path)) {
return false;
}
return !path.split("/").slice(1).map(utils_1.replaceDerive).some(isNaN);
};
exports2.derivePath = (path, seed, offset = HARDENED_OFFSET) => {
if (!exports2.isValidPath(path)) {
throw new Error("Invalid derivation path");
}
const { key, chainCode } = exports2.getMasterKeyFromSeed(seed);
const segments = path.split("/").slice(1).map(utils_1.replaceDerive).map((el) => parseInt(el, 10));
return segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), { key, chainCode });
};
}
});
// node_modules/near-seed-phrase/node_modules/base-x/src/index.js
var require_src = __commonJS({
"node_modules/near-seed-phrase/node_modules/base-x/src/index.js"(exports2, module2) {
"use strict";
var _Buffer = require_safe_buffer().Buffer;
function base(ALPHABET) {
if (ALPHABET.length >= 255) {
throw new TypeError("Alphabet too long");
}
var BASE_MAP = new Uint8Array(256);
for (var j = 0; j < BASE_MAP.length; j++) {
BASE_MAP[j] = 255;
}
for (var i = 0; i < ALPHABET.length; i++) {
var x = ALPHABET.charAt(i);
var xc = x.charCodeAt(0);
if (BASE_MAP[xc] !== 255) {
throw new TypeError(x + " is ambiguous");
}
BASE_MAP[xc] = i;
}
var BASE = ALPHABET.length;
var LEADER = ALPHABET.charAt(0);
var FACTOR = Math.log(BASE) / Math.log(256);
var iFACTOR = Math.log(256) / Math.log(BASE);
function encode(source) {
if (Array.isArray(source) || source instanceof Uint8Array) {
source = _Buffer.from(source);
}
if (!_Buffer.isBuffer(source)) {
throw new TypeError("Expected Buffer");
}
if (source.length === 0) {
return "";
}
var zeroes = 0;
var length = 0;
var pbegin = 0;
var pend = source.length;
while (pbegin !== pend && source[pbegin] === 0) {
pbegin++;
zeroes++;
}
var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
var b58 = new Uint8Array(size);
while (pbegin !== pend) {
var carry = source[pbegin];
var i2 = 0;
for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
carry += 256 * b58[it1] >>> 0;
b58[it1] = carry % BASE >>> 0;
carry = carry / BASE >>> 0;
}
if (carry !== 0) {
throw new Error("Non-zero carry");
}
length = i2;
pbegin++;
}
var it2 = size - length;
while (it2 !== size && b58[it2] === 0) {
it2++;
}
var str = LEADER.repeat(zeroes);
for (; it2 < size; ++it2) {
str += ALPHABET.charAt(b58[it2]);
}
return str;
}
function decodeUnsafe(source) {
if (typeof source !== "string") {
throw new TypeError("Expected String");
}
if (source.length === 0) {
return _Buffer.alloc(0);
}
var psz = 0;
var zeroes = 0;
var length = 0;
while (source[psz] === LEADER) {
zeroes++;
psz++;
}
var size = (source.length - psz) * FACTOR + 1 >>> 0;
var b256 = new Uint8Array(size);
while (psz < source.length) {
var charCode = source.charCodeAt(psz);
if (charCode > 255) {
return;
}
var carry = BASE_MAP[charCode];
if (carry === 255) {
return;
}
var i2 = 0;
for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
carry += BASE * b256[it3] >>> 0;
b256[it3] = carry % 256 >>> 0;
carry = carry / 256 >>> 0;
}
if (carry !== 0) {
throw new Error("Non-zero carry");
}
length = i2;
psz++;
}
var it4 = size - length;
while (it4 !== size && b256[it4] === 0) {
it4++;
}
var vch = _Buffer.allocUnsafe(zeroes + (size - it4));
vch.fill(0, 0, zeroes);
var j2 = zeroes;
while (it4 !== size) {
vch[j2++] = b256[it4++];
}
return vch;
}
function decode(string) {
var buffer = decodeUnsafe(string);
if (buffer) {
return buffer;
}
throw new Error("Non-base" + BASE + " character");
}
return {
encode,
decodeUnsafe,
decode
};
}
module2.exports = base;
}
});
// node_modules/near-seed-phrase/node_modules/bs58/index.js
var require_bs58 = __commonJS({
"node_modules/near-seed-phrase/node_modules/bs58/index.js"(exports2, module2) {
var basex = require_src();
var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
module2.exports = basex(ALPHABET);
}
});
// node_modules/near-seed-phrase/index.js
var require_near_seed_phrase = __commonJS({
"node_modules/near-seed-phrase/index.js"(exports2, module2) {
var bip39 = require_bip39_light();
var { derivePath } = require_dist();
var bs58 = require_bs58();
var nacl = require_nacl_fast();
var KEY_DERIVATION_PATH = "m/44'/397'/0'";
var generateSeedPhrase2 = (entropy) => {
return parseSeedPhrase2(entropy !== void 0 ? bip39.entropyToMnemonic(entropy) : bip39.generateMnemonic());
};
var normalizeSeedPhrase = (seedPhrase) => seedPhrase.trim().split(/\s+/).map((part) => part.toLowerCase()).join(" ");
var parseSeedPhrase2 = (seedPhrase, derivationPath) => {
const seed = bip39.mnemonicToSeed(normalizeSeedPhrase(seedPhrase));
const { key } = derivePath(derivationPath || KEY_DERIVATION_PATH, seed.toString("hex"));
const keyPair = nacl.sign.keyPair.fromSeed(key);
const publicKey = "ed25519:" + bs58.encode(Buffer.from(keyPair.publicKey));
const secretKey = "ed25519:" + bs58.encode(Buffer.from(keyPair.secretKey));
return { seedPhrase, secretKey, publicKey };
};
var findSeedPhraseKey = (seedPhrase, publicKeys) => {
const keyInfo = parseSeedPhrase2(seedPhrase);
if (publicKeys.indexOf(keyInfo.publicKey) < 0) {
return {};
}
return keyInfo;
};
module2.exports = {
KEY_DERIVATION_PATH,
generateSeedPhrase: generateSeedPhrase2,
normalizeSeedPhrase,
parseSeedPhrase: parseSeedPhrase2,
findSeedPhraseKey
};
}
});
// node_modules/mustache/mustache.js
var require_mustache = __commonJS({
"node_modules/mustache/mustache.js"(exports2, module2) {
(function(global2, factory) {
typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = global2 || self, global2.Mustache = factory());
})(exports2, function() {
"use strict";
var objectToString = Object.prototype.toString;
var isArray = Array.isArray || function isArrayPolyfill(object) {
return objectToString.call(object) === "[object Array]";
};
function isFunction(object) {
return typeof object === "function";
}
function typeStr(obj) {
return isArray(obj) ? "array" : typeof obj;
}
function escapeRegExp(string) {
return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
}
function hasProperty(obj, propName) {
return obj != null && typeof obj === "object" && propName in obj;
}
function primitiveHasOwnProperty(primitive, propName) {
return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
}
var regExpTest = RegExp.prototype.test;
function testRegExp(re, string) {
return regExpTest.call(re, string);
}
var nonSpaceRe = /\S/;
function isWhitespace(string) {
return !testRegExp(nonSpaceRe, string);
}
var entityMap = {
"&": "&",
"<": "<",
">": ">",
'"': """,
"'": "'",
"/": "/",
"`": "`",
"=": "="
};
function escapeHtml(string) {
return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap(s) {
return entityMap[s];
});
}
var whiteRe = /\s*/;
var spaceRe = /\s+/;
var equalsRe = /\s*=/;
var curlyRe = /\s*\}/;
var tagRe = /#|\^|\/|>|\{|&|=|!/;
function parseTemplate(template, tags) {
if (!template)
return [];
var lineHasNonSpace = false;
var sections = [];
var tokens = [];
var spaces = [];
var hasTag = false;
var nonSpace = false;
var indentation = "";
var tagIndex = 0;
function stripSpace() {
if (hasTag && !nonSpace) {
while (spaces.length)
delete tokens[spaces.pop()];
} else {
spaces = [];
}
hasTag = false;
nonSpace = false;
}
var openingTagRe, closingTagRe, closingCurlyRe;
function compileTags(tagsToCompile) {
if (typeof tagsToCompile === "string")
tagsToCompile = tagsToCompile.split(spaceRe, 2);
if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
throw new Error("Invalid tags: " + tagsToCompile);
openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + "\\s*");
closingTagRe = new RegExp("\\s*" + escapeRegExp(tagsToCompile[1]));
closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + tagsToCompile[1]));
}
compileTags(tags || mustache.tags);
var scanner = new Scanner(template);
var start, type, value, chr, token, openSection;
while (!scanner.eos()) {
start = scanner.pos;
value = scanner.scanUntil(openingTagRe);
if (value) {
for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
chr = value.charAt(i);
if (isWhitespace(chr)) {
spaces.push(tokens.length);
indentation += chr;
} else {
nonSpace = true;
lineHasNonSpace = true;
indentation += " ";
}
tokens.push(["text", chr, start, start + 1]);
start += 1;
if (chr === "\n") {
stripSpace();
indentation = "";
tagIndex = 0;
lineHasNonSpace = false;
}
}
}
if (!scanner.scan(openingTagRe))
break;
hasTag = true;
type = scanner.scan(tagRe) || "name";
scanner.scan(whiteRe);
if (type === "=") {
value = scanner.scanUntil(equalsRe);
scanner.scan(equalsRe);
scanner.scanUntil(closingTagRe);
} else if (type === "{") {
value = scanner.scanUntil(closingCurlyRe);
scanner.scan(curlyRe);
scanner.scanUntil(closingTagRe);
type = "&";
} else {
value = scanner.scanUntil(closingTagRe);
}
if (!scanner.scan(closingTagRe))
throw new Error("Unclosed tag at " + scanner.pos);
if (type == ">") {
token = [type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace];
} else {
token = [type, value, start, scanner.pos];
}
tagIndex++;
tokens.push(token);
if (type === "#" || type === "^") {
sections.push(token);
} else if (type === "/") {
openSection = sections.pop();
if (!openSection)
throw new Error('Unopened section "' + value + '" at ' + start);
if (openSection[1] !== value)
throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
} else if (type === "name" || type === "{" || type === "&") {
nonSpace = true;
} else if (type === "=") {
compileTags(value);
}
}
stripSpace();
openSection = sections.pop();
if (openSection)
throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
return nestTokens(squashTokens(tokens));
}
function squashTokens(tokens) {
var squashedTokens = [];
var token, lastToken;
for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
token = tokens[i];
if (token) {
if (token[0] === "text" && lastToken && lastToken[0] === "text") {
lastToken[1] += token[1];
lastToken[3] = token[3];
} else {
squashedTokens.push(token);
lastToken = token;
}
}
}
return squashedTokens;
}
function nestTokens(tokens) {
var nestedTokens = [];
var collector = nestedTokens;
var sections = [];
var token, section;
for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
token = tokens[i];
switch (token[0]) {
case "#":
case "^":
collector.push(token);
sections.push(token);
collector = token[4] = [];
break;
case "/":
section = sections.pop();
section[5] = token[2];
collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
break;
default:
collector.push(token);
}
}
return nestedTokens;
}
function Scanner(string) {
this.string = string;
this.tail = string;
this.pos = 0;
}
Scanner.prototype.eos = function eos() {
return this.tail === "";
};
Scanner.prototype.scan = function scan(re) {
var match = this.tail.match(re);
if (!match || match.index !== 0)
return "";
var string = match[0];
this.tail = this.tail.substring(string.length);
this.pos += string.length;
return string;
};
Scanner.prototype.scanUntil = function scanUntil(re) {
var index = this.tail.search(re), match;
switch (index) {
case -1:
match = this.tail;
this.tail = "";
break;
case 0:
match = "";
break;
default:
match = this.tail.substring(0, index);
this.tail = this.tail.substring(index);
}
this.pos += match.length;
return match;
};
function Context(view, parentContext) {
this.view = view;
this.cache = { ".": this.view };
this.parent = parentContext;
}
Context.prototype.push = function push(view) {
return new Context(view, this);
};
Context.prototype.lookup = function lookup(name) {
var cache = this.cache;
var value;
if (cache.hasOwnProperty(name)) {
value = cache[name];
} else {
var context = this, intermediateValue, names, index, lookupHit = false;
while (context) {
if (name.indexOf(".") > 0) {
intermediateValue = context.view;
names = name.split(".");
index = 0;
while (intermediateValue != null && index < names.length) {
if (index === names.length - 1)
lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
intermediateValue = intermediateValue[names[index++]];
}
} else {
intermediateValue = context.view[name];
lookupHit = hasProperty(context.view, name);
}
if (lookupHit) {
value = intermediateValue;
break;
}
context = context.parent;
}
cache[name] = value;
}
if (isFunction(value))
value = value.call(this.view);
return value;
};
function Writer() {
this.templateCache = {
_cache: {},
set: function set(key, value) {
this._cache[key] = value;
},
get: function get(key) {
return this._cache[key];
},
clear: function clear() {
this._cache = {};
}
};
}
Writer.prototype.clearCache = function clearCache() {
if (typeof this.templateCache !== "undefined") {
this.templateCache.clear();
}
};
Writer.prototype.parse = function parse(template, tags) {
var cache = this.templateCache;
var cacheKey = template + ":" + (tags || mustache.tags).join(":");
var isCacheEnabled = typeof cache !== "undefined";
var tokens = isCacheEnabled ? cache.get(cacheKey) : void 0;
if (tokens == void 0) {
tokens = parseTemplate(template, tags);
isCacheEnabled && cache.set(cacheKey, tokens);
}
return tokens;
};
Writer.prototype.render = function render(template, view, partials, tags) {
var tokens = this.parse(template, tags);
var context = view instanceof Context ? view : new Context(view, void 0);
return this.renderTokens(tokens, context, partials, template, tags);
};
Writer.prototype.renderTokens = function renderTokens(tokens, context, partials, originalTemplate, tags) {
var buffer = "";
var token, symbol, value;
for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
value = void 0;
token = tokens[i];
symbol = token[0];
if (symbol === "#") value = this.renderSection(token, context, partials, originalTemplate);
else if (symbol === "^") value = this.renderInverted(token, context, partials, originalTemplate);
else if (symbol === ">") value = this.renderPartial(token, context, partials, tags);
else if (symbol === "&") value = this.unescapedValue(token, context);
else if (symbol === "name") value = this.escapedValue(token, context);
else if (symbol === "text") value = this.rawValue(token);
if (value !== void 0)
buffer += value;
}
return buffer;
};
Writer.prototype.renderSection = function renderSection(token, context, partials, originalTemplate) {
var self2 = this;
var buffer = "";
var value = context.lookup(token[1]);
function subRender(template) {
return self2.render(template, context, partials);
}
if (!value) return;
if (isArray(value)) {
for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate);
}
} else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate);
} else if (isFunction(value)) {
if (typeof originalTemplate !== "string")
throw new Error("Cannot use higher-order sections without the original template");
value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
if (value != null)
buffer += value;
} else {
buffer += this.renderTokens(token[4], context, partials, originalTemplate);
}
return buffer;
};
Writer.prototype.renderInverted = function renderInverted(token, context, partials, originalTemplate) {
var value = context.lookup(token[1]);
if (!value || isArray(value) && value.length === 0)
return this.renderTokens(token[4], context, partials, originalTemplate);
};
Writer.prototype.indentPartial = function indentPartial(partial, indentation, lineHasNonSpace) {
var filteredIndentation = indentation.replace(/[^ \t]/g, "");
var partialByNl = partial.split("\n");
for (var i = 0; i < partialByNl.length; i++) {
if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {
partialByNl[i] = filteredIndentation + partialByNl[i];
}
}
return partialByNl.join("\n");
};
Writer.prototype.renderPartial = function renderPartial(token, context, partials, tags) {
if (!partials) return;
var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
if (value != null) {
var lineHasNonSpace = token[6];
var tagIndex = token[5];
var indentation = token[4];
var indentedValue = value;
if (tagIndex == 0 && indentation) {
indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
}
return this.renderTokens(this.parse(indentedValue, tags), context, partials, indentedValue);
}
};
Writer.prototype.unescapedValue = function unescapedValue(token, context) {
var value = context.lookup(token[1]);
if (value != null)
return value;
};
Writer.prototype.escapedValue = function escapedValue(token, context) {
var value = context.lookup(token[1]);
if (value != null)
return mustache.escape(value);
};
Writer.prototype.rawValue = function rawValue(token) {
return token[1];
};
var mustache = {
name: "mustache.js",
version: "4.0.0",
tags: ["{{", "}}"],
clearCache: void 0,
escape: void 0,
parse: void 0,
render: void 0,
Scanner: void 0,
Context: void 0,
Writer: void 0,
/**
* Allows a user to override the default caching strategy, by providing an
* object with set, get and clear methods. This can also be used to disable
* the cache by setting it to the literal `undefined`.
*/
set templateCache(cache) {
defaultWriter.templateCache = cache;
},
/**
* Gets the default or overridden caching object from the default writer.
*/
get templateCache() {
return defaultWriter.templateCache;
}
};
var defaultWriter = new Writer();
mustache.clearCache = function clearCache() {
return defaultWriter.clearCache();
};
mustache.parse = function parse(template, tags) {
return defaultWriter.parse(template, tags);
};
mustache.render = function render(template, view, partials, tags) {
if (typeof template !== "string") {
throw new TypeError('Invalid template! Template should be a "string" but "' + typeStr(template) + '" was given as the first argument for mustache#render(template, view, partials)');
}
return defaultWriter.render(template, view, partials, tags);
};
mustache.escape = escapeHtml;
mustache.Scanner = Scanner;
mustache.Context = Context;
mustache.Writer = Writer;
return mustache;
});
}
});
// node_modules/depd/index.js
var require_depd = __commonJS({
"node_modules/depd/index.js"(exports2, module2) {
var relative = require("path").relative;
module2.exports = depd3;
var basePath = process.cwd();
function containsNamespace(str, namespace) {
var vals = str.split(/[ ,]+/);
var ns = String(namespace).toLowerCase();
for (var i = 0; i < vals.length; i++) {
var val = vals[i];
if (val && (val === "*" || val.toLowerCase() === ns)) {
return true;
}
}
return false;
}
function convertDataDescriptorToAccessor(obj, prop, message) {
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
var value = descriptor.value;
descriptor.get = function getter() {
return value;
};
if (descriptor.writable) {
descriptor.set = function setter(val) {
return value = val;
};
}
delete descriptor.value;
delete descriptor.writable;
Object.defineProperty(obj, prop, descriptor);
return descriptor;
}
function createArgumentsString(arity) {
var str = "";
for (var i = 0; i < arity; i++) {
str += ", arg" + i;
}
return str.substr(2);
}
function createStackString(stack) {
var str = this.name + ": " + this.namespace;
if (this.message) {
str += " deprecated " + this.message;
}
for (var i = 0; i < stack.length; i++) {
str += "\n at " + stack[i].toString();
}
return str;
}
function depd3(namespace) {
if (!namespace) {
throw new TypeError("argument namespace is required");
}
var stack = getStack();
var site = callSiteLocation(stack[1]);
var file = site[0];
function deprecate(message) {
log.call(deprecate, message);
}
deprecate._file = file;
deprecate._ignored = isignored(namespace);
deprecate._namespace = namespace;
deprecate._traced = istraced(namespace);
deprecate._warned = /* @__PURE__ */ Object.create(null);
deprecate.function = wrapfunction;
deprecate.property = wrapproperty;
return deprecate;
}
function eehaslisteners(emitter, type) {
var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
return count > 0;
}
function isignored(namespace) {
if (process.noDeprecation) {
return true;
}
var str = process.env.NO_DEPRECATION || "";
return containsNamespace(str, namespace);
}
function istraced(namespace) {
if (process.traceDeprecation) {
return true;
}
var str = process.env.TRACE_DEPRECATION || "";
return containsNamespace(str, namespace);
}
function log(message, site) {
var haslisteners = eehaslisteners(process, "deprecation");
if (!haslisteners && this._ignored) {
return;
}
var caller;
var callFile;
var callSite;
var depSite;
var i = 0;
var seen = false;
var stack = getStack();
var file = this._file;
if (site) {
depSite = site;
callSite = callSiteLocation(stack[1]);
callSite.name = depSite.name;
file = callSite[0];
} else {
i = 2;
depSite = callSiteLocation(stack[i]);
callSite = depSite;
}
for (; i < stack.length; i++) {
caller = callSiteLocation(stack[i]);
callFile = caller[0];
if (callFile === file) {
seen = true;
} else if (callFile === this._file) {
file = this._file;
} else if (seen) {
break;
}
}
var key = caller ? depSite.join(":") + "__" + caller.join(":") : void 0;
if (key !== void 0 && key in this._warned) {
return;
}
this._warned[key] = true;
var msg = message;
if (!msg) {
msg = callSite === depSite || !callSite.name ? defaultMessage(depSite) : defaultMessage(callSite);
}
if (haslisteners) {
var err = DeprecationError(this._namespace, msg, stack.slice(i));
process.emit("deprecation", err);
return;
}
var format = process.stderr.isTTY ? formatColor : formatPlain;
var output = format.call(this, msg, caller, stack.slice(i));
process.stderr.write(output + "\n", "utf8");
}
function callSiteLocation(callSite) {
var file = callSite.getFileName() || "<anonymous>";
var line = callSite.getLineNumber();
var colm = callSite.getColumnNumber();
if (callSite.isEval()) {
file = callSite.getEvalOrigin() + ", " + file;
}
var site = [file, line, colm];
site.callSite = callSite;
site.name = callSite.getFunctionName();
return site;
}
function defaultMessage(site) {
var callSite = site.callSite;
var funcName = site.name;
if (!funcName) {
funcName = "<anonymous@" + formatLocation(site) + ">";
}
var context = callSite.getThis();
var typeName = context && callSite.getTypeName();
if (typeName === "Object") {
typeName = void 0;
}
if (typeName === "Function") {
typeName = context.name || typeName;
}
return typeName && callSite.getMethodName() ? typeName + "." + funcName : funcName;
}
function formatPlain(msg, caller, stack) {
var timestamp = (/* @__PURE__ */ new Date()).toUTCString();
var formatted = timestamp + " " + this._namespace + " deprecated " + msg;
if (this._traced) {
for (var i = 0; i < stack.length; i++) {
formatted += "\n at " + stack[i].toString();
}
return formatted;
}
if (caller) {
formatted += " at " + formatLocation(caller);
}
return formatted;
}
function formatColor(msg, caller, stack) {
var formatted = "\x1B[36;1m" + this._namespace + "\x1B[22;39m \x1B[33;1mdeprecated\x1B[22;39m \x1B[0m" + msg + "\x1B[39m";
if (this._traced) {
for (var i = 0; i < stack.length; i++) {
formatted += "\n \x1B[36mat " + stack[i].toString() + "\x1B[39m";
}
return formatted;
}
if (caller) {
formatted += " \x1B[36m" + formatLocation(caller) + "\x1B[39m";
}
return formatted;
}
function formatLocation(callSite) {
return relative(basePath, callSite[0]) + ":" + callSite[1] + ":" + callSite[2];
}
function getStack() {
var limit = Error.stackTraceLimit;
var obj = {};
var prep = Error.prepareStackTrace;
Error.prepareStackTrace = prepareObjectStackTrace;
Error.stackTraceLimit = Math.max(10, limit);
Error.captureStackTrace(obj);
var stack = obj.stack.slice(1);
Error.prepareStackTrace = prep;
Error.stackTraceLimit = limit;
return stack;
}
function prepareObjectStackTrace(obj, stack) {
return stack;
}
function wrapfunction(fn, message) {
if (typeof fn !== "function") {
throw new TypeError("argument fn must be a function");
}
var args = createArgumentsString(fn.length);
var stack = getStack();
var site = callSiteLocation(stack[1]);
site.name = fn.name;
var deprecatedfn = new Function(
"fn",
"log",
"deprecate",
"message",
"site",
'"use strict"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}"
)(fn, log, this, message, site);
return deprecatedfn;
}
function wrapproperty(obj, prop, message) {
if (!obj || typeof obj !== "object" && typeof obj !== "function") {
throw new TypeError("argument obj must be object");
}
var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
if (!descriptor) {
throw new TypeError("must call property on owner object");
}
if (!descriptor.configurable) {
throw new TypeError("property must be configurable");
}
var deprecate = this;
var stack = getStack();
var site = callSiteLocation(stack[1]);
site.name = prop;
if ("value" in descriptor) {
descriptor = convertDataDescriptorToAccessor(obj, prop, message);
}
var get = descriptor.get;
var set = descriptor.set;
if (typeof get === "function") {
descriptor.get = function getter() {
log.call(deprecate, message, site);
return get.apply(this, arguments);
};
}
if (typeof set === "function") {
descriptor.set = function setter() {
log.call(deprecate, message, site);
return set.apply(this, arguments);
};
}
Object.defineProperty(obj, prop, descriptor);
}
function DeprecationError(namespace, message, stack) {
var error = new Error();
var stackString;
Object.defineProperty(error, "constructor", {
value: DeprecationError
});
Object.defineProperty(error, "message", {
configurable: true,
enumerable: false,
value: message,
writable: true
});
Object.defineProperty(error, "name", {
enumerable: false,
configurable: true,
value: "DeprecationError",
writable: true
});
Object.defineProperty(error, "namespace", {
configurable: true,
enumerable: false,
value: namespace,
writable: true
});
Object.defineProperty(error, "stack", {
configurable: true,
enumerable: false,
get: function() {
if (stackString !== void 0) {
return stackString;
}
return stackString = createStackString.call(this, stack);
},
set: function setter(val) {
stackString = val;
}
});
return error;
}
}
});
// node_modules/randombytes/index.js
var require_randombytes = __commonJS({
"node_modules/randombytes/index.js"(exports2, module2) {
module2.exports = require("crypto").randomBytes;
}
});
// node_modules/node-gyp-build/node-gyp-build.js
var require_node_gyp_build = __commonJS({
"node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
var fs = require("fs");
var path = require("path");
var os = require("os");
var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
var vars = process.config && process.config.variables || {};
var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
var abi = process.versions.modules;
var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
var arch = process.env.npm_config_arch || os.arch();
var platform = process.env.npm_config_platform || os.platform();
var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
var uv = (process.versions.uv || "").split(".")[0];
module2.exports = load;
function load(dir) {
return runtimeRequire(load.resolve(dir));
}
load.resolve = load.path = function(dir) {
dir = path.resolve(dir || ".");
try {
var name = runtimeRequire(path.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
} catch (err) {
}
if (!prebuildsOnly) {
var release = getFirst(path.join(dir, "build/Release"), matchBuild);
if (release) return release;
var debug = getFirst(path.join(dir, "build/Debug"), matchBuild);
if (debug) return debug;
}
var prebuild = resolve(dir);
if (prebuild) return prebuild;
var nearby = resolve(path.dirname(process.execPath));
if (nearby) return nearby;
var target = [
"platform=" + platform,
"arch=" + arch,
"runtime=" + runtime,
"abi=" + abi,
"uv=" + uv,
armv ? "armv=" + armv : "",
"libc=" + libc,
"node=" + process.versions.node,
process.versions.electron ? "electron=" + process.versions.electron : "",
typeof __webpack_require__ === "function" ? "webpack=true" : ""
// eslint-disable-line
].filter(Boolean).join(" ");
throw new Error("No native build was found for " + target + "\n loaded from: " + dir + "\n");
function resolve(dir2) {
var tuples = readdirSync(path.join(dir2, "prebuilds")).map(parseTuple);
var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
if (!tuple) return;
var prebuilds = path.join(dir2, "prebuilds", tuple.name);
var parsed = readdirSync(prebuilds).map(parseTags);
var candidates = parsed.filter(matchTags(runtime, abi));
var winner = candidates.sort(compareTags(runtime))[0];
if (winner) return path.join(prebuilds, winner.file);
}
};
function readdirSync(dir) {
try {
return fs.readdirSync(dir);
} catch (err) {
return [];
}
}
function getFirst(dir, filter) {
var files = readdirSync(dir).filter(filter);
return files[0] && path.join(dir, files[0]);
}
function matchBuild(name) {
return /\.node$/.test(name);
}
function parseTuple(name) {
var arr = name.split("-");
if (arr.length !== 2) return;
var platform2 = arr[0];
var architectures = arr[1].split("+");
if (!platform2) return;
if (!architectures.length) return;
if (!architectures.every(Boolean)) return;
return { name, platform: platform2, architectures };
}
function matchTuple(platform2, arch2) {
return function(tuple) {
if (tuple == null) return false;
if (tuple.platform !== platform2) return false;
return tuple.architectures.includes(arch2);
};
}
function compareTuples(a, b) {
return a.architectures.length - b.architectures.length;
}
function parseTags(file) {
var arr = file.split(".");
var extension = arr.pop();
var tags = { file, specificity: 0 };
if (extension !== "node") return;
for (var i = 0; i < arr.length; i++) {
var tag = arr[i];
if (tag === "node" || tag === "electron" || tag === "node-webkit") {
tags.runtime = tag;
} else if (tag === "napi") {
tags.napi = true;
} else if (tag.slice(0, 3) === "abi") {
tags.abi = tag.slice(3);
} else if (tag.slice(0, 2) === "uv") {
tags.uv = tag.slice(2);
} else if (tag.slice(0, 4) === "armv") {
tags.armv = tag.slice(4);
} else if (tag === "glibc" || tag === "musl") {
tags.libc = tag;
} else {
continue;
}
tags.specificity++;
}
return tags;
}
function matchTags(runtime2, abi2) {
return function(tags) {
if (tags == null) return false;
if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
if (tags.uv && tags.uv !== uv) return false;
if (tags.armv && tags.armv !== armv) return false;
if (tags.libc && tags.libc !== libc) return false;
return true;
};
}
function runtimeAgnostic(tags) {
return tags.runtime === "node" && tags.napi;
}
function compareTags(runtime2) {
return function(a, b) {
if (a.runtime !== b.runtime) {
return a.runtime === runtime2 ? -1 : 1;
} else if (a.abi !== b.abi) {
return a.abi ? -1 : 1;
} else if (a.specificity !== b.specificity) {
return a.specificity > b.specificity ? -1 : 1;
} else {
return 0;
}
};
}
function isNwjs() {
return !!(process.versions && process.versions.nw);
}
function isElectron() {
if (process.versions && process.versions.electron) return true;
if (process.env.ELECTRON_RUN_AS_NODE) return true;
return typeof window !== "undefined" && window.process && window.process.type === "renderer";
}
function isAlpine(platform2) {
return platform2 === "linux" && fs.existsSync("/etc/alpine-release");
}
load.parseTags = parseTags;
load.matchTags = matchTags;
load.compareTags = compareTags;
load.parseTuple = parseTuple;
load.matchTuple = matchTuple;
load.compareTuples = compareTuples;
}
});
// node_modules/node-gyp-build/index.js
var require_node_gyp_build2 = __commonJS({
"node_modules/node-gyp-build/index.js"(exports2, module2) {
var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
if (typeof runtimeRequire.addon === "function") {
module2.exports = runtimeRequire.addon.bind(runtimeRequire);
} else {
module2.exports = require_node_gyp_build();
}
}
});
// node_modules/secp256k1/lib/index.js
var require_lib = __commonJS({
"node_modules/secp256k1/lib/index.js"(exports2, module2) {
var errors = {
IMPOSSIBLE_CASE: "Impossible case. Please create issue.",
TWEAK_ADD: "The tweak was out of range or the resulted private key is invalid",
TWEAK_MUL: "The tweak was out of range or equal to zero",
CONTEXT_RANDOMIZE_UNKNOW: "Unknow error on context randomization",
SECKEY_INVALID: "Private Key is invalid",
PUBKEY_PARSE: "Public Key could not be parsed",
PUBKEY_SERIALIZE: "Public Key serialization error",
PUBKEY_COMBINE: "The sum of the public keys is not valid",
SIG_PARSE: "Signature could not be parsed",
SIGN: "The nonce generation function failed, or the private key was invalid",
RECOVER: "Public key could not be recover",
ECDH: "Scalar was invalid (zero or overflow)"
};
function assert(cond, msg) {
if (!cond) throw new Error(msg);
}
function isUint8Array(name, value, length) {
assert(value instanceof Uint8Array, `Expected ${name} to be an Uint8Array`);
if (length !== void 0) {
if (Array.isArray(length)) {
const numbers = length.join(", ");
const msg = `Expected ${name} to be an Uint8Array with length [${numbers}]`;
assert(length.includes(value.length), msg);
} else {
const msg = `Expected ${name} to be an Uint8Array with length ${length}`;
assert(value.length === length, msg);
}
}
}
function isCompressed(value) {
assert(toTypeString(value) === "Boolean", "Expected compressed to be a Boolean");
}
function getAssertedOutput(output = (len) => new Uint8Array(len), length) {
if (typeof output === "function") output = output(length);
isUint8Array("output", output, length);
return output;
}
function toTypeString(value) {
return Object.prototype.toString.call(value).slice(8, -1);
}
module2.exports = (secp256k13) => {
return {
contextRandomize(seed) {
assert(
seed === null || seed instanceof Uint8Array,
"Expected seed to be an Uint8Array or null"
);
if (seed !== null) isUint8Array("seed", seed, 32);
switch (secp256k13.contextRandomize(seed)) {
case 1:
throw new Error(errors.CONTEXT_RANDOMIZE_UNKNOW);
}
},
privateKeyVerify(seckey) {
isUint8Array("private key", seckey, 32);
return secp256k13.privateKeyVerify(seckey) === 0;
},
privateKeyNegate(seckey) {
isUint8Array("private key", seckey, 32);
switch (secp256k13.privateKeyNegate(seckey)) {
case 0:
return seckey;
case 1:
throw new Error(errors.IMPOSSIBLE_CASE);
}
},
privateKeyTweakAdd(seckey, tweak) {
isUint8Array("private key", seckey, 32);
isUint8Array("tweak", tweak, 32);
switch (secp256k13.privateKeyTweakAdd(seckey, tweak)) {
case 0:
return seckey;
case 1:
throw new Error(errors.TWEAK_ADD);
}
},
privateKeyTweakMul(seckey, tweak) {
isUint8Array("private key", seckey, 32);
isUint8Array("tweak", tweak, 32);
switch (secp256k13.privateKeyTweakMul(seckey, tweak)) {
case 0:
return seckey;
case 1:
throw new Error(errors.TWEAK_MUL);
}
},
publicKeyVerify(pubkey) {
isUint8Array("public key", pubkey, [33, 65]);
return secp256k13.publicKeyVerify(pubkey) === 0;
},
publicKeyCreate(seckey, compressed = true, output) {
isUint8Array("private key", seckey, 32);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyCreate(output, seckey)) {
case 0:
return output;
case 1:
throw new Error(errors.SECKEY_INVALID);
case 2:
throw new Error(errors.PUBKEY_SERIALIZE);
}
},
publicKeyConvert(pubkey, compressed = true, output) {
isUint8Array("public key", pubkey, [33, 65]);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyConvert(output, pubkey)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.PUBKEY_SERIALIZE);
}
},
publicKeyNegate(pubkey, compressed = true, output) {
isUint8Array("public key", pubkey, [33, 65]);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyNegate(output, pubkey)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.IMPOSSIBLE_CASE);
case 3:
throw new Error(errors.PUBKEY_SERIALIZE);
}
},
publicKeyCombine(pubkeys, compressed = true, output) {
assert(Array.isArray(pubkeys), "Expected public keys to be an Array");
assert(pubkeys.length > 0, "Expected public keys array will have more than zero items");
for (const pubkey of pubkeys) {
isUint8Array("public key", pubkey, [33, 65]);
}
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyCombine(output, pubkeys)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.PUBKEY_COMBINE);
case 3:
throw new Error(errors.PUBKEY_SERIALIZE);
}
},
publicKeyTweakAdd(pubkey, tweak, compressed = true, output) {
isUint8Array("public key", pubkey, [33, 65]);
isUint8Array("tweak", tweak, 32);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyTweakAdd(output, pubkey, tweak)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.TWEAK_ADD);
}
},
publicKeyTweakMul(pubkey, tweak, compressed = true, output) {
isUint8Array("public key", pubkey, [33, 65]);
isUint8Array("tweak", tweak, 32);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.publicKeyTweakMul(output, pubkey, tweak)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.TWEAK_MUL);
}
},
signatureNormalize(sig) {
isUint8Array("signature", sig, 64);
switch (secp256k13.signatureNormalize(sig)) {
case 0:
return sig;
case 1:
throw new Error(errors.SIG_PARSE);
}
},
signatureExport(sig, output) {
isUint8Array("signature", sig, 64);
output = getAssertedOutput(output, 72);
const obj = { output, outputlen: 72 };
switch (secp256k13.signatureExport(obj, sig)) {
case 0:
return output.slice(0, obj.outputlen);
case 1:
throw new Error(errors.SIG_PARSE);
case 2:
throw new Error(errors.IMPOSSIBLE_CASE);
}
},
signatureImport(sig, output) {
isUint8Array("signature", sig);
output = getAssertedOutput(output, 64);
switch (secp256k13.signatureImport(output, sig)) {
case 0:
return output;
case 1:
throw new Error(errors.SIG_PARSE);
case 2:
throw new Error(errors.IMPOSSIBLE_CASE);
}
},
ecdsaSign(msg32, seckey, options = {}, output) {
isUint8Array("message", msg32, 32);
isUint8Array("private key", seckey, 32);
assert(toTypeString(options) === "Object", "Expected options to be an Object");
if (options.data !== void 0) isUint8Array("options.data", options.data);
if (options.noncefn !== void 0) assert(toTypeString(options.noncefn) === "Function", "Expected options.noncefn to be a Function");
output = getAssertedOutput(output, 64);
const obj = { signature: output, recid: null };
switch (secp256k13.ecdsaSign(obj, msg32, seckey, options.data, options.noncefn)) {
case 0:
return obj;
case 1:
throw new Error(errors.SIGN);
case 2:
throw new Error(errors.IMPOSSIBLE_CASE);
}
},
ecdsaVerify(sig, msg32, pubkey) {
isUint8Array("signature", sig, 64);
isUint8Array("message", msg32, 32);
isUint8Array("public key", pubkey, [33, 65]);
switch (secp256k13.ecdsaVerify(sig, msg32, pubkey)) {
case 0:
return true;
case 3:
return false;
case 1:
throw new Error(errors.SIG_PARSE);
case 2:
throw new Error(errors.PUBKEY_PARSE);
}
},
ecdsaRecover(sig, recid, msg32, compressed = true, output) {
isUint8Array("signature", sig, 64);
assert(
toTypeString(recid) === "Number" && recid >= 0 && recid <= 3,
"Expected recovery id to be a Number within interval [0, 3]"
);
isUint8Array("message", msg32, 32);
isCompressed(compressed);
output = getAssertedOutput(output, compressed ? 33 : 65);
switch (secp256k13.ecdsaRecover(output, sig, recid, msg32)) {
case 0:
return output;
case 1:
throw new Error(errors.SIG_PARSE);
case 2:
throw new Error(errors.RECOVER);
case 3:
throw new Error(errors.IMPOSSIBLE_CASE);
}
},
ecdh(pubkey, seckey, options = {}, output) {
isUint8Array("public key", pubkey, [33, 65]);
isUint8Array("private key", seckey, 32);
assert(toTypeString(options) === "Object", "Expected options to be an Object");
if (options.data !== void 0) isUint8Array("options.data", options.data);
if (options.hashfn !== void 0) {
assert(toTypeString(options.hashfn) === "Function", "Expected options.hashfn to be a Function");
if (options.xbuf !== void 0) isUint8Array("options.xbuf", options.xbuf, 32);
if (options.ybuf !== void 0) isUint8Array("options.ybuf", options.ybuf, 32);
isUint8Array("output", output);
} else {
output = getAssertedOutput(output, 32);
}
switch (secp256k13.ecdh(output, pubkey, seckey, options.data, options.hashfn, options.xbuf, options.ybuf)) {
case 0:
return output;
case 1:
throw new Error(errors.PUBKEY_PARSE);
case 2:
throw new Error(errors.ECDH);
}
}
};
};
}
});
// node_modules/secp256k1/bindings.js
var require_bindings = __commonJS({
"node_modules/secp256k1/bindings.js"(exports2, module2) {
var addon = require_node_gyp_build2()(__dirname);
module2.exports = require_lib()(new addon.Secp256k1());
}
});
// node_modules/elliptic/package.json
var require_package2 = __commonJS({
"node_modules/elliptic/package.json"(exports2, module2) {
module2.exports = {
name: "elliptic",
version: "6.6.1",
description: "EC cryptography",
main: "lib/elliptic.js",
files: [
"lib"
],
scripts: {
lint: "eslint lib test",
"lint:fix": "npm run lint -- --fix",
unit: "istanbul test _mocha --reporter=spec test/index.js",
test: "npm run lint && npm run unit",
version: "grunt dist && git add dist/"
},
repository: {
type: "git",
url: "git@github.com:indutny/elliptic"
},
keywords: [
"EC",
"Elliptic",
"curve",
"Cryptography"
],
author: "Fedor Indutny <fedor@indutny.com>",
license: "MIT",
bugs: {
url: "https://github.com/indutny/elliptic/issues"
},
homepage: "https://github.com/indutny/elliptic",
devDependencies: {
brfs: "^2.0.2",
coveralls: "^3.1.0",
eslint: "^7.6.0",
grunt: "^1.2.1",
"grunt-browserify": "^5.3.0",
"grunt-cli": "^1.3.2",
"grunt-contrib-connect": "^3.0.0",
"grunt-contrib-copy": "^1.0.0",
"grunt-contrib-uglify": "^5.0.0",
"grunt-mocha-istanbul": "^5.0.2",
"grunt-saucelabs": "^9.0.1",
istanbul: "^0.4.5",
mocha: "^8.0.1"
},
dependencies: {
"bn.js": "^4.11.9",
brorand: "^1.1.0",
"hash.js": "^1.0.0",
"hmac-drbg": "^1.0.1",
inherits: "^2.0.4",
"minimalistic-assert": "^1.0.1",
"minimalistic-crypto-utils": "^1.0.1"
}
};
}
});
// node_modules/bn.js/lib/bn.js
var require_bn = __commonJS({
"node_modules/bn.js/lib/bn.js"(exports2, module2) {
(function(module3, exports3) {
"use strict";
function assert(val, msg) {
if (!val) throw new Error(msg || "Assertion failed");
}
function inherits(ctor, superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
function BN(number, base, endian) {
if (BN.isBN(number)) {
return number;
}
this.negative = 0;
this.words = null;
this.length = 0;
this.red = null;
if (number !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
this._init(number || 0, base || 10, endian || "be");
}
}
if (typeof module3 === "object") {
module3.exports = BN;
} else {
exports3.BN = BN;
}
BN.BN = BN;
BN.wordSize = 26;
var Buffer2;
try {
if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
Buffer2 = window.Buffer;
} else {
Buffer2 = require("buffer").Buffer;
}
} catch (e) {
}
BN.isBN = function isBN(num) {
if (num instanceof BN) {
return true;
}
return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
};
BN.max = function max(left, right) {
if (left.cmp(right) > 0) return left;
return right;
};
BN.min = function min(left, right) {
if (left.cmp(right) < 0) return left;
return right;
};
BN.prototype._init = function init(number, base, endian) {
if (typeof number === "number") {
return this._initNumber(number, base, endian);
}
if (typeof number === "object") {
return this._initArray(number, base, endian);
}
if (base === "hex") {
base = 16;
}
assert(base === (base | 0) && base >= 2 && base <= 36);
number = number.toString().replace(/\s+/g, "");
var start = 0;
if (number[0] === "-") {
start++;
this.negative = 1;
}
if (start < number.length) {
if (base === 16) {
this._parseHex(number, start, endian);
} else {
this._parseBase(number, base, start);
if (endian === "le") {
this._initArray(this.toArray(), base, endian);
}
}
}
};
BN.prototype._initNumber = function _initNumber(number, base, endian) {
if (number < 0) {
this.negative = 1;
number = -number;
}
if (number < 67108864) {
this.words = [number & 67108863];
this.length = 1;
} else if (number < 4503599627370496) {
this.words = [
number & 67108863,
number / 67108864 & 67108863
];
this.length = 2;
} else {
assert(number < 9007199254740992);
this.words = [
number & 67108863,
number / 67108864 & 67108863,
1
];
this.length = 3;
}
if (endian !== "le") return;
this._initArray(this.toArray(), base, endian);
};
BN.prototype._initArray = function _initArray(number, base, endian) {
assert(typeof number.length === "number");
if (number.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number.length / 3);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var j, w;
var off = 0;
if (endian === "be") {
for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
this.words[j] |= w << off & 67108863;
this.words[j + 1] = w >>> 26 - off & 67108863;
off += 24;
if (off >= 26) {
off -= 26;
j++;
}
}
} else if (endian === "le") {
for (i = 0, j = 0; i < number.length; i += 3) {
w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
this.words[j] |= w << off & 67108863;
this.words[j + 1] = w >>> 26 - off & 67108863;
off += 24;
if (off >= 26) {
off -= 26;
j++;
}
}
}
return this.strip();
};
function parseHex4Bits(string, index) {
var c = string.charCodeAt(index);
if (c >= 65 && c <= 70) {
return c - 55;
} else if (c >= 97 && c <= 102) {
return c - 87;
} else {
return c - 48 & 15;
}
}
function parseHexByte(string, lowerBound, index) {
var r = parseHex4Bits(string, index);
if (index - 1 >= lowerBound) {
r |= parseHex4Bits(string, index - 1) << 4;
}
return r;
}
BN.prototype._parseHex = function _parseHex(number, start, endian) {
this.length = Math.ceil((number.length - start) / 6);
this.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
this.words[i] = 0;
}
var off = 0;
var j = 0;
var w;
if (endian === "be") {
for (i = number.length - 1; i >= start; i -= 2) {
w = parseHexByte(number, start, i) << off;
this.words[j] |= w & 67108863;
if (off >= 18) {
off -= 18;
j += 1;
this.words[j] |= w >>> 26;
} else {
off += 8;
}
}
} else {
var parseLength = number.length - start;
for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
w = parseHexByte(number, start, i) << off;
this.words[j] |= w & 67108863;
if (off >= 18) {
off -= 18;
j += 1;
this.words[j] |= w >>> 26;
} else {
off += 8;
}
}
}
this.strip();
};
function parseBase(str, start, end, mul) {
var r = 0;
var len = Math.min(str.length, end);
for (var i = start; i < len; i++) {
var c = str.charCodeAt(i) - 48;
r *= mul;
if (c >= 49) {
r += c - 49 + 10;
} else if (c >= 17) {
r += c - 17 + 10;
} else {
r += c;
}
}
return r;
}
BN.prototype._parseBase = function _parseBase(number, base, start) {
this.words = [0];
this.length = 1;
for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) {
limbLen++;
}
limbLen--;
limbPow = limbPow / base | 0;
var total = number.length - start;
var mod2 = total % limbLen;
var end = Math.min(total, total - mod2) + start;
var word = 0;
for (var i = start; i < end; i += limbLen) {
word = parseBase(number, i, i + limbLen, base);
this.imuln(limbPow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
if (mod2 !== 0) {
var pow3 = 1;
word = parseBase(number, i, number.length, base);
for (i = 0; i < mod2; i++) {
pow3 *= base;
}
this.imuln(pow3);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
this.strip();
};
BN.prototype.copy = function copy(dest) {
dest.words = new Array(this.length);
for (var i = 0; i < this.length; i++) {
dest.words[i] = this.words[i];
}
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
};
BN.prototype.clone = function clone() {
var r = new BN(null);
this.copy(r);
return r;
};
BN.prototype._expand = function _expand(size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
};
BN.prototype.strip = function strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this._normSign();
};
BN.prototype._normSign = function _normSign() {
if (this.length === 1 && this.words[0] === 0) {
this.negative = 0;
}
return this;
};
BN.prototype.inspect = function inspect() {
return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
};
var zeros = [
"",
"0",
"00",
"000",
"0000",
"00000",
"000000",
"0000000",
"00000000",
"000000000",
"0000000000",
"00000000000",
"000000000000",
"0000000000000",
"00000000000000",
"000000000000000",
"0000000000000000",
"00000000000000000",
"000000000000000000",
"0000000000000000000",
"00000000000000000000",
"000000000000000000000",
"0000000000000000000000",
"00000000000000000000000",
"000000000000000000000000",
"0000000000000000000000000"
];
var groupSizes = [
0,
0,
25,
16,
12,
11,
10,
9,
8,
8,
7,
7,
7,
7,
6,
6,
6,
6,
6,
6,
6,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5,
5
];
var groupBases = [
0,
0,
33554432,
43046721,
16777216,
48828125,
60466176,
40353607,
16777216,
43046721,
1e7,
19487171,
35831808,
62748517,
7529536,
11390625,
16777216,
24137569,
34012224,
47045881,
64e6,
4084101,
5153632,
6436343,
7962624,
9765625,
11881376,
14348907,
17210368,
20511149,
243e5,
28629151,
33554432,
39135393,
45435424,
52521875,
60466176
];
BN.prototype.toString = function toString(base, padding) {
base = base || 10;
padding = padding | 0 || 1;
var out;
if (base === 16 || base === "hex") {
out = "";
var off = 0;
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = this.words[i];
var word = ((w << off | carry) & 16777215).toString(16);
carry = w >>> 24 - off & 16777215;
off += 2;
if (off >= 26) {
off -= 26;
i--;
}
if (carry !== 0 || i !== this.length - 1) {
out = zeros[6 - word.length] + word + out;
} else {
out = word + out;
}
}
if (carry !== 0) {
out = carry.toString(16) + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
if (base === (base | 0) && base >= 2 && base <= 36) {
var groupSize = groupSizes[base];
var groupBase = groupBases[base];
out = "";
var c = this.clone();
c.negative = 0;
while (!c.isZero()) {
var r = c.modn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) {
out = zeros[groupSize - r.length] + r + out;
} else {
out = r + out;
}
}
if (this.isZero()) {
out = "0" + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
assert(false, "Base should be between 2 and 36");
};
BN.prototype.toNumber = function toNumber() {
var ret = this.words[0];
if (this.length === 2) {
ret += this.words[1] * 67108864;
} else if (this.length === 3 && this.words[2] === 1) {
ret += 4503599627370496 + this.words[1] * 67108864;
} else if (this.length > 2) {
assert(false, "Number can only safely store up to 53 bits");
}
return this.negative !== 0 ? -ret : ret;
};
BN.prototype.toJSON = function toJSON() {
return this.toString(16);
};
BN.prototype.toBuffer = function toBuffer(endian, length) {
assert(typeof Buffer2 !== "undefined");
return this.toArrayLike(Buffer2, endian, length);
};
BN.prototype.toArray = function toArray(endian, length) {
return this.toArrayLike(Array, endian, length);
};
BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
var byteLength = this.byteLength();
var reqLength = length || Math.max(1, byteLength);
assert(byteLength <= reqLength, "byte array longer than desired length");
assert(reqLength > 0, "Requested array length <= 0");
this.strip();
var littleEndian = endian === "le";
var res = new ArrayType(reqLength);
var b, i;
var q = this.clone();
if (!littleEndian) {
for (i = 0; i < reqLength - byteLength; i++) {
res[i] = 0;
}
for (i = 0; !q.isZero(); i++) {
b = q.andln(255);
q.iushrn(8);
res[reqLength - i - 1] = b;
}
} else {
for (i = 0; !q.isZero(); i++) {
b = q.andln(255);
q.iushrn(8);
res[i] = b;
}
for (; i < reqLength; i++) {
res[i] = 0;
}
}
return res;
};
if (Math.clz32) {
BN.prototype._countBits = function _countBits(w) {
return 32 - Math.clz32(w);
};
} else {
BN.prototype._countBits = function _countBits(w) {
var t = w;
var r = 0;
if (t >= 4096) {
r += 13;
t >>>= 13;
}
if (t >= 64) {
r += 7;
t >>>= 7;
}
if (t >= 8) {
r += 4;
t >>>= 4;
}
if (t >= 2) {
r += 2;
t >>>= 2;
}
return r + t;
};
}
BN.prototype._zeroBits = function _zeroBits(w) {
if (w === 0) return 26;
var t = w;
var r = 0;
if ((t & 8191) === 0) {
r += 13;
t >>>= 13;
}
if ((t & 127) === 0) {
r += 7;
t >>>= 7;
}
if ((t & 15) === 0) {
r += 4;
t >>>= 4;
}
if ((t & 3) === 0) {
r += 2;
t >>>= 2;
}
if ((t & 1) === 0) {
r++;
}
return r;
};
BN.prototype.bitLength = function bitLength() {
var w = this.words[this.length - 1];
var hi = this._countBits(w);
return (this.length - 1) * 26 + hi;
};
function toBitArray(num) {
var w = new Array(num.bitLength());
for (var bit = 0; bit < w.length; bit++) {
var off = bit / 26 | 0;
var wbit = bit % 26;
w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
}
return w;
}
BN.prototype.zeroBits = function zeroBits() {
if (this.isZero()) return 0;
var r = 0;
for (var i = 0; i < this.length; i++) {
var b = this._zeroBits(this.words[i]);
r += b;
if (b !== 26) break;
}
return r;
};
BN.prototype.byteLength = function byteLength() {
return Math.ceil(this.bitLength() / 8);
};
BN.prototype.toTwos = function toTwos(width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
};
BN.prototype.fromTwos = function fromTwos(width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
};
BN.prototype.isNeg = function isNeg() {
return this.negative !== 0;
};
BN.prototype.neg = function neg() {
return this.clone().ineg();
};
BN.prototype.ineg = function ineg() {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
};
BN.prototype.iuor = function iuor(num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (var i = 0; i < num.length; i++) {
this.words[i] = this.words[i] | num.words[i];
}
return this.strip();
};
BN.prototype.ior = function ior(num) {
assert((this.negative | num.negative) === 0);
return this.iuor(num);
};
BN.prototype.or = function or(num) {
if (this.length > num.length) return this.clone().ior(num);
return num.clone().ior(this);
};
BN.prototype.uor = function uor(num) {
if (this.length > num.length) return this.clone().iuor(num);
return num.clone().iuor(this);
};
BN.prototype.iuand = function iuand(num) {
var b;
if (this.length > num.length) {
b = num;
} else {
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = this.words[i] & num.words[i];
}
this.length = b.length;
return this.strip();
};
BN.prototype.iand = function iand(num) {
assert((this.negative | num.negative) === 0);
return this.iuand(num);
};
BN.prototype.and = function and(num) {
if (this.length > num.length) return this.clone().iand(num);
return num.clone().iand(this);
};
BN.prototype.uand = function uand(num) {
if (this.length > num.length) return this.clone().iuand(num);
return num.clone().iuand(this);
};
BN.prototype.iuxor = function iuxor(num) {
var a;
var b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
for (var i = 0; i < b.length; i++) {
this.words[i] = a.words[i] ^ b.words[i];
}
if (this !== a) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = a.length;
return this.strip();
};
BN.prototype.ixor = function ixor(num) {
assert((this.negative | num.negative) === 0);
return this.iuxor(num);
};
BN.prototype.xor = function xor(num) {
if (this.length > num.length) return this.clone().ixor(num);
return num.clone().ixor(this);
};
BN.prototype.uxor = function uxor(num) {
if (this.length > num.length) return this.clone().iuxor(num);
return num.clone().iuxor(this);
};
BN.prototype.inotn = function inotn(width) {
assert(typeof width === "number" && width >= 0);
var bytesNeeded = Math.ceil(width / 26) | 0;
var bitsLeft = width % 26;
this._expand(bytesNeeded);
if (bitsLeft > 0) {
bytesNeeded--;
}
for (var i = 0; i < bytesNeeded; i++) {
this.words[i] = ~this.words[i] & 67108863;
}
if (bitsLeft > 0) {
this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
}
return this.strip();
};
BN.prototype.notn = function notn(width) {
return this.clone().inotn(width);
};
BN.prototype.setn = function setn(bit, val) {
assert(typeof bit === "number" && bit >= 0);
var off = bit / 26 | 0;
var wbit = bit % 26;
this._expand(off + 1);
if (val) {
this.words[off] = this.words[off] | 1 << wbit;
} else {
this.words[off] = this.words[off] & ~(1 << wbit);
}
return this.strip();
};
BN.prototype.iadd = function iadd(num) {
var r;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r = this.isub(num);
this.negative ^= 1;
return this._normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r = this.isub(num);
num.negative = 1;
return r._normSign();
}
var a, b;
if (this.length > num.length) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
this.words[i] = r & 67108863;
carry = r >>> 26;
}
this.length = a.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
} else if (a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
return this;
};
BN.prototype.add = function add2(num) {
var res;
if (num.negative !== 0 && this.negative === 0) {
num.negative = 0;
res = this.sub(num);
num.negative ^= 1;
return res;
} else if (num.negative === 0 && this.negative !== 0) {
this.negative = 0;
res = num.sub(this);
this.negative = 1;
return res;
}
if (this.length > num.length) return this.clone().iadd(num);
return num.clone().iadd(this);
};
BN.prototype.isub = function isub(num) {
if (num.negative !== 0) {
num.negative = 0;
var r = this.iadd(num);
num.negative = 1;
return r._normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this._normSign();
}
var cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
var a, b;
if (cmp > 0) {
a = this;
b = num;
} else {
a = num;
b = this;
}
var carry = 0;
for (var i = 0; i < b.length; i++) {
r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
for (; carry !== 0 && i < a.length; i++) {
r = (a.words[i] | 0) + carry;
carry = r >> 26;
this.words[i] = r & 67108863;
}
if (carry === 0 && i < a.length && a !== this) {
for (; i < a.length; i++) {
this.words[i] = a.words[i];
}
}
this.length = Math.max(this.length, i);
if (a !== this) {
this.negative = 1;
}
return this.strip();
};
BN.prototype.sub = function sub(num) {
return this.clone().isub(num);
};
function smallMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
var len = self2.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
var a = self2.words[0] | 0;
var b = num.words[0] | 0;
var r = a * b;
var lo = r & 67108863;
var carry = r / 67108864 | 0;
out.words[0] = lo;
for (var k = 1; k < len; k++) {
var ncarry = carry >>> 26;
var rword = carry & 67108863;
var maxJ = Math.min(k, num.length - 1);
for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
var i = k - j | 0;
a = self2.words[i] | 0;
b = num.words[j] | 0;
r = a * b + rword;
ncarry += r / 67108864 | 0;
rword = r & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) {
out.words[k] = carry | 0;
} else {
out.length--;
}
return out.strip();
}
var comb10MulTo = function comb10MulTo2(self2, num, out) {
var a = self2.words;
var b = num.words;
var o = out.words;
var c = 0;
var lo;
var mid;
var hi;
var a0 = a[0] | 0;
var al0 = a0 & 8191;
var ah0 = a0 >>> 13;
var a1 = a[1] | 0;
var al1 = a1 & 8191;
var ah1 = a1 >>> 13;
var a2 = a[2] | 0;
var al2 = a2 & 8191;
var ah2 = a2 >>> 13;
var a3 = a[3] | 0;
var al3 = a3 & 8191;
var ah3 = a3 >>> 13;
var a4 = a[4] | 0;
var al4 = a4 & 8191;
var ah4 = a4 >>> 13;
var a5 = a[5] | 0;
var al5 = a5 & 8191;
var ah5 = a5 >>> 13;
var a6 = a[6] | 0;
var al6 = a6 & 8191;
var ah6 = a6 >>> 13;
var a7 = a[7] | 0;
var al7 = a7 & 8191;
var ah7 = a7 >>> 13;
var a8 = a[8] | 0;
var al8 = a8 & 8191;
var ah8 = a8 >>> 13;
var a9 = a[9] | 0;
var al9 = a9 & 8191;
var ah9 = a9 >>> 13;
var b0 = b[0] | 0;
var bl0 = b0 & 8191;
var bh0 = b0 >>> 13;
var b1 = b[1] | 0;
var bl1 = b1 & 8191;
var bh1 = b1 >>> 13;
var b2 = b[2] | 0;
var bl2 = b2 & 8191;
var bh2 = b2 >>> 13;
var b3 = b[3] | 0;
var bl3 = b3 & 8191;
var bh3 = b3 >>> 13;
var b4 = b[4] | 0;
var bl4 = b4 & 8191;
var bh4 = b4 >>> 13;
var b5 = b[5] | 0;
var bl5 = b5 & 8191;
var bh5 = b5 >>> 13;
var b6 = b[6] | 0;
var bl6 = b6 & 8191;
var bh6 = b6 >>> 13;
var b7 = b[7] | 0;
var bl7 = b7 & 8191;
var bh7 = b7 >>> 13;
var b8 = b[8] | 0;
var bl8 = b8 & 8191;
var bh8 = b8 >>> 13;
var b9 = b[9] | 0;
var bl9 = b9 & 8191;
var bh9 = b9 >>> 13;
out.negative = self2.negative ^ num.negative;
out.length = 19;
lo = Math.imul(al0, bl0);
mid = Math.imul(al0, bh0);
mid = mid + Math.imul(ah0, bl0) | 0;
hi = Math.imul(ah0, bh0);
var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
w0 &= 67108863;
lo = Math.imul(al1, bl0);
mid = Math.imul(al1, bh0);
mid = mid + Math.imul(ah1, bl0) | 0;
hi = Math.imul(ah1, bh0);
lo = lo + Math.imul(al0, bl1) | 0;
mid = mid + Math.imul(al0, bh1) | 0;
mid = mid + Math.imul(ah0, bl1) | 0;
hi = hi + Math.imul(ah0, bh1) | 0;
var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
w1 &= 67108863;
lo = Math.imul(al2, bl0);
mid = Math.imul(al2, bh0);
mid = mid + Math.imul(ah2, bl0) | 0;
hi = Math.imul(ah2, bh0);
lo = lo + Math.imul(al1, bl1) | 0;
mid = mid + Math.imul(al1, bh1) | 0;
mid = mid + Math.imul(ah1, bl1) | 0;
hi = hi + Math.imul(ah1, bh1) | 0;
lo = lo + Math.imul(al0, bl2) | 0;
mid = mid + Math.imul(al0, bh2) | 0;
mid = mid + Math.imul(ah0, bl2) | 0;
hi = hi + Math.imul(ah0, bh2) | 0;
var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
w2 &= 67108863;
lo = Math.imul(al3, bl0);
mid = Math.imul(al3, bh0);
mid = mid + Math.imul(ah3, bl0) | 0;
hi = Math.imul(ah3, bh0);
lo = lo + Math.imul(al2, bl1) | 0;
mid = mid + Math.imul(al2, bh1) | 0;
mid = mid + Math.imul(ah2, bl1) | 0;
hi = hi + Math.imul(ah2, bh1) | 0;
lo = lo + Math.imul(al1, bl2) | 0;
mid = mid + Math.imul(al1, bh2) | 0;
mid = mid + Math.imul(ah1, bl2) | 0;
hi = hi + Math.imul(ah1, bh2) | 0;
lo = lo + Math.imul(al0, bl3) | 0;
mid = mid + Math.imul(al0, bh3) | 0;
mid = mid + Math.imul(ah0, bl3) | 0;
hi = hi + Math.imul(ah0, bh3) | 0;
var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
w3 &= 67108863;
lo = Math.imul(al4, bl0);
mid = Math.imul(al4, bh0);
mid = mid + Math.imul(ah4, bl0) | 0;
hi = Math.imul(ah4, bh0);
lo = lo + Math.imul(al3, bl1) | 0;
mid = mid + Math.imul(al3, bh1) | 0;
mid = mid + Math.imul(ah3, bl1) | 0;
hi = hi + Math.imul(ah3, bh1) | 0;
lo = lo + Math.imul(al2, bl2) | 0;
mid = mid + Math.imul(al2, bh2) | 0;
mid = mid + Math.imul(ah2, bl2) | 0;
hi = hi + Math.imul(ah2, bh2) | 0;
lo = lo + Math.imul(al1, bl3) | 0;
mid = mid + Math.imul(al1, bh3) | 0;
mid = mid + Math.imul(ah1, bl3) | 0;
hi = hi + Math.imul(ah1, bh3) | 0;
lo = lo + Math.imul(al0, bl4) | 0;
mid = mid + Math.imul(al0, bh4) | 0;
mid = mid + Math.imul(ah0, bl4) | 0;
hi = hi + Math.imul(ah0, bh4) | 0;
var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
w4 &= 67108863;
lo = Math.imul(al5, bl0);
mid = Math.imul(al5, bh0);
mid = mid + Math.imul(ah5, bl0) | 0;
hi = Math.imul(ah5, bh0);
lo = lo + Math.imul(al4, bl1) | 0;
mid = mid + Math.imul(al4, bh1) | 0;
mid = mid + Math.imul(ah4, bl1) | 0;
hi = hi + Math.imul(ah4, bh1) | 0;
lo = lo + Math.imul(al3, bl2) | 0;
mid = mid + Math.imul(al3, bh2) | 0;
mid = mid + Math.imul(ah3, bl2) | 0;
hi = hi + Math.imul(ah3, bh2) | 0;
lo = lo + Math.imul(al2, bl3) | 0;
mid = mid + Math.imul(al2, bh3) | 0;
mid = mid + Math.imul(ah2, bl3) | 0;
hi = hi + Math.imul(ah2, bh3) | 0;
lo = lo + Math.imul(al1, bl4) | 0;
mid = mid + Math.imul(al1, bh4) | 0;
mid = mid + Math.imul(ah1, bl4) | 0;
hi = hi + Math.imul(ah1, bh4) | 0;
lo = lo + Math.imul(al0, bl5) | 0;
mid = mid + Math.imul(al0, bh5) | 0;
mid = mid + Math.imul(ah0, bl5) | 0;
hi = hi + Math.imul(ah0, bh5) | 0;
var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
w5 &= 67108863;
lo = Math.imul(al6, bl0);
mid = Math.imul(al6, bh0);
mid = mid + Math.imul(ah6, bl0) | 0;
hi = Math.imul(ah6, bh0);
lo = lo + Math.imul(al5, bl1) | 0;
mid = mid + Math.imul(al5, bh1) | 0;
mid = mid + Math.imul(ah5, bl1) | 0;
hi = hi + Math.imul(ah5, bh1) | 0;
lo = lo + Math.imul(al4, bl2) | 0;
mid = mid + Math.imul(al4, bh2) | 0;
mid = mid + Math.imul(ah4, bl2) | 0;
hi = hi + Math.imul(ah4, bh2) | 0;
lo = lo + Math.imul(al3, bl3) | 0;
mid = mid + Math.imul(al3, bh3) | 0;
mid = mid + Math.imul(ah3, bl3) | 0;
hi = hi + Math.imul(ah3, bh3) | 0;
lo = lo + Math.imul(al2, bl4) | 0;
mid = mid + Math.imul(al2, bh4) | 0;
mid = mid + Math.imul(ah2, bl4) | 0;
hi = hi + Math.imul(ah2, bh4) | 0;
lo = lo + Math.imul(al1, bl5) | 0;
mid = mid + Math.imul(al1, bh5) | 0;
mid = mid + Math.imul(ah1, bl5) | 0;
hi = hi + Math.imul(ah1, bh5) | 0;
lo = lo + Math.imul(al0, bl6) | 0;
mid = mid + Math.imul(al0, bh6) | 0;
mid = mid + Math.imul(ah0, bl6) | 0;
hi = hi + Math.imul(ah0, bh6) | 0;
var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
w6 &= 67108863;
lo = Math.imul(al7, bl0);
mid = Math.imul(al7, bh0);
mid = mid + Math.imul(ah7, bl0) | 0;
hi = Math.imul(ah7, bh0);
lo = lo + Math.imul(al6, bl1) | 0;
mid = mid + Math.imul(al6, bh1) | 0;
mid = mid + Math.imul(ah6, bl1) | 0;
hi = hi + Math.imul(ah6, bh1) | 0;
lo = lo + Math.imul(al5, bl2) | 0;
mid = mid + Math.imul(al5, bh2) | 0;
mid = mid + Math.imul(ah5, bl2) | 0;
hi = hi + Math.imul(ah5, bh2) | 0;
lo = lo + Math.imul(al4, bl3) | 0;
mid = mid + Math.imul(al4, bh3) | 0;
mid = mid + Math.imul(ah4, bl3) | 0;
hi = hi + Math.imul(ah4, bh3) | 0;
lo = lo + Math.imul(al3, bl4) | 0;
mid = mid + Math.imul(al3, bh4) | 0;
mid = mid + Math.imul(ah3, bl4) | 0;
hi = hi + Math.imul(ah3, bh4) | 0;
lo = lo + Math.imul(al2, bl5) | 0;
mid = mid + Math.imul(al2, bh5) | 0;
mid = mid + Math.imul(ah2, bl5) | 0;
hi = hi + Math.imul(ah2, bh5) | 0;
lo = lo + Math.imul(al1, bl6) | 0;
mid = mid + Math.imul(al1, bh6) | 0;
mid = mid + Math.imul(ah1, bl6) | 0;
hi = hi + Math.imul(ah1, bh6) | 0;
lo = lo + Math.imul(al0, bl7) | 0;
mid = mid + Math.imul(al0, bh7) | 0;
mid = mid + Math.imul(ah0, bl7) | 0;
hi = hi + Math.imul(ah0, bh7) | 0;
var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
w7 &= 67108863;
lo = Math.imul(al8, bl0);
mid = Math.imul(al8, bh0);
mid = mid + Math.imul(ah8, bl0) | 0;
hi = Math.imul(ah8, bh0);
lo = lo + Math.imul(al7, bl1) | 0;
mid = mid + Math.imul(al7, bh1) | 0;
mid = mid + Math.imul(ah7, bl1) | 0;
hi = hi + Math.imul(ah7, bh1) | 0;
lo = lo + Math.imul(al6, bl2) | 0;
mid = mid + Math.imul(al6, bh2) | 0;
mid = mid + Math.imul(ah6, bl2) | 0;
hi = hi + Math.imul(ah6, bh2) | 0;
lo = lo + Math.imul(al5, bl3) | 0;
mid = mid + Math.imul(al5, bh3) | 0;
mid = mid + Math.imul(ah5, bl3) | 0;
hi = hi + Math.imul(ah5, bh3) | 0;
lo = lo + Math.imul(al4, bl4) | 0;
mid = mid + Math.imul(al4, bh4) | 0;
mid = mid + Math.imul(ah4, bl4) | 0;
hi = hi + Math.imul(ah4, bh4) | 0;
lo = lo + Math.imul(al3, bl5) | 0;
mid = mid + Math.imul(al3, bh5) | 0;
mid = mid + Math.imul(ah3, bl5) | 0;
hi = hi + Math.imul(ah3, bh5) | 0;
lo = lo + Math.imul(al2, bl6) | 0;
mid = mid + Math.imul(al2, bh6) | 0;
mid = mid + Math.imul(ah2, bl6) | 0;
hi = hi + Math.imul(ah2, bh6) | 0;
lo = lo + Math.imul(al1, bl7) | 0;
mid = mid + Math.imul(al1, bh7) | 0;
mid = mid + Math.imul(ah1, bl7) | 0;
hi = hi + Math.imul(ah1, bh7) | 0;
lo = lo + Math.imul(al0, bl8) | 0;
mid = mid + Math.imul(al0, bh8) | 0;
mid = mid + Math.imul(ah0, bl8) | 0;
hi = hi + Math.imul(ah0, bh8) | 0;
var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
w8 &= 67108863;
lo = Math.imul(al9, bl0);
mid = Math.imul(al9, bh0);
mid = mid + Math.imul(ah9, bl0) | 0;
hi = Math.imul(ah9, bh0);
lo = lo + Math.imul(al8, bl1) | 0;
mid = mid + Math.imul(al8, bh1) | 0;
mid = mid + Math.imul(ah8, bl1) | 0;
hi = hi + Math.imul(ah8, bh1) | 0;
lo = lo + Math.imul(al7, bl2) | 0;
mid = mid + Math.imul(al7, bh2) | 0;
mid = mid + Math.imul(ah7, bl2) | 0;
hi = hi + Math.imul(ah7, bh2) | 0;
lo = lo + Math.imul(al6, bl3) | 0;
mid = mid + Math.imul(al6, bh3) | 0;
mid = mid + Math.imul(ah6, bl3) | 0;
hi = hi + Math.imul(ah6, bh3) | 0;
lo = lo + Math.imul(al5, bl4) | 0;
mid = mid + Math.imul(al5, bh4) | 0;
mid = mid + Math.imul(ah5, bl4) | 0;
hi = hi + Math.imul(ah5, bh4) | 0;
lo = lo + Math.imul(al4, bl5) | 0;
mid = mid + Math.imul(al4, bh5) | 0;
mid = mid + Math.imul(ah4, bl5) | 0;
hi = hi + Math.imul(ah4, bh5) | 0;
lo = lo + Math.imul(al3, bl6) | 0;
mid = mid + Math.imul(al3, bh6) | 0;
mid = mid + Math.imul(ah3, bl6) | 0;
hi = hi + Math.imul(ah3, bh6) | 0;
lo = lo + Math.imul(al2, bl7) | 0;
mid = mid + Math.imul(al2, bh7) | 0;
mid = mid + Math.imul(ah2, bl7) | 0;
hi = hi + Math.imul(ah2, bh7) | 0;
lo = lo + Math.imul(al1, bl8) | 0;
mid = mid + Math.imul(al1, bh8) | 0;
mid = mid + Math.imul(ah1, bl8) | 0;
hi = hi + Math.imul(ah1, bh8) | 0;
lo = lo + Math.imul(al0, bl9) | 0;
mid = mid + Math.imul(al0, bh9) | 0;
mid = mid + Math.imul(ah0, bl9) | 0;
hi = hi + Math.imul(ah0, bh9) | 0;
var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
w9 &= 67108863;
lo = Math.imul(al9, bl1);
mid = Math.imul(al9, bh1);
mid = mid + Math.imul(ah9, bl1) | 0;
hi = Math.imul(ah9, bh1);
lo = lo + Math.imul(al8, bl2) | 0;
mid = mid + Math.imul(al8, bh2) | 0;
mid = mid + Math.imul(ah8, bl2) | 0;
hi = hi + Math.imul(ah8, bh2) | 0;
lo = lo + Math.imul(al7, bl3) | 0;
mid = mid + Math.imul(al7, bh3) | 0;
mid = mid + Math.imul(ah7, bl3) | 0;
hi = hi + Math.imul(ah7, bh3) | 0;
lo = lo + Math.imul(al6, bl4) | 0;
mid = mid + Math.imul(al6, bh4) | 0;
mid = mid + Math.imul(ah6, bl4) | 0;
hi = hi + Math.imul(ah6, bh4) | 0;
lo = lo + Math.imul(al5, bl5) | 0;
mid = mid + Math.imul(al5, bh5) | 0;
mid = mid + Math.imul(ah5, bl5) | 0;
hi = hi + Math.imul(ah5, bh5) | 0;
lo = lo + Math.imul(al4, bl6) | 0;
mid = mid + Math.imul(al4, bh6) | 0;
mid = mid + Math.imul(ah4, bl6) | 0;
hi = hi + Math.imul(ah4, bh6) | 0;
lo = lo + Math.imul(al3, bl7) | 0;
mid = mid + Math.imul(al3, bh7) | 0;
mid = mid + Math.imul(ah3, bl7) | 0;
hi = hi + Math.imul(ah3, bh7) | 0;
lo = lo + Math.imul(al2, bl8) | 0;
mid = mid + Math.imul(al2, bh8) | 0;
mid = mid + Math.imul(ah2, bl8) | 0;
hi = hi + Math.imul(ah2, bh8) | 0;
lo = lo + Math.imul(al1, bl9) | 0;
mid = mid + Math.imul(al1, bh9) | 0;
mid = mid + Math.imul(ah1, bl9) | 0;
hi = hi + Math.imul(ah1, bh9) | 0;
var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
w10 &= 67108863;
lo = Math.imul(al9, bl2);
mid = Math.imul(al9, bh2);
mid = mid + Math.imul(ah9, bl2) | 0;
hi = Math.imul(ah9, bh2);
lo = lo + Math.imul(al8, bl3) | 0;
mid = mid + Math.imul(al8, bh3) | 0;
mid = mid + Math.imul(ah8, bl3) | 0;
hi = hi + Math.imul(ah8, bh3) | 0;
lo = lo + Math.imul(al7, bl4) | 0;
mid = mid + Math.imul(al7, bh4) | 0;
mid = mid + Math.imul(ah7, bl4) | 0;
hi = hi + Math.imul(ah7, bh4) | 0;
lo = lo + Math.imul(al6, bl5) | 0;
mid = mid + Math.imul(al6, bh5) | 0;
mid = mid + Math.imul(ah6, bl5) | 0;
hi = hi + Math.imul(ah6, bh5) | 0;
lo = lo + Math.imul(al5, bl6) | 0;
mid = mid + Math.imul(al5, bh6) | 0;
mid = mid + Math.imul(ah5, bl6) | 0;
hi = hi + Math.imul(ah5, bh6) | 0;
lo = lo + Math.imul(al4, bl7) | 0;
mid = mid + Math.imul(al4, bh7) | 0;
mid = mid + Math.imul(ah4, bl7) | 0;
hi = hi + Math.imul(ah4, bh7) | 0;
lo = lo + Math.imul(al3, bl8) | 0;
mid = mid + Math.imul(al3, bh8) | 0;
mid = mid + Math.imul(ah3, bl8) | 0;
hi = hi + Math.imul(ah3, bh8) | 0;
lo = lo + Math.imul(al2, bl9) | 0;
mid = mid + Math.imul(al2, bh9) | 0;
mid = mid + Math.imul(ah2, bl9) | 0;
hi = hi + Math.imul(ah2, bh9) | 0;
var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
w11 &= 67108863;
lo = Math.imul(al9, bl3);
mid = Math.imul(al9, bh3);
mid = mid + Math.imul(ah9, bl3) | 0;
hi = Math.imul(ah9, bh3);
lo = lo + Math.imul(al8, bl4) | 0;
mid = mid + Math.imul(al8, bh4) | 0;
mid = mid + Math.imul(ah8, bl4) | 0;
hi = hi + Math.imul(ah8, bh4) | 0;
lo = lo + Math.imul(al7, bl5) | 0;
mid = mid + Math.imul(al7, bh5) | 0;
mid = mid + Math.imul(ah7, bl5) | 0;
hi = hi + Math.imul(ah7, bh5) | 0;
lo = lo + Math.imul(al6, bl6) | 0;
mid = mid + Math.imul(al6, bh6) | 0;
mid = mid + Math.imul(ah6, bl6) | 0;
hi = hi + Math.imul(ah6, bh6) | 0;
lo = lo + Math.imul(al5, bl7) | 0;
mid = mid + Math.imul(al5, bh7) | 0;
mid = mid + Math.imul(ah5, bl7) | 0;
hi = hi + Math.imul(ah5, bh7) | 0;
lo = lo + Math.imul(al4, bl8) | 0;
mid = mid + Math.imul(al4, bh8) | 0;
mid = mid + Math.imul(ah4, bl8) | 0;
hi = hi + Math.imul(ah4, bh8) | 0;
lo = lo + Math.imul(al3, bl9) | 0;
mid = mid + Math.imul(al3, bh9) | 0;
mid = mid + Math.imul(ah3, bl9) | 0;
hi = hi + Math.imul(ah3, bh9) | 0;
var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
w12 &= 67108863;
lo = Math.imul(al9, bl4);
mid = Math.imul(al9, bh4);
mid = mid + Math.imul(ah9, bl4) | 0;
hi = Math.imul(ah9, bh4);
lo = lo + Math.imul(al8, bl5) | 0;
mid = mid + Math.imul(al8, bh5) | 0;
mid = mid + Math.imul(ah8, bl5) | 0;
hi = hi + Math.imul(ah8, bh5) | 0;
lo = lo + Math.imul(al7, bl6) | 0;
mid = mid + Math.imul(al7, bh6) | 0;
mid = mid + Math.imul(ah7, bl6) | 0;
hi = hi + Math.imul(ah7, bh6) | 0;
lo = lo + Math.imul(al6, bl7) | 0;
mid = mid + Math.imul(al6, bh7) | 0;
mid = mid + Math.imul(ah6, bl7) | 0;
hi = hi + Math.imul(ah6, bh7) | 0;
lo = lo + Math.imul(al5, bl8) | 0;
mid = mid + Math.imul(al5, bh8) | 0;
mid = mid + Math.imul(ah5, bl8) | 0;
hi = hi + Math.imul(ah5, bh8) | 0;
lo = lo + Math.imul(al4, bl9) | 0;
mid = mid + Math.imul(al4, bh9) | 0;
mid = mid + Math.imul(ah4, bl9) | 0;
hi = hi + Math.imul(ah4, bh9) | 0;
var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
w13 &= 67108863;
lo = Math.imul(al9, bl5);
mid = Math.imul(al9, bh5);
mid = mid + Math.imul(ah9, bl5) | 0;
hi = Math.imul(ah9, bh5);
lo = lo + Math.imul(al8, bl6) | 0;
mid = mid + Math.imul(al8, bh6) | 0;
mid = mid + Math.imul(ah8, bl6) | 0;
hi = hi + Math.imul(ah8, bh6) | 0;
lo = lo + Math.imul(al7, bl7) | 0;
mid = mid + Math.imul(al7, bh7) | 0;
mid = mid + Math.imul(ah7, bl7) | 0;
hi = hi + Math.imul(ah7, bh7) | 0;
lo = lo + Math.imul(al6, bl8) | 0;
mid = mid + Math.imul(al6, bh8) | 0;
mid = mid + Math.imul(ah6, bl8) | 0;
hi = hi + Math.imul(ah6, bh8) | 0;
lo = lo + Math.imul(al5, bl9) | 0;
mid = mid + Math.imul(al5, bh9) | 0;
mid = mid + Math.imul(ah5, bl9) | 0;
hi = hi + Math.imul(ah5, bh9) | 0;
var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
w14 &= 67108863;
lo = Math.imul(al9, bl6);
mid = Math.imul(al9, bh6);
mid = mid + Math.imul(ah9, bl6) | 0;
hi = Math.imul(ah9, bh6);
lo = lo + Math.imul(al8, bl7) | 0;
mid = mid + Math.imul(al8, bh7) | 0;
mid = mid + Math.imul(ah8, bl7) | 0;
hi = hi + Math.imul(ah8, bh7) | 0;
lo = lo + Math.imul(al7, bl8) | 0;
mid = mid + Math.imul(al7, bh8) | 0;
mid = mid + Math.imul(ah7, bl8) | 0;
hi = hi + Math.imul(ah7, bh8) | 0;
lo = lo + Math.imul(al6, bl9) | 0;
mid = mid + Math.imul(al6, bh9) | 0;
mid = mid + Math.imul(ah6, bl9) | 0;
hi = hi + Math.imul(ah6, bh9) | 0;
var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
w15 &= 67108863;
lo = Math.imul(al9, bl7);
mid = Math.imul(al9, bh7);
mid = mid + Math.imul(ah9, bl7) | 0;
hi = Math.imul(ah9, bh7);
lo = lo + Math.imul(al8, bl8) | 0;
mid = mid + Math.imul(al8, bh8) | 0;
mid = mid + Math.imul(ah8, bl8) | 0;
hi = hi + Math.imul(ah8, bh8) | 0;
lo = lo + Math.imul(al7, bl9) | 0;
mid = mid + Math.imul(al7, bh9) | 0;
mid = mid + Math.imul(ah7, bl9) | 0;
hi = hi + Math.imul(ah7, bh9) | 0;
var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
w16 &= 67108863;
lo = Math.imul(al9, bl8);
mid = Math.imul(al9, bh8);
mid = mid + Math.imul(ah9, bl8) | 0;
hi = Math.imul(ah9, bh8);
lo = lo + Math.imul(al8, bl9) | 0;
mid = mid + Math.imul(al8, bh9) | 0;
mid = mid + Math.imul(ah8, bl9) | 0;
hi = hi + Math.imul(ah8, bh9) | 0;
var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
w17 &= 67108863;
lo = Math.imul(al9, bl9);
mid = Math.imul(al9, bh9);
mid = mid + Math.imul(ah9, bl9) | 0;
hi = Math.imul(ah9, bh9);
var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
w18 &= 67108863;
o[0] = w0;
o[1] = w1;
o[2] = w2;
o[3] = w3;
o[4] = w4;
o[5] = w5;
o[6] = w6;
o[7] = w7;
o[8] = w8;
o[9] = w9;
o[10] = w10;
o[11] = w11;
o[12] = w12;
o[13] = w13;
o[14] = w14;
o[15] = w15;
o[16] = w16;
o[17] = w17;
o[18] = w18;
if (c !== 0) {
o[19] = c;
out.length++;
}
return out;
};
if (!Math.imul) {
comb10MulTo = smallMulTo;
}
function bigMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
out.length = self2.length + num.length;
var carry = 0;
var hncarry = 0;
for (var k = 0; k < out.length - 1; k++) {
var ncarry = hncarry;
hncarry = 0;
var rword = carry & 67108863;
var maxJ = Math.min(k, num.length - 1);
for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
var i = k - j;
var a = self2.words[i] | 0;
var b = num.words[j] | 0;
var r = a * b;
var lo = r & 67108863;
ncarry = ncarry + (r / 67108864 | 0) | 0;
lo = lo + rword | 0;
rword = lo & 67108863;
ncarry = ncarry + (lo >>> 26) | 0;
hncarry += ncarry >>> 26;
ncarry &= 67108863;
}
out.words[k] = rword;
carry = ncarry;
ncarry = hncarry;
}
if (carry !== 0) {
out.words[k] = carry;
} else {
out.length--;
}
return out.strip();
}
function jumboMulTo(self2, num, out) {
var fftm = new FFTM();
return fftm.mulp(self2, num, out);
}
BN.prototype.mulTo = function mulTo(num, out) {
var res;
var len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = comb10MulTo(this, num, out);
} else if (len < 63) {
res = smallMulTo(this, num, out);
} else if (len < 1024) {
res = bigMulTo(this, num, out);
} else {
res = jumboMulTo(this, num, out);
}
return res;
};
function FFTM(x, y) {
this.x = x;
this.y = y;
}
FFTM.prototype.makeRBT = function makeRBT(N) {
var t = new Array(N);
var l = BN.prototype._countBits(N) - 1;
for (var i = 0; i < N; i++) {
t[i] = this.revBin(i, l, N);
}
return t;
};
FFTM.prototype.revBin = function revBin(x, l, N) {
if (x === 0 || x === N - 1) return x;
var rb = 0;
for (var i = 0; i < l; i++) {
rb |= (x & 1) << l - i - 1;
x >>= 1;
}
return rb;
};
FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
for (var i = 0; i < N; i++) {
rtws[i] = rws[rbt[i]];
itws[i] = iws[rbt[i]];
}
};
FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
this.permute(rbt, rws, iws, rtws, itws, N);
for (var s = 1; s < N; s <<= 1) {
var l = s << 1;
var rtwdf = Math.cos(2 * Math.PI / l);
var itwdf = Math.sin(2 * Math.PI / l);
for (var p = 0; p < N; p += l) {
var rtwdf_ = rtwdf;
var itwdf_ = itwdf;
for (var j = 0; j < s; j++) {
var re = rtws[p + j];
var ie = itws[p + j];
var ro = rtws[p + j + s];
var io = itws[p + j + s];
var rx = rtwdf_ * ro - itwdf_ * io;
io = rtwdf_ * io + itwdf_ * ro;
ro = rx;
rtws[p + j] = re + ro;
itws[p + j] = ie + io;
rtws[p + j + s] = re - ro;
itws[p + j + s] = ie - io;
if (j !== l) {
rx = rtwdf * rtwdf_ - itwdf * itwdf_;
itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
rtwdf_ = rx;
}
}
}
}
};
FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
var N = Math.max(m, n) | 1;
var odd = N & 1;
var i = 0;
for (N = N / 2 | 0; N; N = N >>> 1) {
i++;
}
return 1 << i + 1 + odd;
};
FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
if (N <= 1) return;
for (var i = 0; i < N / 2; i++) {
var t = rws[i];
rws[i] = rws[N - i - 1];
rws[N - i - 1] = t;
t = iws[i];
iws[i] = -iws[N - i - 1];
iws[N - i - 1] = -t;
}
};
FFTM.prototype.normalize13b = function normalize13b(ws, N) {
var carry = 0;
for (var i = 0; i < N / 2; i++) {
var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
ws[i] = w & 67108863;
if (w < 67108864) {
carry = 0;
} else {
carry = w / 67108864 | 0;
}
}
return ws;
};
FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
var carry = 0;
for (var i = 0; i < len; i++) {
carry = carry + (ws[i] | 0);
rws[2 * i] = carry & 8191;
carry = carry >>> 13;
rws[2 * i + 1] = carry & 8191;
carry = carry >>> 13;
}
for (i = 2 * len; i < N; ++i) {
rws[i] = 0;
}
assert(carry === 0);
assert((carry & ~8191) === 0);
};
FFTM.prototype.stub = function stub(N) {
var ph = new Array(N);
for (var i = 0; i < N; i++) {
ph[i] = 0;
}
return ph;
};
FFTM.prototype.mulp = function mulp(x, y, out) {
var N = 2 * this.guessLen13b(x.length, y.length);
var rbt = this.makeRBT(N);
var _ = this.stub(N);
var rws = new Array(N);
var rwst = new Array(N);
var iwst = new Array(N);
var nrws = new Array(N);
var nrwst = new Array(N);
var niwst = new Array(N);
var rmws = out.words;
rmws.length = N;
this.convert13b(x.words, x.length, rws, N);
this.convert13b(y.words, y.length, nrws, N);
this.transform(rws, _, rwst, iwst, N, rbt);
this.transform(nrws, _, nrwst, niwst, N, rbt);
for (var i = 0; i < N; i++) {
var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
rwst[i] = rx;
}
this.conjugate(rwst, iwst, N);
this.transform(rwst, iwst, rmws, _, N, rbt);
this.conjugate(rmws, _, N);
this.normalize13b(rmws, N);
out.negative = x.negative ^ y.negative;
out.length = x.length + y.length;
return out.strip();
};
BN.prototype.mul = function mul(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
};
BN.prototype.mulf = function mulf(num) {
var out = new BN(null);
out.words = new Array(this.length + num.length);
return jumboMulTo(this, num, out);
};
BN.prototype.imul = function imul(num) {
return this.clone().mulTo(num, this);
};
BN.prototype.imuln = function imuln(num) {
assert(typeof num === "number");
assert(num < 67108864);
var carry = 0;
for (var i = 0; i < this.length; i++) {
var w = (this.words[i] | 0) * num;
var lo = (w & 67108863) + (carry & 67108863);
carry >>= 26;
carry += w / 67108864 | 0;
carry += lo >>> 26;
this.words[i] = lo & 67108863;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
this.length = num === 0 ? 1 : this.length;
return this;
};
BN.prototype.muln = function muln(num) {
return this.clone().imuln(num);
};
BN.prototype.sqr = function sqr() {
return this.mul(this);
};
BN.prototype.isqr = function isqr() {
return this.imul(this.clone());
};
BN.prototype.pow = function pow3(num) {
var w = toBitArray(num);
if (w.length === 0) return new BN(1);
var res = this;
for (var i = 0; i < w.length; i++, res = res.sqr()) {
if (w[i] !== 0) break;
}
if (++i < w.length) {
for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
if (w[i] === 0) continue;
res = res.mul(q);
}
}
return res;
};
BN.prototype.iushln = function iushln(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
var carryMask = 67108863 >>> 26 - r << 26 - r;
var i;
if (r !== 0) {
var carry = 0;
for (i = 0; i < this.length; i++) {
var newCarry = this.words[i] & carryMask;
var c = (this.words[i] | 0) - newCarry << r;
this.words[i] = c | carry;
carry = newCarry >>> 26 - r;
}
if (carry) {
this.words[i] = carry;
this.length++;
}
}
if (s !== 0) {
for (i = this.length - 1; i >= 0; i--) {
this.words[i + s] = this.words[i];
}
for (i = 0; i < s; i++) {
this.words[i] = 0;
}
this.length += s;
}
return this.strip();
};
BN.prototype.ishln = function ishln(bits) {
assert(this.negative === 0);
return this.iushln(bits);
};
BN.prototype.iushrn = function iushrn(bits, hint, extended) {
assert(typeof bits === "number" && bits >= 0);
var h;
if (hint) {
h = (hint - hint % 26) / 26;
} else {
h = 0;
}
var r = bits % 26;
var s = Math.min((bits - r) / 26, this.length);
var mask = 67108863 ^ 67108863 >>> r << r;
var maskedWords = extended;
h -= s;
h = Math.max(0, h);
if (maskedWords) {
for (var i = 0; i < s; i++) {
maskedWords.words[i] = this.words[i];
}
maskedWords.length = s;
}
if (s === 0) {
} else if (this.length > s) {
this.length -= s;
for (i = 0; i < this.length; i++) {
this.words[i] = this.words[i + s];
}
} else {
this.words[0] = 0;
this.length = 1;
}
var carry = 0;
for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
var word = this.words[i] | 0;
this.words[i] = carry << 26 - r | word >>> r;
carry = word & mask;
}
if (maskedWords && carry !== 0) {
maskedWords.words[maskedWords.length++] = carry;
}
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
};
BN.prototype.ishrn = function ishrn(bits, hint, extended) {
assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
};
BN.prototype.shln = function shln(bits) {
return this.clone().ishln(bits);
};
BN.prototype.ushln = function ushln(bits) {
return this.clone().iushln(bits);
};
BN.prototype.shrn = function shrn(bits) {
return this.clone().ishrn(bits);
};
BN.prototype.ushrn = function ushrn(bits) {
return this.clone().iushrn(bits);
};
BN.prototype.testn = function testn(bit) {
assert(typeof bit === "number" && bit >= 0);
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) return false;
var w = this.words[s];
return !!(w & q);
};
BN.prototype.imaskn = function imaskn(bits) {
assert(typeof bits === "number" && bits >= 0);
var r = bits % 26;
var s = (bits - r) / 26;
assert(this.negative === 0, "imaskn works only with positive numbers");
if (this.length <= s) {
return this;
}
if (r !== 0) {
s++;
}
this.length = Math.min(s, this.length);
if (r !== 0) {
var mask = 67108863 ^ 67108863 >>> r << r;
this.words[this.length - 1] &= mask;
}
return this.strip();
};
BN.prototype.maskn = function maskn(bits) {
return this.clone().imaskn(bits);
};
BN.prototype.iaddn = function iaddn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.isubn(-num);
if (this.negative !== 0) {
if (this.length === 1 && (this.words[0] | 0) < num) {
this.words[0] = num - (this.words[0] | 0);
this.negative = 0;
return this;
}
this.negative = 0;
this.isubn(num);
this.negative = 1;
return this;
}
return this._iaddn(num);
};
BN.prototype._iaddn = function _iaddn(num) {
this.words[0] += num;
for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
this.words[i] -= 67108864;
if (i === this.length - 1) {
this.words[i + 1] = 1;
} else {
this.words[i + 1]++;
}
}
this.length = Math.max(this.length, i + 1);
return this;
};
BN.prototype.isubn = function isubn(num) {
assert(typeof num === "number");
assert(num < 67108864);
if (num < 0) return this.iaddn(-num);
if (this.negative !== 0) {
this.negative = 0;
this.iaddn(num);
this.negative = 1;
return this;
}
this.words[0] -= num;
if (this.length === 1 && this.words[0] < 0) {
this.words[0] = -this.words[0];
this.negative = 1;
} else {
for (var i = 0; i < this.length && this.words[i] < 0; i++) {
this.words[i] += 67108864;
this.words[i + 1] -= 1;
}
}
return this.strip();
};
BN.prototype.addn = function addn(num) {
return this.clone().iaddn(num);
};
BN.prototype.subn = function subn(num) {
return this.clone().isubn(num);
};
BN.prototype.iabs = function iabs() {
this.negative = 0;
return this;
};
BN.prototype.abs = function abs() {
return this.clone().iabs();
};
BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
var len = num.length + shift;
var i;
this._expand(len);
var w;
var carry = 0;
for (i = 0; i < num.length; i++) {
w = (this.words[i + shift] | 0) + carry;
var right = (num.words[i] | 0) * mul;
w -= right & 67108863;
carry = (w >> 26) - (right / 67108864 | 0);
this.words[i + shift] = w & 67108863;
}
for (; i < this.length - shift; i++) {
w = (this.words[i + shift] | 0) + carry;
carry = w >> 26;
this.words[i + shift] = w & 67108863;
}
if (carry === 0) return this.strip();
assert(carry === -1);
carry = 0;
for (i = 0; i < this.length; i++) {
w = -(this.words[i] | 0) + carry;
carry = w >> 26;
this.words[i] = w & 67108863;
}
this.negative = 1;
return this.strip();
};
BN.prototype._wordDiv = function _wordDiv(num, mode) {
var shift = this.length - num.length;
var a = this.clone();
var b = num;
var bhi = b.words[b.length - 1] | 0;
var bhiBits = this._countBits(bhi);
shift = 26 - bhiBits;
if (shift !== 0) {
b = b.ushln(shift);
a.iushln(shift);
bhi = b.words[b.length - 1] | 0;
}
var m = a.length - b.length;
var q;
if (mode !== "mod") {
q = new BN(null);
q.length = m + 1;
q.words = new Array(q.length);
for (var i = 0; i < q.length; i++) {
q.words[i] = 0;
}
}
var diff = a.clone()._ishlnsubmul(b, 1, m);
if (diff.negative === 0) {
a = diff;
if (q) {
q.words[m] = 1;
}
}
for (var j = m - 1; j >= 0; j--) {
var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
qj = Math.min(qj / bhi | 0, 67108863);
a._ishlnsubmul(b, qj, j);
while (a.negative !== 0) {
qj--;
a.negative = 0;
a._ishlnsubmul(b, 1, j);
if (!a.isZero()) {
a.negative ^= 1;
}
}
if (q) {
q.words[j] = qj;
}
}
if (q) {
q.strip();
}
a.strip();
if (mode !== "div" && shift !== 0) {
a.iushrn(shift);
}
return {
div: q || null,
mod: a
};
};
BN.prototype.divmod = function divmod(num, mode, positive) {
assert(!num.isZero());
if (this.isZero()) {
return {
div: new BN(0),
mod: new BN(0)
};
}
var div, mod2, res;
if (this.negative !== 0 && num.negative === 0) {
res = this.neg().divmod(num, mode);
if (mode !== "mod") {
div = res.div.neg();
}
if (mode !== "div") {
mod2 = res.mod.neg();
if (positive && mod2.negative !== 0) {
mod2.iadd(num);
}
}
return {
div,
mod: mod2
};
}
if (this.negative === 0 && num.negative !== 0) {
res = this.divmod(num.neg(), mode);
if (mode !== "mod") {
div = res.div.neg();
}
return {
div,
mod: res.mod
};
}
if ((this.negative & num.negative) !== 0) {
res = this.neg().divmod(num.neg(), mode);
if (mode !== "div") {
mod2 = res.mod.neg();
if (positive && mod2.negative !== 0) {
mod2.isub(num);
}
}
return {
div: res.div,
mod: mod2
};
}
if (num.length > this.length || this.cmp(num) < 0) {
return {
div: new BN(0),
mod: this
};
}
if (num.length === 1) {
if (mode === "div") {
return {
div: this.divn(num.words[0]),
mod: null
};
}
if (mode === "mod") {
return {
div: null,
mod: new BN(this.modn(num.words[0]))
};
}
return {
div: this.divn(num.words[0]),
mod: new BN(this.modn(num.words[0]))
};
}
return this._wordDiv(num, mode);
};
BN.prototype.div = function div(num) {
return this.divmod(num, "div", false).div;
};
BN.prototype.mod = function mod2(num) {
return this.divmod(num, "mod", false).mod;
};
BN.prototype.umod = function umod(num) {
return this.divmod(num, "mod", true).mod;
};
BN.prototype.divRound = function divRound(num) {
var dm = this.divmod(num);
if (dm.mod.isZero()) return dm.div;
var mod2 = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
var half = num.ushrn(1);
var r2 = num.andln(1);
var cmp = mod2.cmp(half);
if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
};
BN.prototype.modn = function modn(num) {
assert(num <= 67108863);
var p = (1 << 26) % num;
var acc = 0;
for (var i = this.length - 1; i >= 0; i--) {
acc = (p * acc + (this.words[i] | 0)) % num;
}
return acc;
};
BN.prototype.idivn = function idivn(num) {
assert(num <= 67108863);
var carry = 0;
for (var i = this.length - 1; i >= 0; i--) {
var w = (this.words[i] | 0) + carry * 67108864;
this.words[i] = w / num | 0;
carry = w % num;
}
return this.strip();
};
BN.prototype.divn = function divn(num) {
return this.clone().idivn(num);
};
BN.prototype.egcd = function egcd(p) {
assert(p.negative === 0);
assert(!p.isZero());
var x = this;
var y = p.clone();
if (x.negative !== 0) {
x = x.umod(p);
} else {
x = x.clone();
}
var A = new BN(1);
var B = new BN(0);
var C = new BN(0);
var D = new BN(1);
var g = 0;
while (x.isEven() && y.isEven()) {
x.iushrn(1);
y.iushrn(1);
++g;
}
var yp = y.clone();
var xp = x.clone();
while (!x.isZero()) {
for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
x.iushrn(i);
while (i-- > 0) {
if (A.isOdd() || B.isOdd()) {
A.iadd(yp);
B.isub(xp);
}
A.iushrn(1);
B.iushrn(1);
}
}
for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
if (j > 0) {
y.iushrn(j);
while (j-- > 0) {
if (C.isOdd() || D.isOdd()) {
C.iadd(yp);
D.isub(xp);
}
C.iushrn(1);
D.iushrn(1);
}
}
if (x.cmp(y) >= 0) {
x.isub(y);
A.isub(C);
B.isub(D);
} else {
y.isub(x);
C.isub(A);
D.isub(B);
}
}
return {
a: C,
b: D,
gcd: y.iushln(g)
};
};
BN.prototype._invmp = function _invmp(p) {
assert(p.negative === 0);
assert(!p.isZero());
var a = this;
var b = p.clone();
if (a.negative !== 0) {
a = a.umod(p);
} else {
a = a.clone();
}
var x1 = new BN(1);
var x2 = new BN(0);
var delta = b.clone();
while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1) ;
if (i > 0) {
a.iushrn(i);
while (i-- > 0) {
if (x1.isOdd()) {
x1.iadd(delta);
}
x1.iushrn(1);
}
}
for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
if (j > 0) {
b.iushrn(j);
while (j-- > 0) {
if (x2.isOdd()) {
x2.iadd(delta);
}
x2.iushrn(1);
}
}
if (a.cmp(b) >= 0) {
a.isub(b);
x1.isub(x2);
} else {
b.isub(a);
x2.isub(x1);
}
}
var res;
if (a.cmpn(1) === 0) {
res = x1;
} else {
res = x2;
}
if (res.cmpn(0) < 0) {
res.iadd(p);
}
return res;
};
BN.prototype.gcd = function gcd(num) {
if (this.isZero()) return num.abs();
if (num.isZero()) return this.abs();
var a = this.clone();
var b = num.clone();
a.negative = 0;
b.negative = 0;
for (var shift = 0; a.isEven() && b.isEven(); shift++) {
a.iushrn(1);
b.iushrn(1);
}
do {
while (a.isEven()) {
a.iushrn(1);
}
while (b.isEven()) {
b.iushrn(1);
}
var r = a.cmp(b);
if (r < 0) {
var t = a;
a = b;
b = t;
} else if (r === 0 || b.cmpn(1) === 0) {
break;
}
a.isub(b);
} while (true);
return b.iushln(shift);
};
BN.prototype.invm = function invm(num) {
return this.egcd(num).a.umod(num);
};
BN.prototype.isEven = function isEven() {
return (this.words[0] & 1) === 0;
};
BN.prototype.isOdd = function isOdd() {
return (this.words[0] & 1) === 1;
};
BN.prototype.andln = function andln(num) {
return this.words[0] & num;
};
BN.prototype.bincn = function bincn(bit) {
assert(typeof bit === "number");
var r = bit % 26;
var s = (bit - r) / 26;
var q = 1 << r;
if (this.length <= s) {
this._expand(s + 1);
this.words[s] |= q;
return this;
}
var carry = q;
for (var i = s; carry !== 0 && i < this.length; i++) {
var w = this.words[i] | 0;
w += carry;
carry = w >>> 26;
w &= 67108863;
this.words[i] = w;
}
if (carry !== 0) {
this.words[i] = carry;
this.length++;
}
return this;
};
BN.prototype.isZero = function isZero() {
return this.length === 1 && this.words[0] === 0;
};
BN.prototype.cmpn = function cmpn(num) {
var negative = num < 0;
if (this.negative !== 0 && !negative) return -1;
if (this.negative === 0 && negative) return 1;
this.strip();
var res;
if (this.length > 1) {
res = 1;
} else {
if (negative) {
num = -num;
}
assert(num <= 67108863, "Number is too big");
var w = this.words[0] | 0;
res = w === num ? 0 : w < num ? -1 : 1;
}
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.cmp = function cmp(num) {
if (this.negative !== 0 && num.negative === 0) return -1;
if (this.negative === 0 && num.negative !== 0) return 1;
var res = this.ucmp(num);
if (this.negative !== 0) return -res | 0;
return res;
};
BN.prototype.ucmp = function ucmp(num) {
if (this.length > num.length) return 1;
if (this.length < num.length) return -1;
var res = 0;
for (var i = this.length - 1; i >= 0; i--) {
var a = this.words[i] | 0;
var b = num.words[i] | 0;
if (a === b) continue;
if (a < b) {
res = -1;
} else if (a > b) {
res = 1;
}
break;
}
return res;
};
BN.prototype.gtn = function gtn(num) {
return this.cmpn(num) === 1;
};
BN.prototype.gt = function gt(num) {
return this.cmp(num) === 1;
};
BN.prototype.gten = function gten(num) {
return this.cmpn(num) >= 0;
};
BN.prototype.gte = function gte(num) {
return this.cmp(num) >= 0;
};
BN.prototype.ltn = function ltn(num) {
return this.cmpn(num) === -1;
};
BN.prototype.lt = function lt(num) {
return this.cmp(num) === -1;
};
BN.prototype.lten = function lten(num) {
return this.cmpn(num) <= 0;
};
BN.prototype.lte = function lte(num) {
return this.cmp(num) <= 0;
};
BN.prototype.eqn = function eqn(num) {
return this.cmpn(num) === 0;
};
BN.prototype.eq = function eq(num) {
return this.cmp(num) === 0;
};
BN.red = function red(num) {
return new Red(num);
};
BN.prototype.toRed = function toRed(ctx) {
assert(!this.red, "Already a number in reduction context");
assert(this.negative === 0, "red works only with positives");
return ctx.convertTo(this)._forceRed(ctx);
};
BN.prototype.fromRed = function fromRed() {
assert(this.red, "fromRed works only with numbers in reduction context");
return this.red.convertFrom(this);
};
BN.prototype._forceRed = function _forceRed(ctx) {
this.red = ctx;
return this;
};
BN.prototype.forceRed = function forceRed(ctx) {
assert(!this.red, "Already a number in reduction context");
return this._forceRed(ctx);
};
BN.prototype.redAdd = function redAdd(num) {
assert(this.red, "redAdd works only with red numbers");
return this.red.add(this, num);
};
BN.prototype.redIAdd = function redIAdd(num) {
assert(this.red, "redIAdd works only with red numbers");
return this.red.iadd(this, num);
};
BN.prototype.redSub = function redSub(num) {
assert(this.red, "redSub works only with red numbers");
return this.red.sub(this, num);
};
BN.prototype.redISub = function redISub(num) {
assert(this.red, "redISub works only with red numbers");
return this.red.isub(this, num);
};
BN.prototype.redShl = function redShl(num) {
assert(this.red, "redShl works only with red numbers");
return this.red.shl(this, num);
};
BN.prototype.redMul = function redMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.mul(this, num);
};
BN.prototype.redIMul = function redIMul(num) {
assert(this.red, "redMul works only with red numbers");
this.red._verify2(this, num);
return this.red.imul(this, num);
};
BN.prototype.redSqr = function redSqr() {
assert(this.red, "redSqr works only with red numbers");
this.red._verify1(this);
return this.red.sqr(this);
};
BN.prototype.redISqr = function redISqr() {
assert(this.red, "redISqr works only with red numbers");
this.red._verify1(this);
return this.red.isqr(this);
};
BN.prototype.redSqrt = function redSqrt() {
assert(this.red, "redSqrt works only with red numbers");
this.red._verify1(this);
return this.red.sqrt(this);
};
BN.prototype.redInvm = function redInvm() {
assert(this.red, "redInvm works only with red numbers");
this.red._verify1(this);
return this.red.invm(this);
};
BN.prototype.redNeg = function redNeg() {
assert(this.red, "redNeg works only with red numbers");
this.red._verify1(this);
return this.red.neg(this);
};
BN.prototype.redPow = function redPow(num) {
assert(this.red && !num.red, "redPow(normalNum)");
this.red._verify1(this);
return this.red.pow(this, num);
};
var primes = {
k256: null,
p224: null,
p192: null,
p25519: null
};
function MPrime(name, p) {
this.name = name;
this.p = new BN(p, 16);
this.n = this.p.bitLength();
this.k = new BN(1).iushln(this.n).isub(this.p);
this.tmp = this._tmp();
}
MPrime.prototype._tmp = function _tmp() {
var tmp = new BN(null);
tmp.words = new Array(Math.ceil(this.n / 13));
return tmp;
};
MPrime.prototype.ireduce = function ireduce(num) {
var r = num;
var rlen;
do {
this.split(r, this.tmp);
r = this.imulK(r);
r = r.iadd(this.tmp);
rlen = r.bitLength();
} while (rlen > this.n);
var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
if (cmp === 0) {
r.words[0] = 0;
r.length = 1;
} else if (cmp > 0) {
r.isub(this.p);
} else {
if (r.strip !== void 0) {
r.strip();
} else {
r._strip();
}
}
return r;
};
MPrime.prototype.split = function split2(input, out) {
input.iushrn(this.n, 0, out);
};
MPrime.prototype.imulK = function imulK(num) {
return num.imul(this.k);
};
function K256() {
MPrime.call(
this,
"k256",
"ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
);
}
inherits(K256, MPrime);
K256.prototype.split = function split2(input, output) {
var mask = 4194303;
var outLen = Math.min(input.length, 9);
for (var i = 0; i < outLen; i++) {
output.words[i] = input.words[i];
}
output.length = outLen;
if (input.length <= 9) {
input.words[0] = 0;
input.length = 1;
return;
}
var prev = input.words[9];
output.words[output.length++] = prev & mask;
for (i = 10; i < input.length; i++) {
var next = input.words[i] | 0;
input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
prev = next;
}
prev >>>= 22;
input.words[i - 10] = prev;
if (prev === 0 && input.length > 10) {
input.length -= 10;
} else {
input.length -= 9;
}
};
K256.prototype.imulK = function imulK(num) {
num.words[num.length] = 0;
num.words[num.length + 1] = 0;
num.length += 2;
var lo = 0;
for (var i = 0; i < num.length; i++) {
var w = num.words[i] | 0;
lo += w * 977;
num.words[i] = lo & 67108863;
lo = w * 64 + (lo / 67108864 | 0);
}
if (num.words[num.length - 1] === 0) {
num.length--;
if (num.words[num.length - 1] === 0) {
num.length--;
}
}
return num;
};
function P224() {
MPrime.call(
this,
"p224",
"ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
);
}
inherits(P224, MPrime);
function P192() {
MPrime.call(
this,
"p192",
"ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
);
}
inherits(P192, MPrime);
function P25519() {
MPrime.call(
this,
"25519",
"7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
);
}
inherits(P25519, MPrime);
P25519.prototype.imulK = function imulK(num) {
var carry = 0;
for (var i = 0; i < num.length; i++) {
var hi = (num.words[i] | 0) * 19 + carry;
var lo = hi & 67108863;
hi >>>= 26;
num.words[i] = lo;
carry = hi;
}
if (carry !== 0) {
num.words[num.length++] = carry;
}
return num;
};
BN._prime = function prime(name) {
if (primes[name]) return primes[name];
var prime2;
if (name === "k256") {
prime2 = new K256();
} else if (name === "p224") {
prime2 = new P224();
} else if (name === "p192") {
prime2 = new P192();
} else if (name === "p25519") {
prime2 = new P25519();
} else {
throw new Error("Unknown prime " + name);
}
primes[name] = prime2;
return prime2;
};
function Red(m) {
if (typeof m === "string") {
var prime = BN._prime(m);
this.m = prime.p;
this.prime = prime;
} else {
assert(m.gtn(1), "modulus must be greater than 1");
this.m = m;
this.prime = null;
}
}
Red.prototype._verify1 = function _verify1(a) {
assert(a.negative === 0, "red works only with positives");
assert(a.red, "red works only with red numbers");
};
Red.prototype._verify2 = function _verify2(a, b) {
assert((a.negative | b.negative) === 0, "red works only with positives");
assert(
a.red && a.red === b.red,
"red works only with red numbers"
);
};
Red.prototype.imod = function imod(a) {
if (this.prime) return this.prime.ireduce(a)._forceRed(this);
return a.umod(this.m)._forceRed(this);
};
Red.prototype.neg = function neg(a) {
if (a.isZero()) {
return a.clone();
}
return this.m.sub(a)._forceRed(this);
};
Red.prototype.add = function add2(a, b) {
this._verify2(a, b);
var res = a.add(b);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res._forceRed(this);
};
Red.prototype.iadd = function iadd(a, b) {
this._verify2(a, b);
var res = a.iadd(b);
if (res.cmp(this.m) >= 0) {
res.isub(this.m);
}
return res;
};
Red.prototype.sub = function sub(a, b) {
this._verify2(a, b);
var res = a.sub(b);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res._forceRed(this);
};
Red.prototype.isub = function isub(a, b) {
this._verify2(a, b);
var res = a.isub(b);
if (res.cmpn(0) < 0) {
res.iadd(this.m);
}
return res;
};
Red.prototype.shl = function shl(a, num) {
this._verify1(a);
return this.imod(a.ushln(num));
};
Red.prototype.imul = function imul(a, b) {
this._verify2(a, b);
return this.imod(a.imul(b));
};
Red.prototype.mul = function mul(a, b) {
this._verify2(a, b);
return this.imod(a.mul(b));
};
Red.prototype.isqr = function isqr(a) {
return this.imul(a, a.clone());
};
Red.prototype.sqr = function sqr(a) {
return this.mul(a, a);
};
Red.prototype.sqrt = function sqrt(a) {
if (a.isZero()) return a.clone();
var mod3 = this.m.andln(3);
assert(mod3 % 2 === 1);
if (mod3 === 3) {
var pow3 = this.m.add(new BN(1)).iushrn(2);
return this.pow(a, pow3);
}
var q = this.m.subn(1);
var s = 0;
while (!q.isZero() && q.andln(1) === 0) {
s++;
q.iushrn(1);
}
assert(!q.isZero());
var one = new BN(1).toRed(this);
var nOne = one.redNeg();
var lpow = this.m.subn(1).iushrn(1);
var z = this.m.bitLength();
z = new BN(2 * z * z).toRed(this);
while (this.pow(z, lpow).cmp(nOne) !== 0) {
z.redIAdd(nOne);
}
var c = this.pow(z, q);
var r = this.pow(a, q.addn(1).iushrn(1));
var t = this.pow(a, q);
var m = s;
while (t.cmp(one) !== 0) {
var tmp = t;
for (var i = 0; tmp.cmp(one) !== 0; i++) {
tmp = tmp.redSqr();
}
assert(i < m);
var b = this.pow(c, new BN(1).iushln(m - i - 1));
r = r.redMul(b);
c = b.redSqr();
t = t.redMul(c);
m = i;
}
return r;
};
Red.prototype.invm = function invm(a) {
var inv = a._invmp(this.m);
if (inv.negative !== 0) {
inv.negative = 0;
return this.imod(inv).redNeg();
} else {
return this.imod(inv);
}
};
Red.prototype.pow = function pow3(a, num) {
if (num.isZero()) return new BN(1).toRed(this);
if (num.cmpn(1) === 0) return a.clone();
var windowSize = 4;
var wnd = new Array(1 << windowSize);
wnd[0] = new BN(1).toRed(this);
wnd[1] = a;
for (var i = 2; i < wnd.length; i++) {
wnd[i] = this.mul(wnd[i - 1], a);
}
var res = wnd[0];
var current = 0;
var currentLen = 0;
var start = num.bitLength() % 26;
if (start === 0) {
start = 26;
}
for (i = num.length - 1; i >= 0; i--) {
var word = num.words[i];
for (var j = start - 1; j >= 0; j--) {
var bit = word >> j & 1;
if (res !== wnd[0]) {
res = this.sqr(res);
}
if (bit === 0 && current === 0) {
currentLen = 0;
continue;
}
current <<= 1;
current |= bit;
currentLen++;
if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
res = this.mul(res, wnd[current]);
currentLen = 0;
current = 0;
}
start = 26;
}
return res;
};
Red.prototype.convertTo = function convertTo(num) {
var r = num.umod(this.m);
return r === num ? r.clone() : r;
};
Red.prototype.convertFrom = function convertFrom(num) {
var res = num.clone();
res.red = null;
return res;
};
BN.mont = function mont(num) {
return new Mont(num);
};
function Mont(m) {
Red.call(this, m);
this.shift = this.m.bitLength();
if (this.shift % 26 !== 0) {
this.shift += 26 - this.shift % 26;
}
this.r = new BN(1).iushln(this.shift);
this.r2 = this.imod(this.r.sqr());
this.rinv = this.r._invmp(this.m);
this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
this.minv = this.minv.umod(this.r);
this.minv = this.r.sub(this.minv);
}
inherits(Mont, Red);
Mont.prototype.convertTo = function convertTo(num) {
return this.imod(num.ushln(this.shift));
};
Mont.prototype.convertFrom = function convertFrom(num) {
var r = this.imod(num.mul(this.rinv));
r.red = null;
return r;
};
Mont.prototype.imul = function imul(a, b) {
if (a.isZero() || b.isZero()) {
a.words[0] = 0;
a.length = 1;
return a;
}
var t = a.imul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) {
res = u.isub(this.m);
} else if (u.cmpn(0) < 0) {
res = u.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.mul = function mul(a, b) {
if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
var t = a.mul(b);
var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
var u = t.isub(c).iushrn(this.shift);
var res = u;
if (u.cmp(this.m) >= 0) {
res = u.isub(this.m);
} else if (u.cmpn(0) < 0) {
res = u.iadd(this.m);
}
return res._forceRed(this);
};
Mont.prototype.invm = function invm(a) {
var res = this.imod(a._invmp(this.m).mul(this.r2));
return res._forceRed(this);
};
})(typeof module2 === "undefined" || module2, exports2);
}
});
// node_modules/minimalistic-assert/index.js
var require_minimalistic_assert = __commonJS({
"node_modules/minimalistic-assert/index.js"(exports2, module2) {
module2.exports = assert;
function assert(val, msg) {
if (!val)
throw new Error(msg || "Assertion failed");
}
assert.equal = function assertEqual(l, r, msg) {
if (l != r)
throw new Error(msg || "Assertion failed: " + l + " != " + r);
};
}
});
// node_modules/minimalistic-crypto-utils/lib/utils.js
var require_utils2 = __commonJS({
"node_modules/minimalistic-crypto-utils/lib/utils.js"(exports2) {
"use strict";
var utils = exports2;
function toArray(msg, enc) {
if (Array.isArray(msg))
return msg.slice();
if (!msg)
return [];
var res = [];
if (typeof msg !== "string") {
for (var i = 0; i < msg.length; i++)
res[i] = msg[i] | 0;
return res;
}
if (enc === "hex") {
msg = msg.replace(/[^a-z0-9]+/ig, "");
if (msg.length % 2 !== 0)
msg = "0" + msg;
for (var i = 0; i < msg.length; i += 2)
res.push(parseInt(msg[i] + msg[i + 1], 16));
} else {
for (var i = 0; i < msg.length; i++) {
var c = msg.charCodeAt(i);
var hi = c >> 8;
var lo = c & 255;
if (hi)
res.push(hi, lo);
else
res.push(lo);
}
}
return res;
}
utils.toArray = toArray;
function zero2(word) {
if (word.length === 1)
return "0" + word;
else
return word;
}
utils.zero2 = zero2;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++)
res += zero2(msg[i].toString(16));
return res;
}
utils.toHex = toHex;
utils.encode = function encode(arr, enc) {
if (enc === "hex")
return toHex(arr);
else
return arr;
};
}
});
// node_modules/elliptic/lib/elliptic/utils.js
var require_utils3 = __commonJS({
"node_modules/elliptic/lib/elliptic/utils.js"(exports2) {
"use strict";
var utils = exports2;
var BN = require_bn();
var minAssert = require_minimalistic_assert();
var minUtils = require_utils2();
utils.assert = minAssert;
utils.toArray = minUtils.toArray;
utils.zero2 = minUtils.zero2;
utils.toHex = minUtils.toHex;
utils.encode = minUtils.encode;
function getNAF(num, w, bits) {
var naf = new Array(Math.max(num.bitLength(), bits) + 1);
var i;
for (i = 0; i < naf.length; i += 1) {
naf[i] = 0;
}
var ws = 1 << w + 1;
var k = num.clone();
for (i = 0; i < naf.length; i++) {
var z;
var mod2 = k.andln(ws - 1);
if (k.isOdd()) {
if (mod2 > (ws >> 1) - 1)
z = (ws >> 1) - mod2;
else
z = mod2;
k.isubn(z);
} else {
z = 0;
}
naf[i] = z;
k.iushrn(1);
}
return naf;
}
utils.getNAF = getNAF;
function getJSF(k1, k2) {
var jsf = [
[],
[]
];
k1 = k1.clone();
k2 = k2.clone();
var d1 = 0;
var d2 = 0;
var m8;
while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
var m14 = k1.andln(3) + d1 & 3;
var m24 = k2.andln(3) + d2 & 3;
if (m14 === 3)
m14 = -1;
if (m24 === 3)
m24 = -1;
var u1;
if ((m14 & 1) === 0) {
u1 = 0;
} else {
m8 = k1.andln(7) + d1 & 7;
if ((m8 === 3 || m8 === 5) && m24 === 2)
u1 = -m14;
else
u1 = m14;
}
jsf[0].push(u1);
var u2;
if ((m24 & 1) === 0) {
u2 = 0;
} else {
m8 = k2.andln(7) + d2 & 7;
if ((m8 === 3 || m8 === 5) && m14 === 2)
u2 = -m24;
else
u2 = m24;
}
jsf[1].push(u2);
if (2 * d1 === u1 + 1)
d1 = 1 - d1;
if (2 * d2 === u2 + 1)
d2 = 1 - d2;
k1.iushrn(1);
k2.iushrn(1);
}
return jsf;
}
utils.getJSF = getJSF;
function cachedProperty(obj, name, computer) {
var key = "_" + name;
obj.prototype[name] = function cachedProperty2() {
return this[key] !== void 0 ? this[key] : this[key] = computer.call(this);
};
}
utils.cachedProperty = cachedProperty;
function parseBytes(bytes) {
return typeof bytes === "string" ? utils.toArray(bytes, "hex") : bytes;
}
utils.parseBytes = parseBytes;
function intFromLE(bytes) {
return new BN(bytes, "hex", "le");
}
utils.intFromLE = intFromLE;
}
});
// node_modules/brorand/index.js
var require_brorand = __commonJS({
"node_modules/brorand/index.js"(exports2, module2) {
var r;
module2.exports = function rand(len) {
if (!r)
r = new Rand(null);
return r.generate(len);
};
function Rand(rand) {
this.rand = rand;
}
module2.exports.Rand = Rand;
Rand.prototype.generate = function generate(len) {
return this._rand(len);
};
Rand.prototype._rand = function _rand(n) {
if (this.rand.getBytes)
return this.rand.getBytes(n);
var res = new Uint8Array(n);
for (var i = 0; i < res.length; i++)
res[i] = this.rand.getByte();
return res;
};
if (typeof self === "object") {
if (self.crypto && self.crypto.getRandomValues) {
Rand.prototype._rand = function _rand(n) {
var arr = new Uint8Array(n);
self.crypto.getRandomValues(arr);
return arr;
};
} else if (self.msCrypto && self.msCrypto.getRandomValues) {
Rand.prototype._rand = function _rand(n) {
var arr = new Uint8Array(n);
self.msCrypto.getRandomValues(arr);
return arr;
};
} else if (typeof window === "object") {
Rand.prototype._rand = function() {
throw new Error("Not implemented yet");
};
}
} else {
try {
crypto4 = require("crypto");
if (typeof crypto4.randomBytes !== "function")
throw new Error("Not supported");
Rand.prototype._rand = function _rand(n) {
return crypto4.randomBytes(n);
};
} catch (e) {
}
}
var crypto4;
}
});
// node_modules/elliptic/lib/elliptic/curve/base.js
var require_base = __commonJS({
"node_modules/elliptic/lib/elliptic/curve/base.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var utils = require_utils3();
var getNAF = utils.getNAF;
var getJSF = utils.getJSF;
var assert = utils.assert;
function BaseCurve(type, conf) {
this.type = type;
this.p = new BN(conf.p, 16);
this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
this.zero = new BN(0).toRed(this.red);
this.one = new BN(1).toRed(this.red);
this.two = new BN(2).toRed(this.red);
this.n = conf.n && new BN(conf.n, 16);
this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
this._wnafT1 = new Array(4);
this._wnafT2 = new Array(4);
this._wnafT3 = new Array(4);
this._wnafT4 = new Array(4);
this._bitLength = this.n ? this.n.bitLength() : 0;
var adjustCount = this.n && this.p.div(this.n);
if (!adjustCount || adjustCount.cmpn(100) > 0) {
this.redN = null;
} else {
this._maxwellTrick = true;
this.redN = this.n.toRed(this.red);
}
}
module2.exports = BaseCurve;
BaseCurve.prototype.point = function point() {
throw new Error("Not implemented");
};
BaseCurve.prototype.validate = function validate() {
throw new Error("Not implemented");
};
BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
assert(p.precomputed);
var doubles = p._getDoubles();
var naf = getNAF(k, 1, this._bitLength);
var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
I /= 3;
var repr = [];
var j;
var nafW;
for (j = 0; j < naf.length; j += doubles.step) {
nafW = 0;
for (var l = j + doubles.step - 1; l >= j; l--)
nafW = (nafW << 1) + naf[l];
repr.push(nafW);
}
var a = this.jpoint(null, null, null);
var b = this.jpoint(null, null, null);
for (var i = I; i > 0; i--) {
for (j = 0; j < repr.length; j++) {
nafW = repr[j];
if (nafW === i)
b = b.mixedAdd(doubles.points[j]);
else if (nafW === -i)
b = b.mixedAdd(doubles.points[j].neg());
}
a = a.add(b);
}
return a.toP();
};
BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
var w = 4;
var nafPoints = p._getNAFPoints(w);
w = nafPoints.wnd;
var wnd = nafPoints.points;
var naf = getNAF(k, w, this._bitLength);
var acc = this.jpoint(null, null, null);
for (var i = naf.length - 1; i >= 0; i--) {
for (var l = 0; i >= 0 && naf[i] === 0; i--)
l++;
if (i >= 0)
l++;
acc = acc.dblp(l);
if (i < 0)
break;
var z = naf[i];
assert(z !== 0);
if (p.type === "affine") {
if (z > 0)
acc = acc.mixedAdd(wnd[z - 1 >> 1]);
else
acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
} else {
if (z > 0)
acc = acc.add(wnd[z - 1 >> 1]);
else
acc = acc.add(wnd[-z - 1 >> 1].neg());
}
}
return p.type === "affine" ? acc.toP() : acc;
};
BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
var wndWidth = this._wnafT1;
var wnd = this._wnafT2;
var naf = this._wnafT3;
var max = 0;
var i;
var j;
var p;
for (i = 0; i < len; i++) {
p = points[i];
var nafPoints = p._getNAFPoints(defW);
wndWidth[i] = nafPoints.wnd;
wnd[i] = nafPoints.points;
}
for (i = len - 1; i >= 1; i -= 2) {
var a = i - 1;
var b = i;
if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);
naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);
max = Math.max(naf[a].length, max);
max = Math.max(naf[b].length, max);
continue;
}
var comb = [
points[a],
/* 1 */
null,
/* 3 */
null,
/* 5 */
points[b]
/* 7 */
];
if (points[a].y.cmp(points[b].y) === 0) {
comb[1] = points[a].add(points[b]);
comb[2] = points[a].toJ().mixedAdd(points[b].neg());
} else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
comb[1] = points[a].toJ().mixedAdd(points[b]);
comb[2] = points[a].add(points[b].neg());
} else {
comb[1] = points[a].toJ().mixedAdd(points[b]);
comb[2] = points[a].toJ().mixedAdd(points[b].neg());
}
var index = [
-3,
/* -1 -1 */
-1,
/* -1 0 */
-5,
/* -1 1 */
-7,
/* 0 -1 */
0,
/* 0 0 */
7,
/* 0 1 */
5,
/* 1 -1 */
1,
/* 1 0 */
3
/* 1 1 */
];
var jsf = getJSF(coeffs[a], coeffs[b]);
max = Math.max(jsf[0].length, max);
naf[a] = new Array(max);
naf[b] = new Array(max);
for (j = 0; j < max; j++) {
var ja = jsf[0][j] | 0;
var jb = jsf[1][j] | 0;
naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
naf[b][j] = 0;
wnd[a] = comb;
}
}
var acc = this.jpoint(null, null, null);
var tmp = this._wnafT4;
for (i = max; i >= 0; i--) {
var k = 0;
while (i >= 0) {
var zero = true;
for (j = 0; j < len; j++) {
tmp[j] = naf[j][i] | 0;
if (tmp[j] !== 0)
zero = false;
}
if (!zero)
break;
k++;
i--;
}
if (i >= 0)
k++;
acc = acc.dblp(k);
if (i < 0)
break;
for (j = 0; j < len; j++) {
var z = tmp[j];
p;
if (z === 0)
continue;
else if (z > 0)
p = wnd[j][z - 1 >> 1];
else if (z < 0)
p = wnd[j][-z - 1 >> 1].neg();
if (p.type === "affine")
acc = acc.mixedAdd(p);
else
acc = acc.add(p);
}
}
for (i = 0; i < len; i++)
wnd[i] = null;
if (jacobianResult)
return acc;
else
return acc.toP();
};
function BasePoint(curve, type) {
this.curve = curve;
this.type = type;
this.precomputed = null;
}
BaseCurve.BasePoint = BasePoint;
BasePoint.prototype.eq = function eq() {
throw new Error("Not implemented");
};
BasePoint.prototype.validate = function validate() {
return this.curve.validate(this);
};
BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
bytes = utils.toArray(bytes, enc);
var len = this.p.byteLength();
if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len) {
if (bytes[0] === 6)
assert(bytes[bytes.length - 1] % 2 === 0);
else if (bytes[0] === 7)
assert(bytes[bytes.length - 1] % 2 === 1);
var res = this.point(
bytes.slice(1, 1 + len),
bytes.slice(1 + len, 1 + 2 * len)
);
return res;
} else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len) {
return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 3);
}
throw new Error("Unknown point format");
};
BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
return this.encode(enc, true);
};
BasePoint.prototype._encode = function _encode(compact) {
var len = this.curve.p.byteLength();
var x = this.getX().toArray("be", len);
if (compact)
return [this.getY().isEven() ? 2 : 3].concat(x);
return [4].concat(x, this.getY().toArray("be", len));
};
BasePoint.prototype.encode = function encode(enc, compact) {
return utils.encode(this._encode(compact), enc);
};
BasePoint.prototype.precompute = function precompute(power) {
if (this.precomputed)
return this;
var precomputed = {
doubles: null,
naf: null,
beta: null
};
precomputed.naf = this._getNAFPoints(8);
precomputed.doubles = this._getDoubles(4, power);
precomputed.beta = this._getBeta();
this.precomputed = precomputed;
return this;
};
BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
if (!this.precomputed)
return false;
var doubles = this.precomputed.doubles;
if (!doubles)
return false;
return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
};
BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
if (this.precomputed && this.precomputed.doubles)
return this.precomputed.doubles;
var doubles = [this];
var acc = this;
for (var i = 0; i < power; i += step) {
for (var j = 0; j < step; j++)
acc = acc.dbl();
doubles.push(acc);
}
return {
step,
points: doubles
};
};
BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
if (this.precomputed && this.precomputed.naf)
return this.precomputed.naf;
var res = [this];
var max = (1 << wnd) - 1;
var dbl = max === 1 ? null : this.dbl();
for (var i = 1; i < max; i++)
res[i] = res[i - 1].add(dbl);
return {
wnd,
points: res
};
};
BasePoint.prototype._getBeta = function _getBeta() {
return null;
};
BasePoint.prototype.dblp = function dblp(k) {
var r = this;
for (var i = 0; i < k; i++)
r = r.dbl();
return r;
};
}
});
// node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
"node_modules/inherits/inherits_browser.js"(exports2, module2) {
if (typeof Object.create === "function") {
module2.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
};
} else {
module2.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function() {
};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}
}
});
// node_modules/inherits/inherits.js
var require_inherits = __commonJS({
"node_modules/inherits/inherits.js"(exports2, module2) {
try {
util = require("util");
if (typeof util.inherits !== "function") throw "";
module2.exports = util.inherits;
} catch (e) {
module2.exports = require_inherits_browser();
}
var util;
}
});
// node_modules/elliptic/lib/elliptic/curve/short.js
var require_short = __commonJS({
"node_modules/elliptic/lib/elliptic/curve/short.js"(exports2, module2) {
"use strict";
var utils = require_utils3();
var BN = require_bn();
var inherits = require_inherits();
var Base = require_base();
var assert = utils.assert;
function ShortCurve(conf) {
Base.call(this, "short", conf);
this.a = new BN(conf.a, 16).toRed(this.red);
this.b = new BN(conf.b, 16).toRed(this.red);
this.tinv = this.two.redInvm();
this.zeroA = this.a.fromRed().cmpn(0) === 0;
this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
this.endo = this._getEndomorphism(conf);
this._endoWnafT1 = new Array(4);
this._endoWnafT2 = new Array(4);
}
inherits(ShortCurve, Base);
module2.exports = ShortCurve;
ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
return;
var beta;
var lambda;
if (conf.beta) {
beta = new BN(conf.beta, 16).toRed(this.red);
} else {
var betas = this._getEndoRoots(this.p);
beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
beta = beta.toRed(this.red);
}
if (conf.lambda) {
lambda = new BN(conf.lambda, 16);
} else {
var lambdas = this._getEndoRoots(this.n);
if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
lambda = lambdas[0];
} else {
lambda = lambdas[1];
assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
}
}
var basis;
if (conf.basis) {
basis = conf.basis.map(function(vec) {
return {
a: new BN(vec.a, 16),
b: new BN(vec.b, 16)
};
});
} else {
basis = this._getEndoBasis(lambda);
}
return {
beta,
lambda,
basis
};
};
ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
var red = num === this.p ? this.red : BN.mont(num);
var tinv = new BN(2).toRed(red).redInvm();
var ntinv = tinv.redNeg();
var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
var l1 = ntinv.redAdd(s).fromRed();
var l2 = ntinv.redSub(s).fromRed();
return [l1, l2];
};
ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
var u = lambda;
var v = this.n.clone();
var x1 = new BN(1);
var y1 = new BN(0);
var x2 = new BN(0);
var y2 = new BN(1);
var a0;
var b0;
var a1;
var b1;
var a2;
var b2;
var prevR;
var i = 0;
var r;
var x;
while (u.cmpn(0) !== 0) {
var q = v.div(u);
r = v.sub(q.mul(u));
x = x2.sub(q.mul(x1));
var y = y2.sub(q.mul(y1));
if (!a1 && r.cmp(aprxSqrt) < 0) {
a0 = prevR.neg();
b0 = x1;
a1 = r.neg();
b1 = x;
} else if (a1 && ++i === 2) {
break;
}
prevR = r;
v = u;
u = r;
x2 = x1;
x1 = x;
y2 = y1;
y1 = y;
}
a2 = r.neg();
b2 = x;
var len1 = a1.sqr().add(b1.sqr());
var len2 = a2.sqr().add(b2.sqr());
if (len2.cmp(len1) >= 0) {
a2 = a0;
b2 = b0;
}
if (a1.negative) {
a1 = a1.neg();
b1 = b1.neg();
}
if (a2.negative) {
a2 = a2.neg();
b2 = b2.neg();
}
return [
{ a: a1, b: b1 },
{ a: a2, b: b2 }
];
};
ShortCurve.prototype._endoSplit = function _endoSplit(k) {
var basis = this.endo.basis;
var v1 = basis[0];
var v2 = basis[1];
var c1 = v2.b.mul(k).divRound(this.n);
var c2 = v1.b.neg().mul(k).divRound(this.n);
var p1 = c1.mul(v1.a);
var p2 = c2.mul(v2.a);
var q1 = c1.mul(v1.b);
var q2 = c2.mul(v2.b);
var k1 = k.sub(p1).sub(p2);
var k2 = q1.add(q2).neg();
return { k1, k2 };
};
ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
x = new BN(x, 16);
if (!x.red)
x = x.toRed(this.red);
var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
var y = y2.redSqrt();
if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
throw new Error("invalid point");
var isOdd = y.fromRed().isOdd();
if (odd && !isOdd || !odd && isOdd)
y = y.redNeg();
return this.point(x, y);
};
ShortCurve.prototype.validate = function validate(point) {
if (point.inf)
return true;
var x = point.x;
var y = point.y;
var ax = this.a.redMul(x);
var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
return y.redSqr().redISub(rhs).cmpn(0) === 0;
};
ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
var npoints = this._endoWnafT1;
var ncoeffs = this._endoWnafT2;
for (var i = 0; i < points.length; i++) {
var split2 = this._endoSplit(coeffs[i]);
var p = points[i];
var beta = p._getBeta();
if (split2.k1.negative) {
split2.k1.ineg();
p = p.neg(true);
}
if (split2.k2.negative) {
split2.k2.ineg();
beta = beta.neg(true);
}
npoints[i * 2] = p;
npoints[i * 2 + 1] = beta;
ncoeffs[i * 2] = split2.k1;
ncoeffs[i * 2 + 1] = split2.k2;
}
var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);
for (var j = 0; j < i * 2; j++) {
npoints[j] = null;
ncoeffs[j] = null;
}
return res;
};
function Point(curve, x, y, isRed) {
Base.BasePoint.call(this, curve, "affine");
if (x === null && y === null) {
this.x = null;
this.y = null;
this.inf = true;
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
if (isRed) {
this.x.forceRed(this.curve.red);
this.y.forceRed(this.curve.red);
}
if (!this.x.red)
this.x = this.x.toRed(this.curve.red);
if (!this.y.red)
this.y = this.y.toRed(this.curve.red);
this.inf = false;
}
}
inherits(Point, Base.BasePoint);
ShortCurve.prototype.point = function point(x, y, isRed) {
return new Point(this, x, y, isRed);
};
ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
return Point.fromJSON(this, obj, red);
};
Point.prototype._getBeta = function _getBeta() {
if (!this.curve.endo)
return;
var pre = this.precomputed;
if (pre && pre.beta)
return pre.beta;
var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
if (pre) {
var curve = this.curve;
var endoMul = function(p) {
return curve.point(p.x.redMul(curve.endo.beta), p.y);
};
pre.beta = beta;
beta.precomputed = {
beta: null,
naf: pre.naf && {
wnd: pre.naf.wnd,
points: pre.naf.points.map(endoMul)
},
doubles: pre.doubles && {
step: pre.doubles.step,
points: pre.doubles.points.map(endoMul)
}
};
}
return beta;
};
Point.prototype.toJSON = function toJSON() {
if (!this.precomputed)
return [this.x, this.y];
return [this.x, this.y, this.precomputed && {
doubles: this.precomputed.doubles && {
step: this.precomputed.doubles.step,
points: this.precomputed.doubles.points.slice(1)
},
naf: this.precomputed.naf && {
wnd: this.precomputed.naf.wnd,
points: this.precomputed.naf.points.slice(1)
}
}];
};
Point.fromJSON = function fromJSON(curve, obj, red) {
if (typeof obj === "string")
obj = JSON.parse(obj);
var res = curve.point(obj[0], obj[1], red);
if (!obj[2])
return res;
function obj2point(obj2) {
return curve.point(obj2[0], obj2[1], red);
}
var pre = obj[2];
res.precomputed = {
beta: null,
doubles: pre.doubles && {
step: pre.doubles.step,
points: [res].concat(pre.doubles.points.map(obj2point))
},
naf: pre.naf && {
wnd: pre.naf.wnd,
points: [res].concat(pre.naf.points.map(obj2point))
}
};
return res;
};
Point.prototype.inspect = function inspect() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
};
Point.prototype.isInfinity = function isInfinity() {
return this.inf;
};
Point.prototype.add = function add2(p) {
if (this.inf)
return p;
if (p.inf)
return this;
if (this.eq(p))
return this.dbl();
if (this.neg().eq(p))
return this.curve.point(null, null);
if (this.x.cmp(p.x) === 0)
return this.curve.point(null, null);
var c = this.y.redSub(p.y);
if (c.cmpn(0) !== 0)
c = c.redMul(this.x.redSub(p.x).redInvm());
var nx = c.redSqr().redISub(this.x).redISub(p.x);
var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
return this.curve.point(nx, ny);
};
Point.prototype.dbl = function dbl() {
if (this.inf)
return this;
var ys1 = this.y.redAdd(this.y);
if (ys1.cmpn(0) === 0)
return this.curve.point(null, null);
var a = this.curve.a;
var x2 = this.x.redSqr();
var dyinv = ys1.redInvm();
var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
var nx = c.redSqr().redISub(this.x.redAdd(this.x));
var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
return this.curve.point(nx, ny);
};
Point.prototype.getX = function getX() {
return this.x.fromRed();
};
Point.prototype.getY = function getY() {
return this.y.fromRed();
};
Point.prototype.mul = function mul(k) {
k = new BN(k, 16);
if (this.isInfinity())
return this;
else if (this._hasDoubles(k))
return this.curve._fixedNafMul(this, k);
else if (this.curve.endo)
return this.curve._endoWnafMulAdd([this], [k]);
else
return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
var points = [this, p2];
var coeffs = [k1, k2];
if (this.curve.endo)
return this.curve._endoWnafMulAdd(points, coeffs);
else
return this.curve._wnafMulAdd(1, points, coeffs, 2);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
var points = [this, p2];
var coeffs = [k1, k2];
if (this.curve.endo)
return this.curve._endoWnafMulAdd(points, coeffs, true);
else
return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
};
Point.prototype.eq = function eq(p) {
return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
};
Point.prototype.neg = function neg(_precompute) {
if (this.inf)
return this;
var res = this.curve.point(this.x, this.y.redNeg());
if (_precompute && this.precomputed) {
var pre = this.precomputed;
var negate = function(p) {
return p.neg();
};
res.precomputed = {
naf: pre.naf && {
wnd: pre.naf.wnd,
points: pre.naf.points.map(negate)
},
doubles: pre.doubles && {
step: pre.doubles.step,
points: pre.doubles.points.map(negate)
}
};
}
return res;
};
Point.prototype.toJ = function toJ() {
if (this.inf)
return this.curve.jpoint(null, null, null);
var res = this.curve.jpoint(this.x, this.y, this.curve.one);
return res;
};
function JPoint(curve, x, y, z) {
Base.BasePoint.call(this, curve, "jacobian");
if (x === null && y === null && z === null) {
this.x = this.curve.one;
this.y = this.curve.one;
this.z = new BN(0);
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
this.z = new BN(z, 16);
}
if (!this.x.red)
this.x = this.x.toRed(this.curve.red);
if (!this.y.red)
this.y = this.y.toRed(this.curve.red);
if (!this.z.red)
this.z = this.z.toRed(this.curve.red);
this.zOne = this.z === this.curve.one;
}
inherits(JPoint, Base.BasePoint);
ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
return new JPoint(this, x, y, z);
};
JPoint.prototype.toP = function toP() {
if (this.isInfinity())
return this.curve.point(null, null);
var zinv = this.z.redInvm();
var zinv2 = zinv.redSqr();
var ax = this.x.redMul(zinv2);
var ay = this.y.redMul(zinv2).redMul(zinv);
return this.curve.point(ax, ay);
};
JPoint.prototype.neg = function neg() {
return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
};
JPoint.prototype.add = function add2(p) {
if (this.isInfinity())
return p;
if (p.isInfinity())
return this;
var pz2 = p.z.redSqr();
var z2 = this.z.redSqr();
var u1 = this.x.redMul(pz2);
var u2 = p.x.redMul(z2);
var s1 = this.y.redMul(pz2.redMul(p.z));
var s2 = p.y.redMul(z2.redMul(this.z));
var h = u1.redSub(u2);
var r = s1.redSub(s2);
if (h.cmpn(0) === 0) {
if (r.cmpn(0) !== 0)
return this.curve.jpoint(null, null, null);
else
return this.dbl();
}
var h2 = h.redSqr();
var h3 = h2.redMul(h);
var v = u1.redMul(h2);
var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
var nz = this.z.redMul(p.z).redMul(h);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mixedAdd = function mixedAdd(p) {
if (this.isInfinity())
return p.toJ();
if (p.isInfinity())
return this;
var z2 = this.z.redSqr();
var u1 = this.x;
var u2 = p.x.redMul(z2);
var s1 = this.y;
var s2 = p.y.redMul(z2).redMul(this.z);
var h = u1.redSub(u2);
var r = s1.redSub(s2);
if (h.cmpn(0) === 0) {
if (r.cmpn(0) !== 0)
return this.curve.jpoint(null, null, null);
else
return this.dbl();
}
var h2 = h.redSqr();
var h3 = h2.redMul(h);
var v = u1.redMul(h2);
var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
var nz = this.z.redMul(h);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.dblp = function dblp(pow3) {
if (pow3 === 0)
return this;
if (this.isInfinity())
return this;
if (!pow3)
return this.dbl();
var i;
if (this.curve.zeroA || this.curve.threeA) {
var r = this;
for (i = 0; i < pow3; i++)
r = r.dbl();
return r;
}
var a = this.curve.a;
var tinv = this.curve.tinv;
var jx = this.x;
var jy = this.y;
var jz = this.z;
var jz4 = jz.redSqr().redSqr();
var jyd = jy.redAdd(jy);
for (i = 0; i < pow3; i++) {
var jx2 = jx.redSqr();
var jyd2 = jyd.redSqr();
var jyd4 = jyd2.redSqr();
var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
var t1 = jx.redMul(jyd2);
var nx = c.redSqr().redISub(t1.redAdd(t1));
var t2 = t1.redISub(nx);
var dny = c.redMul(t2);
dny = dny.redIAdd(dny).redISub(jyd4);
var nz = jyd.redMul(jz);
if (i + 1 < pow3)
jz4 = jz4.redMul(jyd4);
jx = nx;
jz = nz;
jyd = dny;
}
return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
};
JPoint.prototype.dbl = function dbl() {
if (this.isInfinity())
return this;
if (this.curve.zeroA)
return this._zeroDbl();
else if (this.curve.threeA)
return this._threeDbl();
else
return this._dbl();
};
JPoint.prototype._zeroDbl = function _zeroDbl() {
var nx;
var ny;
var nz;
if (this.zOne) {
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var yyyy = yy.redSqr();
var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s = s.redIAdd(s);
var m = xx.redAdd(xx).redIAdd(xx);
var t = m.redSqr().redISub(s).redISub(s);
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
nx = t;
ny = m.redMul(s.redISub(t)).redISub(yyyy8);
nz = this.y.redAdd(this.y);
} else {
var a = this.x.redSqr();
var b = this.y.redSqr();
var c = b.redSqr();
var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
d = d.redIAdd(d);
var e = a.redAdd(a).redIAdd(a);
var f = e.redSqr();
var c8 = c.redIAdd(c);
c8 = c8.redIAdd(c8);
c8 = c8.redIAdd(c8);
nx = f.redISub(d).redISub(d);
ny = e.redMul(d.redISub(nx)).redISub(c8);
nz = this.y.redMul(this.z);
nz = nz.redIAdd(nz);
}
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._threeDbl = function _threeDbl() {
var nx;
var ny;
var nz;
if (this.zOne) {
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var yyyy = yy.redSqr();
var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
s = s.redIAdd(s);
var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
var t = m.redSqr().redISub(s).redISub(s);
nx = t;
var yyyy8 = yyyy.redIAdd(yyyy);
yyyy8 = yyyy8.redIAdd(yyyy8);
yyyy8 = yyyy8.redIAdd(yyyy8);
ny = m.redMul(s.redISub(t)).redISub(yyyy8);
nz = this.y.redAdd(this.y);
} else {
var delta = this.z.redSqr();
var gamma = this.y.redSqr();
var beta = this.x.redMul(gamma);
var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
alpha = alpha.redAdd(alpha).redIAdd(alpha);
var beta4 = beta.redIAdd(beta);
beta4 = beta4.redIAdd(beta4);
var beta8 = beta4.redAdd(beta4);
nx = alpha.redSqr().redISub(beta8);
nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
var ggamma8 = gamma.redSqr();
ggamma8 = ggamma8.redIAdd(ggamma8);
ggamma8 = ggamma8.redIAdd(ggamma8);
ggamma8 = ggamma8.redIAdd(ggamma8);
ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
}
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype._dbl = function _dbl() {
var a = this.curve.a;
var jx = this.x;
var jy = this.y;
var jz = this.z;
var jz4 = jz.redSqr().redSqr();
var jx2 = jx.redSqr();
var jy2 = jy.redSqr();
var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
var jxd4 = jx.redAdd(jx);
jxd4 = jxd4.redIAdd(jxd4);
var t1 = jxd4.redMul(jy2);
var nx = c.redSqr().redISub(t1.redAdd(t1));
var t2 = t1.redISub(nx);
var jyd8 = jy2.redSqr();
jyd8 = jyd8.redIAdd(jyd8);
jyd8 = jyd8.redIAdd(jyd8);
jyd8 = jyd8.redIAdd(jyd8);
var ny = c.redMul(t2).redISub(jyd8);
var nz = jy.redAdd(jy).redMul(jz);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.trpl = function trpl() {
if (!this.curve.zeroA)
return this.dbl().add(this);
var xx = this.x.redSqr();
var yy = this.y.redSqr();
var zz = this.z.redSqr();
var yyyy = yy.redSqr();
var m = xx.redAdd(xx).redIAdd(xx);
var mm = m.redSqr();
var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
e = e.redIAdd(e);
e = e.redAdd(e).redIAdd(e);
e = e.redISub(mm);
var ee = e.redSqr();
var t = yyyy.redIAdd(yyyy);
t = t.redIAdd(t);
t = t.redIAdd(t);
t = t.redIAdd(t);
var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
var yyu4 = yy.redMul(u);
yyu4 = yyu4.redIAdd(yyu4);
yyu4 = yyu4.redIAdd(yyu4);
var nx = this.x.redMul(ee).redISub(yyu4);
nx = nx.redIAdd(nx);
nx = nx.redIAdd(nx);
var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
ny = ny.redIAdd(ny);
ny = ny.redIAdd(ny);
ny = ny.redIAdd(ny);
var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
return this.curve.jpoint(nx, ny, nz);
};
JPoint.prototype.mul = function mul(k, kbase) {
k = new BN(k, kbase);
return this.curve._wnafMul(this, k);
};
JPoint.prototype.eq = function eq(p) {
if (p.type === "affine")
return this.eq(p.toJ());
if (this === p)
return true;
var z2 = this.z.redSqr();
var pz2 = p.z.redSqr();
if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
return false;
var z3 = z2.redMul(this.z);
var pz3 = pz2.redMul(p.z);
return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
};
JPoint.prototype.eqXToP = function eqXToP(x) {
var zs = this.z.redSqr();
var rx = x.toRed(this.curve.red).redMul(zs);
if (this.x.cmp(rx) === 0)
return true;
var xc = x.clone();
var t = this.curve.redN.redMul(zs);
for (; ; ) {
xc.iadd(this.curve.n);
if (xc.cmp(this.curve.p) >= 0)
return false;
rx.redIAdd(t);
if (this.x.cmp(rx) === 0)
return true;
}
};
JPoint.prototype.inspect = function inspect() {
if (this.isInfinity())
return "<EC JPoint Infinity>";
return "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
};
JPoint.prototype.isInfinity = function isInfinity() {
return this.z.cmpn(0) === 0;
};
}
});
// node_modules/elliptic/lib/elliptic/curve/mont.js
var require_mont = __commonJS({
"node_modules/elliptic/lib/elliptic/curve/mont.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var inherits = require_inherits();
var Base = require_base();
var utils = require_utils3();
function MontCurve(conf) {
Base.call(this, "mont", conf);
this.a = new BN(conf.a, 16).toRed(this.red);
this.b = new BN(conf.b, 16).toRed(this.red);
this.i4 = new BN(4).toRed(this.red).redInvm();
this.two = new BN(2).toRed(this.red);
this.a24 = this.i4.redMul(this.a.redAdd(this.two));
}
inherits(MontCurve, Base);
module2.exports = MontCurve;
MontCurve.prototype.validate = function validate(point) {
var x = point.normalize().x;
var x2 = x.redSqr();
var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
var y = rhs.redSqrt();
return y.redSqr().cmp(rhs) === 0;
};
function Point(curve, x, z) {
Base.BasePoint.call(this, curve, "projective");
if (x === null && z === null) {
this.x = this.curve.one;
this.z = this.curve.zero;
} else {
this.x = new BN(x, 16);
this.z = new BN(z, 16);
if (!this.x.red)
this.x = this.x.toRed(this.curve.red);
if (!this.z.red)
this.z = this.z.toRed(this.curve.red);
}
}
inherits(Point, Base.BasePoint);
MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
return this.point(utils.toArray(bytes, enc), 1);
};
MontCurve.prototype.point = function point(x, z) {
return new Point(this, x, z);
};
MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
return Point.fromJSON(this, obj);
};
Point.prototype.precompute = function precompute() {
};
Point.prototype._encode = function _encode() {
return this.getX().toArray("be", this.curve.p.byteLength());
};
Point.fromJSON = function fromJSON(curve, obj) {
return new Point(curve, obj[0], obj[1] || curve.one);
};
Point.prototype.inspect = function inspect() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
};
Point.prototype.isInfinity = function isInfinity() {
return this.z.cmpn(0) === 0;
};
Point.prototype.dbl = function dbl() {
var a = this.x.redAdd(this.z);
var aa = a.redSqr();
var b = this.x.redSub(this.z);
var bb = b.redSqr();
var c = aa.redSub(bb);
var nx = aa.redMul(bb);
var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
return this.curve.point(nx, nz);
};
Point.prototype.add = function add2() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.diffAdd = function diffAdd(p, diff) {
var a = this.x.redAdd(this.z);
var b = this.x.redSub(this.z);
var c = p.x.redAdd(p.z);
var d = p.x.redSub(p.z);
var da = d.redMul(a);
var cb = c.redMul(b);
var nx = diff.z.redMul(da.redAdd(cb).redSqr());
var nz = diff.x.redMul(da.redISub(cb).redSqr());
return this.curve.point(nx, nz);
};
Point.prototype.mul = function mul(k) {
var t = k.clone();
var a = this;
var b = this.curve.point(null, null);
var c = this;
for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
bits.push(t.andln(1));
for (var i = bits.length - 1; i >= 0; i--) {
if (bits[i] === 0) {
a = a.diffAdd(b, c);
b = b.dbl();
} else {
b = a.diffAdd(b, c);
a = a.dbl();
}
}
return b;
};
Point.prototype.mulAdd = function mulAdd() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.jumlAdd = function jumlAdd() {
throw new Error("Not supported on Montgomery curve");
};
Point.prototype.eq = function eq(other) {
return this.getX().cmp(other.getX()) === 0;
};
Point.prototype.normalize = function normalize() {
this.x = this.x.redMul(this.z.redInvm());
this.z = this.curve.one;
return this;
};
Point.prototype.getX = function getX() {
this.normalize();
return this.x.fromRed();
};
}
});
// node_modules/elliptic/lib/elliptic/curve/edwards.js
var require_edwards = __commonJS({
"node_modules/elliptic/lib/elliptic/curve/edwards.js"(exports2, module2) {
"use strict";
var utils = require_utils3();
var BN = require_bn();
var inherits = require_inherits();
var Base = require_base();
var assert = utils.assert;
function EdwardsCurve(conf) {
this.twisted = (conf.a | 0) !== 1;
this.mOneA = this.twisted && (conf.a | 0) === -1;
this.extended = this.mOneA;
Base.call(this, "edwards", conf);
this.a = new BN(conf.a, 16).umod(this.red.m);
this.a = this.a.toRed(this.red);
this.c = new BN(conf.c, 16).toRed(this.red);
this.c2 = this.c.redSqr();
this.d = new BN(conf.d, 16).toRed(this.red);
this.dd = this.d.redAdd(this.d);
assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
this.oneC = (conf.c | 0) === 1;
}
inherits(EdwardsCurve, Base);
module2.exports = EdwardsCurve;
EdwardsCurve.prototype._mulA = function _mulA(num) {
if (this.mOneA)
return num.redNeg();
else
return this.a.redMul(num);
};
EdwardsCurve.prototype._mulC = function _mulC(num) {
if (this.oneC)
return num;
else
return this.c.redMul(num);
};
EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
return this.point(x, y, z, t);
};
EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
x = new BN(x, 16);
if (!x.red)
x = x.toRed(this.red);
var x2 = x.redSqr();
var rhs = this.c2.redSub(this.a.redMul(x2));
var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
var y2 = rhs.redMul(lhs.redInvm());
var y = y2.redSqrt();
if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
throw new Error("invalid point");
var isOdd = y.fromRed().isOdd();
if (odd && !isOdd || !odd && isOdd)
y = y.redNeg();
return this.point(x, y);
};
EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
y = new BN(y, 16);
if (!y.red)
y = y.toRed(this.red);
var y2 = y.redSqr();
var lhs = y2.redSub(this.c2);
var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
var x2 = lhs.redMul(rhs.redInvm());
if (x2.cmp(this.zero) === 0) {
if (odd)
throw new Error("invalid point");
else
return this.point(this.zero, y);
}
var x = x2.redSqrt();
if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
throw new Error("invalid point");
if (x.fromRed().isOdd() !== odd)
x = x.redNeg();
return this.point(x, y);
};
EdwardsCurve.prototype.validate = function validate(point) {
if (point.isInfinity())
return true;
point.normalize();
var x2 = point.x.redSqr();
var y2 = point.y.redSqr();
var lhs = x2.redMul(this.a).redAdd(y2);
var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
return lhs.cmp(rhs) === 0;
};
function Point(curve, x, y, z, t) {
Base.BasePoint.call(this, curve, "projective");
if (x === null && y === null && z === null) {
this.x = this.curve.zero;
this.y = this.curve.one;
this.z = this.curve.one;
this.t = this.curve.zero;
this.zOne = true;
} else {
this.x = new BN(x, 16);
this.y = new BN(y, 16);
this.z = z ? new BN(z, 16) : this.curve.one;
this.t = t && new BN(t, 16);
if (!this.x.red)
this.x = this.x.toRed(this.curve.red);
if (!this.y.red)
this.y = this.y.toRed(this.curve.red);
if (!this.z.red)
this.z = this.z.toRed(this.curve.red);
if (this.t && !this.t.red)
this.t = this.t.toRed(this.curve.red);
this.zOne = this.z === this.curve.one;
if (this.curve.extended && !this.t) {
this.t = this.x.redMul(this.y);
if (!this.zOne)
this.t = this.t.redMul(this.z.redInvm());
}
}
}
inherits(Point, Base.BasePoint);
EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
return Point.fromJSON(this, obj);
};
EdwardsCurve.prototype.point = function point(x, y, z, t) {
return new Point(this, x, y, z, t);
};
Point.fromJSON = function fromJSON(curve, obj) {
return new Point(curve, obj[0], obj[1], obj[2]);
};
Point.prototype.inspect = function inspect() {
if (this.isInfinity())
return "<EC Point Infinity>";
return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
};
Point.prototype.isInfinity = function isInfinity() {
return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
};
Point.prototype._extDbl = function _extDbl() {
var a = this.x.redSqr();
var b = this.y.redSqr();
var c = this.z.redSqr();
c = c.redIAdd(c);
var d = this.curve._mulA(a);
var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
var g = d.redAdd(b);
var f = g.redSub(c);
var h = d.redSub(b);
var nx = e.redMul(f);
var ny = g.redMul(h);
var nt = e.redMul(h);
var nz = f.redMul(g);
return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projDbl = function _projDbl() {
var b = this.x.redAdd(this.y).redSqr();
var c = this.x.redSqr();
var d = this.y.redSqr();
var nx;
var ny;
var nz;
var e;
var h;
var j;
if (this.curve.twisted) {
e = this.curve._mulA(c);
var f = e.redAdd(d);
if (this.zOne) {
nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
ny = f.redMul(e.redSub(d));
nz = f.redSqr().redSub(f).redSub(f);
} else {
h = this.z.redSqr();
j = f.redSub(h).redISub(h);
nx = b.redSub(c).redISub(d).redMul(j);
ny = f.redMul(e.redSub(d));
nz = f.redMul(j);
}
} else {
e = c.redAdd(d);
h = this.curve._mulC(this.z).redSqr();
j = e.redSub(h).redSub(h);
nx = this.curve._mulC(b.redISub(e)).redMul(j);
ny = this.curve._mulC(e).redMul(c.redISub(d));
nz = e.redMul(j);
}
return this.curve.point(nx, ny, nz);
};
Point.prototype.dbl = function dbl() {
if (this.isInfinity())
return this;
if (this.curve.extended)
return this._extDbl();
else
return this._projDbl();
};
Point.prototype._extAdd = function _extAdd(p) {
var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
var c = this.t.redMul(this.curve.dd).redMul(p.t);
var d = this.z.redMul(p.z.redAdd(p.z));
var e = b.redSub(a);
var f = d.redSub(c);
var g = d.redAdd(c);
var h = b.redAdd(a);
var nx = e.redMul(f);
var ny = g.redMul(h);
var nt = e.redMul(h);
var nz = f.redMul(g);
return this.curve.point(nx, ny, nz, nt);
};
Point.prototype._projAdd = function _projAdd(p) {
var a = this.z.redMul(p.z);
var b = a.redSqr();
var c = this.x.redMul(p.x);
var d = this.y.redMul(p.y);
var e = this.curve.d.redMul(c).redMul(d);
var f = b.redSub(e);
var g = b.redAdd(e);
var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
var nx = a.redMul(f).redMul(tmp);
var ny;
var nz;
if (this.curve.twisted) {
ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
nz = f.redMul(g);
} else {
ny = a.redMul(g).redMul(d.redSub(c));
nz = this.curve._mulC(f).redMul(g);
}
return this.curve.point(nx, ny, nz);
};
Point.prototype.add = function add2(p) {
if (this.isInfinity())
return p;
if (p.isInfinity())
return this;
if (this.curve.extended)
return this._extAdd(p);
else
return this._projAdd(p);
};
Point.prototype.mul = function mul(k) {
if (this._hasDoubles(k))
return this.curve._fixedNafMul(this, k);
else
return this.curve._wnafMul(this, k);
};
Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
};
Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
};
Point.prototype.normalize = function normalize() {
if (this.zOne)
return this;
var zi = this.z.redInvm();
this.x = this.x.redMul(zi);
this.y = this.y.redMul(zi);
if (this.t)
this.t = this.t.redMul(zi);
this.z = this.curve.one;
this.zOne = true;
return this;
};
Point.prototype.neg = function neg() {
return this.curve.point(
this.x.redNeg(),
this.y,
this.z,
this.t && this.t.redNeg()
);
};
Point.prototype.getX = function getX() {
this.normalize();
return this.x.fromRed();
};
Point.prototype.getY = function getY() {
this.normalize();
return this.y.fromRed();
};
Point.prototype.eq = function eq(other) {
return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
};
Point.prototype.eqXToP = function eqXToP(x) {
var rx = x.toRed(this.curve.red).redMul(this.z);
if (this.x.cmp(rx) === 0)
return true;
var xc = x.clone();
var t = this.curve.redN.redMul(this.z);
for (; ; ) {
xc.iadd(this.curve.n);
if (xc.cmp(this.curve.p) >= 0)
return false;
rx.redIAdd(t);
if (this.x.cmp(rx) === 0)
return true;
}
};
Point.prototype.toP = Point.prototype.normalize;
Point.prototype.mixedAdd = Point.prototype.add;
}
});
// node_modules/elliptic/lib/elliptic/curve/index.js
var require_curve = __commonJS({
"node_modules/elliptic/lib/elliptic/curve/index.js"(exports2) {
"use strict";
var curve = exports2;
curve.base = require_base();
curve.short = require_short();
curve.mont = require_mont();
curve.edwards = require_edwards();
}
});
// node_modules/hash.js/lib/hash/utils.js
var require_utils4 = __commonJS({
"node_modules/hash.js/lib/hash/utils.js"(exports2) {
"use strict";
var assert = require_minimalistic_assert();
var inherits = require_inherits();
exports2.inherits = inherits;
function isSurrogatePair(msg, i) {
if ((msg.charCodeAt(i) & 64512) !== 55296) {
return false;
}
if (i < 0 || i + 1 >= msg.length) {
return false;
}
return (msg.charCodeAt(i + 1) & 64512) === 56320;
}
function toArray(msg, enc) {
if (Array.isArray(msg))
return msg.slice();
if (!msg)
return [];
var res = [];
if (typeof msg === "string") {
if (!enc) {
var p = 0;
for (var i = 0; i < msg.length; i++) {
var c = msg.charCodeAt(i);
if (c < 128) {
res[p++] = c;
} else if (c < 2048) {
res[p++] = c >> 6 | 192;
res[p++] = c & 63 | 128;
} else if (isSurrogatePair(msg, i)) {
c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
res[p++] = c >> 18 | 240;
res[p++] = c >> 12 & 63 | 128;
res[p++] = c >> 6 & 63 | 128;
res[p++] = c & 63 | 128;
} else {
res[p++] = c >> 12 | 224;
res[p++] = c >> 6 & 63 | 128;
res[p++] = c & 63 | 128;
}
}
} else if (enc === "hex") {
msg = msg.replace(/[^a-z0-9]+/ig, "");
if (msg.length % 2 !== 0)
msg = "0" + msg;
for (i = 0; i < msg.length; i += 2)
res.push(parseInt(msg[i] + msg[i + 1], 16));
}
} else {
for (i = 0; i < msg.length; i++)
res[i] = msg[i] | 0;
}
return res;
}
exports2.toArray = toArray;
function toHex(msg) {
var res = "";
for (var i = 0; i < msg.length; i++)
res += zero2(msg[i].toString(16));
return res;
}
exports2.toHex = toHex;
function htonl(w) {
var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
return res >>> 0;
}
exports2.htonl = htonl;
function toHex32(msg, endian) {
var res = "";
for (var i = 0; i < msg.length; i++) {
var w = msg[i];
if (endian === "little")
w = htonl(w);
res += zero8(w.toString(16));
}
return res;
}
exports2.toHex32 = toHex32;
function zero2(word) {
if (word.length === 1)
return "0" + word;
else
return word;
}
exports2.zero2 = zero2;
function zero8(word) {
if (word.length === 7)
return "0" + word;
else if (word.length === 6)
return "00" + word;
else if (word.length === 5)
return "000" + word;
else if (word.length === 4)
return "0000" + word;
else if (word.length === 3)
return "00000" + word;
else if (word.length === 2)
return "000000" + word;
else if (word.length === 1)
return "0000000" + word;
else
return word;
}
exports2.zero8 = zero8;
function join32(msg, start, end, endian) {
var len = end - start;
assert(len % 4 === 0);
var res = new Array(len / 4);
for (var i = 0, k = start; i < res.length; i++, k += 4) {
var w;
if (endian === "big")
w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
else
w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
res[i] = w >>> 0;
}
return res;
}
exports2.join32 = join32;
function split32(msg, endian) {
var res = new Array(msg.length * 4);
for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
var m = msg[i];
if (endian === "big") {
res[k] = m >>> 24;
res[k + 1] = m >>> 16 & 255;
res[k + 2] = m >>> 8 & 255;
res[k + 3] = m & 255;
} else {
res[k + 3] = m >>> 24;
res[k + 2] = m >>> 16 & 255;
res[k + 1] = m >>> 8 & 255;
res[k] = m & 255;
}
}
return res;
}
exports2.split32 = split32;
function rotr32(w, b) {
return w >>> b | w << 32 - b;
}
exports2.rotr32 = rotr32;
function rotl32(w, b) {
return w << b | w >>> 32 - b;
}
exports2.rotl32 = rotl32;
function sum32(a, b) {
return a + b >>> 0;
}
exports2.sum32 = sum32;
function sum32_3(a, b, c) {
return a + b + c >>> 0;
}
exports2.sum32_3 = sum32_3;
function sum32_4(a, b, c, d) {
return a + b + c + d >>> 0;
}
exports2.sum32_4 = sum32_4;
function sum32_5(a, b, c, d, e) {
return a + b + c + d + e >>> 0;
}
exports2.sum32_5 = sum32_5;
function sum64(buf, pos, ah, al) {
var bh = buf[pos];
var bl = buf[pos + 1];
var lo = al + bl >>> 0;
var hi = (lo < al ? 1 : 0) + ah + bh;
buf[pos] = hi >>> 0;
buf[pos + 1] = lo;
}
exports2.sum64 = sum64;
function sum64_hi(ah, al, bh, bl) {
var lo = al + bl >>> 0;
var hi = (lo < al ? 1 : 0) + ah + bh;
return hi >>> 0;
}
exports2.sum64_hi = sum64_hi;
function sum64_lo(ah, al, bh, bl) {
var lo = al + bl;
return lo >>> 0;
}
exports2.sum64_lo = sum64_lo;
function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
var carry = 0;
var lo = al;
lo = lo + bl >>> 0;
carry += lo < al ? 1 : 0;
lo = lo + cl >>> 0;
carry += lo < cl ? 1 : 0;
lo = lo + dl >>> 0;
carry += lo < dl ? 1 : 0;
var hi = ah + bh + ch + dh + carry;
return hi >>> 0;
}
exports2.sum64_4_hi = sum64_4_hi;
function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
var lo = al + bl + cl + dl;
return lo >>> 0;
}
exports2.sum64_4_lo = sum64_4_lo;
function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
var carry = 0;
var lo = al;
lo = lo + bl >>> 0;
carry += lo < al ? 1 : 0;
lo = lo + cl >>> 0;
carry += lo < cl ? 1 : 0;
lo = lo + dl >>> 0;
carry += lo < dl ? 1 : 0;
lo = lo + el >>> 0;
carry += lo < el ? 1 : 0;
var hi = ah + bh + ch + dh + eh + carry;
return hi >>> 0;
}
exports2.sum64_5_hi = sum64_5_hi;
function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
var lo = al + bl + cl + dl + el;
return lo >>> 0;
}
exports2.sum64_5_lo = sum64_5_lo;
function rotr64_hi(ah, al, num) {
var r = al << 32 - num | ah >>> num;
return r >>> 0;
}
exports2.rotr64_hi = rotr64_hi;
function rotr64_lo(ah, al, num) {
var r = ah << 32 - num | al >>> num;
return r >>> 0;
}
exports2.rotr64_lo = rotr64_lo;
function shr64_hi(ah, al, num) {
return ah >>> num;
}
exports2.shr64_hi = shr64_hi;
function shr64_lo(ah, al, num) {
var r = ah << 32 - num | al >>> num;
return r >>> 0;
}
exports2.shr64_lo = shr64_lo;
}
});
// node_modules/hash.js/lib/hash/common.js
var require_common = __commonJS({
"node_modules/hash.js/lib/hash/common.js"(exports2) {
"use strict";
var utils = require_utils4();
var assert = require_minimalistic_assert();
function BlockHash() {
this.pending = null;
this.pendingTotal = 0;
this.blockSize = this.constructor.blockSize;
this.outSize = this.constructor.outSize;
this.hmacStrength = this.constructor.hmacStrength;
this.padLength = this.constructor.padLength / 8;
this.endian = "big";
this._delta8 = this.blockSize / 8;
this._delta32 = this.blockSize / 32;
}
exports2.BlockHash = BlockHash;
BlockHash.prototype.update = function update(msg, enc) {
msg = utils.toArray(msg, enc);
if (!this.pending)
this.pending = msg;
else
this.pending = this.pending.concat(msg);
this.pendingTotal += msg.length;
if (this.pending.length >= this._delta8) {
msg = this.pending;
var r = msg.length % this._delta8;
this.pending = msg.slice(msg.length - r, msg.length);
if (this.pending.length === 0)
this.pending = null;
msg = utils.join32(msg, 0, msg.length - r, this.endian);
for (var i = 0; i < msg.length; i += this._delta32)
this._update(msg, i, i + this._delta32);
}
return this;
};
BlockHash.prototype.digest = function digest(enc) {
this.update(this._pad());
assert(this.pending === null);
return this._digest(enc);
};
BlockHash.prototype._pad = function pad() {
var len = this.pendingTotal;
var bytes = this._delta8;
var k = bytes - (len + this.padLength) % bytes;
var res = new Array(k + this.padLength);
res[0] = 128;
for (var i = 1; i < k; i++)
res[i] = 0;
len <<= 3;
if (this.endian === "big") {
for (var t = 8; t < this.padLength; t++)
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = len >>> 24 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len & 255;
} else {
res[i++] = len & 255;
res[i++] = len >>> 8 & 255;
res[i++] = len >>> 16 & 255;
res[i++] = len >>> 24 & 255;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
res[i++] = 0;
for (t = 8; t < this.padLength; t++)
res[i++] = 0;
}
return res;
};
}
});
// node_modules/hash.js/lib/hash/sha/common.js
var require_common2 = __commonJS({
"node_modules/hash.js/lib/hash/sha/common.js"(exports2) {
"use strict";
var utils = require_utils4();
var rotr32 = utils.rotr32;
function ft_1(s, x, y, z) {
if (s === 0)
return ch32(x, y, z);
if (s === 1 || s === 3)
return p32(x, y, z);
if (s === 2)
return maj32(x, y, z);
}
exports2.ft_1 = ft_1;
function ch32(x, y, z) {
return x & y ^ ~x & z;
}
exports2.ch32 = ch32;
function maj32(x, y, z) {
return x & y ^ x & z ^ y & z;
}
exports2.maj32 = maj32;
function p32(x, y, z) {
return x ^ y ^ z;
}
exports2.p32 = p32;
function s0_256(x) {
return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}
exports2.s0_256 = s0_256;
function s1_256(x) {
return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}
exports2.s1_256 = s1_256;
function g0_256(x) {
return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}
exports2.g0_256 = g0_256;
function g1_256(x) {
return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}
exports2.g1_256 = g1_256;
}
});
// node_modules/hash.js/lib/hash/sha/1.js
var require__ = __commonJS({
"node_modules/hash.js/lib/hash/sha/1.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var common = require_common();
var shaCommon = require_common2();
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_5 = utils.sum32_5;
var ft_1 = shaCommon.ft_1;
var BlockHash = common.BlockHash;
var sha1_K = [
1518500249,
1859775393,
2400959708,
3395469782
];
function SHA1() {
if (!(this instanceof SHA1))
return new SHA1();
BlockHash.call(this);
this.h = [
1732584193,
4023233417,
2562383102,
271733878,
3285377520
];
this.W = new Array(80);
}
utils.inherits(SHA1, BlockHash);
module2.exports = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;
SHA1.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++)
W[i] = msg[start + i];
for (; i < W.length; i++)
W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
var a = this.h[0];
var b = this.h[1];
var c = this.h[2];
var d = this.h[3];
var e = this.h[4];
for (i = 0; i < W.length; i++) {
var s = ~~(i / 20);
var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
e = d;
d = c;
c = rotl32(b, 30);
b = a;
a = t;
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
};
SHA1.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h, "big");
else
return utils.split32(this.h, "big");
};
}
});
// node_modules/hash.js/lib/hash/sha/256.js
var require__2 = __commonJS({
"node_modules/hash.js/lib/hash/sha/256.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var common = require_common();
var shaCommon = require_common2();
var assert = require_minimalistic_assert();
var sum32 = utils.sum32;
var sum32_4 = utils.sum32_4;
var sum32_5 = utils.sum32_5;
var ch32 = shaCommon.ch32;
var maj32 = shaCommon.maj32;
var s0_256 = shaCommon.s0_256;
var s1_256 = shaCommon.s1_256;
var g0_256 = shaCommon.g0_256;
var g1_256 = shaCommon.g1_256;
var BlockHash = common.BlockHash;
var sha256_K = [
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
];
function SHA2562() {
if (!(this instanceof SHA2562))
return new SHA2562();
BlockHash.call(this);
this.h = [
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
];
this.k = sha256_K;
this.W = new Array(64);
}
utils.inherits(SHA2562, BlockHash);
module2.exports = SHA2562;
SHA2562.blockSize = 512;
SHA2562.outSize = 256;
SHA2562.hmacStrength = 192;
SHA2562.padLength = 64;
SHA2562.prototype._update = function _update(msg, start) {
var W = this.W;
for (var i = 0; i < 16; i++)
W[i] = msg[start + i];
for (; i < W.length; i++)
W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
var a = this.h[0];
var b = this.h[1];
var c = this.h[2];
var d = this.h[3];
var e = this.h[4];
var f = this.h[5];
var g = this.h[6];
var h = this.h[7];
assert(this.k.length === W.length);
for (i = 0; i < W.length; i++) {
var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
var T2 = sum32(s0_256(a), maj32(a, b, c));
h = g;
g = f;
f = e;
e = sum32(d, T1);
d = c;
c = b;
b = a;
a = sum32(T1, T2);
}
this.h[0] = sum32(this.h[0], a);
this.h[1] = sum32(this.h[1], b);
this.h[2] = sum32(this.h[2], c);
this.h[3] = sum32(this.h[3], d);
this.h[4] = sum32(this.h[4], e);
this.h[5] = sum32(this.h[5], f);
this.h[6] = sum32(this.h[6], g);
this.h[7] = sum32(this.h[7], h);
};
SHA2562.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h, "big");
else
return utils.split32(this.h, "big");
};
}
});
// node_modules/hash.js/lib/hash/sha/224.js
var require__3 = __commonJS({
"node_modules/hash.js/lib/hash/sha/224.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var SHA2562 = require__2();
function SHA224() {
if (!(this instanceof SHA224))
return new SHA224();
SHA2562.call(this);
this.h = [
3238371032,
914150663,
812702999,
4144912697,
4290775857,
1750603025,
1694076839,
3204075428
];
}
utils.inherits(SHA224, SHA2562);
module2.exports = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;
SHA224.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h.slice(0, 7), "big");
else
return utils.split32(this.h.slice(0, 7), "big");
};
}
});
// node_modules/hash.js/lib/hash/sha/512.js
var require__4 = __commonJS({
"node_modules/hash.js/lib/hash/sha/512.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var common = require_common();
var assert = require_minimalistic_assert();
var rotr64_hi = utils.rotr64_hi;
var rotr64_lo = utils.rotr64_lo;
var shr64_hi = utils.shr64_hi;
var shr64_lo = utils.shr64_lo;
var sum64 = utils.sum64;
var sum64_hi = utils.sum64_hi;
var sum64_lo = utils.sum64_lo;
var sum64_4_hi = utils.sum64_4_hi;
var sum64_4_lo = utils.sum64_4_lo;
var sum64_5_hi = utils.sum64_5_hi;
var sum64_5_lo = utils.sum64_5_lo;
var BlockHash = common.BlockHash;
var sha512_K = [
1116352408,
3609767458,
1899447441,
602891725,
3049323471,
3964484399,
3921009573,
2173295548,
961987163,
4081628472,
1508970993,
3053834265,
2453635748,
2937671579,
2870763221,
3664609560,
3624381080,
2734883394,
310598401,
1164996542,
607225278,
1323610764,
1426881987,
3590304994,
1925078388,
4068182383,
2162078206,
991336113,
2614888103,
633803317,
3248222580,
3479774868,
3835390401,
2666613458,
4022224774,
944711139,
264347078,
2341262773,
604807628,
2007800933,
770255983,
1495990901,
1249150122,
1856431235,
1555081692,
3175218132,
1996064986,
2198950837,
2554220882,
3999719339,
2821834349,
766784016,
2952996808,
2566594879,
3210313671,
3203337956,
3336571891,
1034457026,
3584528711,
2466948901,
113926993,
3758326383,
338241895,
168717936,
666307205,
1188179964,
773529912,
1546045734,
1294757372,
1522805485,
1396182291,
2643833823,
1695183700,
2343527390,
1986661051,
1014477480,
2177026350,
1206759142,
2456956037,
344077627,
2730485921,
1290863460,
2820302411,
3158454273,
3259730800,
3505952657,
3345764771,
106217008,
3516065817,
3606008344,
3600352804,
1432725776,
4094571909,
1467031594,
275423344,
851169720,
430227734,
3100823752,
506948616,
1363258195,
659060556,
3750685593,
883997877,
3785050280,
958139571,
3318307427,
1322822218,
3812723403,
1537002063,
2003034995,
1747873779,
3602036899,
1955562222,
1575990012,
2024104815,
1125592928,
2227730452,
2716904306,
2361852424,
442776044,
2428436474,
593698344,
2756734187,
3733110249,
3204031479,
2999351573,
3329325298,
3815920427,
3391569614,
3928383900,
3515267271,
566280711,
3940187606,
3454069534,
4118630271,
4000239992,
116418474,
1914138554,
174292421,
2731055270,
289380356,
3203993006,
460393269,
320620315,
685471733,
587496836,
852142971,
1086792851,
1017036298,
365543100,
1126000580,
2618297676,
1288033470,
3409855158,
1501505948,
4234509866,
1607167915,
987167468,
1816402316,
1246189591
];
function SHA5122() {
if (!(this instanceof SHA5122))
return new SHA5122();
BlockHash.call(this);
this.h = [
1779033703,
4089235720,
3144134277,
2227873595,
1013904242,
4271175723,
2773480762,
1595750129,
1359893119,
2917565137,
2600822924,
725511199,
528734635,
4215389547,
1541459225,
327033209
];
this.k = sha512_K;
this.W = new Array(160);
}
utils.inherits(SHA5122, BlockHash);
module2.exports = SHA5122;
SHA5122.blockSize = 1024;
SHA5122.outSize = 512;
SHA5122.hmacStrength = 192;
SHA5122.padLength = 128;
SHA5122.prototype._prepareBlock = function _prepareBlock(msg, start) {
var W = this.W;
for (var i = 0; i < 32; i++)
W[i] = msg[start + i];
for (; i < W.length; i += 2) {
var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
var c1_hi = W[i - 14];
var c1_lo = W[i - 13];
var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
var c3_hi = W[i - 32];
var c3_lo = W[i - 31];
W[i] = sum64_4_hi(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
W[i + 1] = sum64_4_lo(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo
);
}
};
SHA5122.prototype._update = function _update(msg, start) {
this._prepareBlock(msg, start);
var W = this.W;
var ah = this.h[0];
var al = this.h[1];
var bh = this.h[2];
var bl = this.h[3];
var ch = this.h[4];
var cl = this.h[5];
var dh = this.h[6];
var dl = this.h[7];
var eh = this.h[8];
var el = this.h[9];
var fh = this.h[10];
var fl = this.h[11];
var gh = this.h[12];
var gl = this.h[13];
var hh = this.h[14];
var hl = this.h[15];
assert(this.k.length === W.length);
for (var i = 0; i < W.length; i += 2) {
var c0_hi = hh;
var c0_lo = hl;
var c1_hi = s1_512_hi(eh, el);
var c1_lo = s1_512_lo(eh, el);
var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
var c3_hi = this.k[i];
var c3_lo = this.k[i + 1];
var c4_hi = W[i];
var c4_lo = W[i + 1];
var T1_hi = sum64_5_hi(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo,
c4_hi,
c4_lo
);
var T1_lo = sum64_5_lo(
c0_hi,
c0_lo,
c1_hi,
c1_lo,
c2_hi,
c2_lo,
c3_hi,
c3_lo,
c4_hi,
c4_lo
);
c0_hi = s0_512_hi(ah, al);
c0_lo = s0_512_lo(ah, al);
c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
hh = gh;
hl = gl;
gh = fh;
gl = fl;
fh = eh;
fl = el;
eh = sum64_hi(dh, dl, T1_hi, T1_lo);
el = sum64_lo(dl, dl, T1_hi, T1_lo);
dh = ch;
dl = cl;
ch = bh;
cl = bl;
bh = ah;
bl = al;
ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
}
sum64(this.h, 0, ah, al);
sum64(this.h, 2, bh, bl);
sum64(this.h, 4, ch, cl);
sum64(this.h, 6, dh, dl);
sum64(this.h, 8, eh, el);
sum64(this.h, 10, fh, fl);
sum64(this.h, 12, gh, gl);
sum64(this.h, 14, hh, hl);
};
SHA5122.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h, "big");
else
return utils.split32(this.h, "big");
};
function ch64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ ~xh & zh;
if (r < 0)
r += 4294967296;
return r;
}
function ch64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ ~xl & zl;
if (r < 0)
r += 4294967296;
return r;
}
function maj64_hi(xh, xl, yh, yl, zh) {
var r = xh & yh ^ xh & zh ^ yh & zh;
if (r < 0)
r += 4294967296;
return r;
}
function maj64_lo(xh, xl, yh, yl, zh, zl) {
var r = xl & yl ^ xl & zl ^ yl & zl;
if (r < 0)
r += 4294967296;
return r;
}
function s0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 28);
var c1_hi = rotr64_hi(xl, xh, 2);
var c2_hi = rotr64_hi(xl, xh, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function s0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 28);
var c1_lo = rotr64_lo(xl, xh, 2);
var c2_lo = rotr64_lo(xl, xh, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function s1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 14);
var c1_hi = rotr64_hi(xh, xl, 18);
var c2_hi = rotr64_hi(xl, xh, 9);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function s1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 14);
var c1_lo = rotr64_lo(xh, xl, 18);
var c2_lo = rotr64_lo(xl, xh, 9);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function g0_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 1);
var c1_hi = rotr64_hi(xh, xl, 8);
var c2_hi = shr64_hi(xh, xl, 7);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function g0_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 1);
var c1_lo = rotr64_lo(xh, xl, 8);
var c2_lo = shr64_lo(xh, xl, 7);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
function g1_512_hi(xh, xl) {
var c0_hi = rotr64_hi(xh, xl, 19);
var c1_hi = rotr64_hi(xl, xh, 29);
var c2_hi = shr64_hi(xh, xl, 6);
var r = c0_hi ^ c1_hi ^ c2_hi;
if (r < 0)
r += 4294967296;
return r;
}
function g1_512_lo(xh, xl) {
var c0_lo = rotr64_lo(xh, xl, 19);
var c1_lo = rotr64_lo(xl, xh, 29);
var c2_lo = shr64_lo(xh, xl, 6);
var r = c0_lo ^ c1_lo ^ c2_lo;
if (r < 0)
r += 4294967296;
return r;
}
}
});
// node_modules/hash.js/lib/hash/sha/384.js
var require__5 = __commonJS({
"node_modules/hash.js/lib/hash/sha/384.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var SHA5122 = require__4();
function SHA384() {
if (!(this instanceof SHA384))
return new SHA384();
SHA5122.call(this);
this.h = [
3418070365,
3238371032,
1654270250,
914150663,
2438529370,
812702999,
355462360,
4144912697,
1731405415,
4290775857,
2394180231,
1750603025,
3675008525,
1694076839,
1203062813,
3204075428
];
}
utils.inherits(SHA384, SHA5122);
module2.exports = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;
SHA384.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h.slice(0, 12), "big");
else
return utils.split32(this.h.slice(0, 12), "big");
};
}
});
// node_modules/hash.js/lib/hash/sha.js
var require_sha = __commonJS({
"node_modules/hash.js/lib/hash/sha.js"(exports2) {
"use strict";
exports2.sha1 = require__();
exports2.sha224 = require__3();
exports2.sha256 = require__2();
exports2.sha384 = require__5();
exports2.sha512 = require__4();
}
});
// node_modules/hash.js/lib/hash/ripemd.js
var require_ripemd = __commonJS({
"node_modules/hash.js/lib/hash/ripemd.js"(exports2) {
"use strict";
var utils = require_utils4();
var common = require_common();
var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_3 = utils.sum32_3;
var sum32_4 = utils.sum32_4;
var BlockHash = common.BlockHash;
function RIPEMD160() {
if (!(this instanceof RIPEMD160))
return new RIPEMD160();
BlockHash.call(this);
this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
this.endian = "little";
}
utils.inherits(RIPEMD160, BlockHash);
exports2.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;
RIPEMD160.prototype._update = function update(msg, start) {
var A = this.h[0];
var B = this.h[1];
var C = this.h[2];
var D = this.h[3];
var E = this.h[4];
var Ah = A;
var Bh = B;
var Ch = C;
var Dh = D;
var Eh = E;
for (var j = 0; j < 80; j++) {
var T = sum32(
rotl32(
sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
s[j]
),
E
);
A = E;
E = D;
D = rotl32(C, 10);
C = B;
B = T;
T = sum32(
rotl32(
sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
sh[j]
),
Eh
);
Ah = Eh;
Eh = Dh;
Dh = rotl32(Ch, 10);
Ch = Bh;
Bh = T;
}
T = sum32_3(this.h[1], C, Dh);
this.h[1] = sum32_3(this.h[2], D, Eh);
this.h[2] = sum32_3(this.h[3], E, Ah);
this.h[3] = sum32_3(this.h[4], A, Bh);
this.h[4] = sum32_3(this.h[0], B, Ch);
this.h[0] = T;
};
RIPEMD160.prototype._digest = function digest(enc) {
if (enc === "hex")
return utils.toHex32(this.h, "little");
else
return utils.split32(this.h, "little");
};
function f(j, x, y, z) {
if (j <= 15)
return x ^ y ^ z;
else if (j <= 31)
return x & y | ~x & z;
else if (j <= 47)
return (x | ~y) ^ z;
else if (j <= 63)
return x & z | y & ~z;
else
return x ^ (y | ~z);
}
function K(j) {
if (j <= 15)
return 0;
else if (j <= 31)
return 1518500249;
else if (j <= 47)
return 1859775393;
else if (j <= 63)
return 2400959708;
else
return 2840853838;
}
function Kh(j) {
if (j <= 15)
return 1352829926;
else if (j <= 31)
return 1548603684;
else if (j <= 47)
return 1836072691;
else if (j <= 63)
return 2053994217;
else
return 0;
}
var r = [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
7,
4,
13,
1,
10,
6,
15,
3,
12,
0,
9,
5,
2,
14,
11,
8,
3,
10,
14,
4,
9,
15,
8,
1,
2,
7,
0,
6,
13,
11,
5,
12,
1,
9,
11,
10,
0,
8,
12,
4,
13,
3,
7,
15,
14,
5,
6,
2,
4,
0,
5,
9,
7,
12,
2,
10,
14,
1,
3,
8,
11,
6,
15,
13
];
var rh = [
5,
14,
7,
0,
9,
2,
11,
4,
13,
6,
15,
8,
1,
10,
3,
12,
6,
11,
3,
7,
0,
13,
5,
10,
14,
15,
8,
12,
4,
9,
1,
2,
15,
5,
1,
3,
7,
14,
6,
9,
11,
8,
12,
2,
10,
0,
4,
13,
8,
6,
4,
1,
3,
11,
15,
0,
5,
12,
2,
13,
9,
7,
10,
14,
12,
15,
10,
4,
1,
5,
8,
7,
6,
2,
13,
14,
0,
3,
9,
11
];
var s = [
11,
14,
15,
12,
5,
8,
7,
9,
11,
13,
14,
15,
6,
7,
9,
8,
7,
6,
8,
13,
11,
9,
7,
15,
7,
12,
15,
9,
11,
7,
13,
12,
11,
13,
6,
7,
14,
9,
13,
15,
14,
8,
13,
6,
5,
12,
7,
5,
11,
12,
14,
15,
14,
15,
9,
8,
9,
14,
5,
6,
8,
6,
5,
12,
9,
15,
5,
11,
6,
8,
13,
12,
5,
12,
13,
14,
11,
8,
5,
6
];
var sh = [
8,
9,
9,
11,
13,
15,
15,
5,
7,
7,
8,
11,
14,
14,
12,
6,
9,
13,
15,
7,
12,
8,
9,
11,
7,
7,
12,
7,
6,
15,
13,
11,
9,
7,
15,
11,
8,
6,
6,
14,
12,
13,
5,
14,
13,
13,
7,
5,
15,
5,
8,
11,
14,
14,
6,
14,
6,
9,
12,
9,
12,
5,
15,
8,
8,
5,
12,
9,
12,
5,
14,
6,
8,
13,
6,
5,
15,
13,
11,
11
];
}
});
// node_modules/hash.js/lib/hash/hmac.js
var require_hmac = __commonJS({
"node_modules/hash.js/lib/hash/hmac.js"(exports2, module2) {
"use strict";
var utils = require_utils4();
var assert = require_minimalistic_assert();
function Hmac(hash, key, enc) {
if (!(this instanceof Hmac))
return new Hmac(hash, key, enc);
this.Hash = hash;
this.blockSize = hash.blockSize / 8;
this.outSize = hash.outSize / 8;
this.inner = null;
this.outer = null;
this._init(utils.toArray(key, enc));
}
module2.exports = Hmac;
Hmac.prototype._init = function init(key) {
if (key.length > this.blockSize)
key = new this.Hash().update(key).digest();
assert(key.length <= this.blockSize);
for (var i = key.length; i < this.blockSize; i++)
key.push(0);
for (i = 0; i < key.length; i++)
key[i] ^= 54;
this.inner = new this.Hash().update(key);
for (i = 0; i < key.length; i++)
key[i] ^= 106;
this.outer = new this.Hash().update(key);
};
Hmac.prototype.update = function update(msg, enc) {
this.inner.update(msg, enc);
return this;
};
Hmac.prototype.digest = function digest(enc) {
this.outer.update(this.inner.digest());
return this.outer.digest(enc);
};
}
});
// node_modules/hash.js/lib/hash.js
var require_hash = __commonJS({
"node_modules/hash.js/lib/hash.js"(exports2) {
var hash = exports2;
hash.utils = require_utils4();
hash.common = require_common();
hash.sha = require_sha();
hash.ripemd = require_ripemd();
hash.hmac = require_hmac();
hash.sha1 = hash.sha.sha1;
hash.sha256 = hash.sha.sha256;
hash.sha224 = hash.sha.sha224;
hash.sha384 = hash.sha.sha384;
hash.sha512 = hash.sha.sha512;
hash.ripemd160 = hash.ripemd.ripemd160;
}
});
// node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js
var require_secp256k1 = __commonJS({
"node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js"(exports2, module2) {
module2.exports = {
doubles: {
step: 4,
points: [
[
"e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a",
"f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821"
],
[
"8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508",
"11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf"
],
[
"175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739",
"d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695"
],
[
"363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640",
"4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9"
],
[
"8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c",
"4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36"
],
[
"723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda",
"96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f"
],
[
"eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa",
"5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999"
],
[
"100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0",
"cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09"
],
[
"e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d",
"9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d"
],
[
"feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d",
"e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088"
],
[
"da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1",
"9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d"
],
[
"53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0",
"5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8"
],
[
"8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047",
"10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a"
],
[
"385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862",
"283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453"
],
[
"6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7",
"7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160"
],
[
"3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd",
"56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0"
],
[
"85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83",
"7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6"
],
[
"948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a",
"53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589"
],
[
"6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8",
"bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17"
],
[
"e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d",
"4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda"
],
[
"e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725",
"7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd"
],
[
"213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754",
"4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2"
],
[
"4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c",
"17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6"
],
[
"fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6",
"6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f"
],
[
"76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39",
"c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01"
],
[
"c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891",
"893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3"
],
[
"d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b",
"febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f"
],
[
"b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03",
"2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7"
],
[
"e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d",
"eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78"
],
[
"a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070",
"7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1"
],
[
"90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4",
"e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150"
],
[
"8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da",
"662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82"
],
[
"e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11",
"1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc"
],
[
"8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e",
"efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b"
],
[
"e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41",
"2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51"
],
[
"b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef",
"67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45"
],
[
"d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8",
"db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120"
],
[
"324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d",
"648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84"
],
[
"4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96",
"35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d"
],
[
"9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd",
"ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d"
],
[
"6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5",
"9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8"
],
[
"a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266",
"40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8"
],
[
"7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71",
"34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac"
],
[
"928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac",
"c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f"
],
[
"85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751",
"1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962"
],
[
"ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e",
"493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907"
],
[
"827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241",
"c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec"
],
[
"eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3",
"be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d"
],
[
"e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f",
"4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414"
],
[
"1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19",
"aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd"
],
[
"146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be",
"b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0"
],
[
"fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9",
"6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811"
],
[
"da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2",
"8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1"
],
[
"a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13",
"7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c"
],
[
"174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c",
"ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73"
],
[
"959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba",
"2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd"
],
[
"d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151",
"e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405"
],
[
"64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073",
"d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589"
],
[
"8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458",
"38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e"
],
[
"13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b",
"69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27"
],
[
"bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366",
"d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1"
],
[
"8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa",
"40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482"
],
[
"8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0",
"620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945"
],
[
"dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787",
"7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573"
],
[
"f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e",
"ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82"
]
]
},
naf: {
wnd: 7,
points: [
[
"f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9",
"388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672"
],
[
"2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4",
"d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6"
],
[
"5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc",
"6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da"
],
[
"acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe",
"cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37"
],
[
"774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb",
"d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b"
],
[
"f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8",
"ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81"
],
[
"d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e",
"581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58"
],
[
"defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34",
"4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77"
],
[
"2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c",
"85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a"
],
[
"352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5",
"321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c"
],
[
"2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f",
"2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67"
],
[
"9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714",
"73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402"
],
[
"daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729",
"a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55"
],
[
"c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db",
"2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482"
],
[
"6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4",
"e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82"
],
[
"1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5",
"b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396"
],
[
"605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479",
"2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49"
],
[
"62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d",
"80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf"
],
[
"80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f",
"1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a"
],
[
"7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb",
"d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7"
],
[
"d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9",
"eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933"
],
[
"49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963",
"758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a"
],
[
"77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74",
"958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6"
],
[
"f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530",
"e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37"
],
[
"463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b",
"5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e"
],
[
"f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247",
"cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6"
],
[
"caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1",
"cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476"
],
[
"2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120",
"4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40"
],
[
"7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435",
"91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61"
],
[
"754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18",
"673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683"
],
[
"e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8",
"59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5"
],
[
"186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb",
"3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b"
],
[
"df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f",
"55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417"
],
[
"5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143",
"efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868"
],
[
"290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba",
"e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a"
],
[
"af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45",
"f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6"
],
[
"766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a",
"744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996"
],
[
"59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e",
"c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e"
],
[
"f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8",
"e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d"
],
[
"7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c",
"30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2"
],
[
"948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519",
"e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e"
],
[
"7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab",
"100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437"
],
[
"3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca",
"ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311"
],
[
"d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf",
"8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4"
],
[
"1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610",
"68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575"
],
[
"733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4",
"f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d"
],
[
"15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c",
"d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d"
],
[
"a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940",
"edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629"
],
[
"e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980",
"a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06"
],
[
"311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3",
"66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374"
],
[
"34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf",
"9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee"
],
[
"f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63",
"4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1"
],
[
"d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448",
"fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b"
],
[
"32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf",
"5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661"
],
[
"7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5",
"8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6"
],
[
"ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6",
"8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e"
],
[
"16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5",
"5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d"
],
[
"eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99",
"f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc"
],
[
"78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51",
"f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4"
],
[
"494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5",
"42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c"
],
[
"a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5",
"204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b"
],
[
"c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997",
"4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913"
],
[
"841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881",
"73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154"
],
[
"5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5",
"39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865"
],
[
"36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66",
"d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc"
],
[
"336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726",
"ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224"
],
[
"8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede",
"6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e"
],
[
"1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94",
"60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6"
],
[
"85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31",
"3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511"
],
[
"29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51",
"b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b"
],
[
"a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252",
"ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2"
],
[
"4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5",
"cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c"
],
[
"d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b",
"6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3"
],
[
"ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4",
"322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d"
],
[
"af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f",
"6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700"
],
[
"e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889",
"2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4"
],
[
"591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246",
"b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196"
],
[
"11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984",
"998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4"
],
[
"3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a",
"b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257"
],
[
"cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030",
"bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13"
],
[
"c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197",
"6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096"
],
[
"c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593",
"c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38"
],
[
"a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef",
"21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f"
],
[
"347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38",
"60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448"
],
[
"da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a",
"49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a"
],
[
"c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111",
"5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4"
],
[
"4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502",
"7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437"
],
[
"3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea",
"be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7"
],
[
"cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26",
"8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d"
],
[
"b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986",
"39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a"
],
[
"d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e",
"62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54"
],
[
"48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4",
"25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77"
],
[
"dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda",
"ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517"
],
[
"6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859",
"cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10"
],
[
"e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f",
"f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125"
],
[
"eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c",
"6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e"
],
[
"13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942",
"fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1"
],
[
"ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a",
"1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2"
],
[
"b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80",
"5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423"
],
[
"ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d",
"438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8"
],
[
"8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1",
"cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758"
],
[
"52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63",
"c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375"
],
[
"e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352",
"6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d"
],
[
"7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193",
"ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec"
],
[
"5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00",
"9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0"
],
[
"32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58",
"ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c"
],
[
"e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7",
"d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4"
],
[
"8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8",
"c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f"
],
[
"4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e",
"67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649"
],
[
"3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d",
"cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826"
],
[
"674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b",
"299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5"
],
[
"d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f",
"f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87"
],
[
"30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6",
"462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b"
],
[
"be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297",
"62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc"
],
[
"93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a",
"7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c"
],
[
"b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c",
"ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f"
],
[
"d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52",
"4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a"
],
[
"d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb",
"bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46"
],
[
"463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065",
"bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f"
],
[
"7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917",
"603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03"
],
[
"74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9",
"cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08"
],
[
"30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3",
"553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8"
],
[
"9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57",
"712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373"
],
[
"176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66",
"ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3"
],
[
"75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8",
"9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8"
],
[
"809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721",
"9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1"
],
[
"1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180",
"4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9"
]
]
}
};
}
});
// node_modules/elliptic/lib/elliptic/curves.js
var require_curves = __commonJS({
"node_modules/elliptic/lib/elliptic/curves.js"(exports2) {
"use strict";
var curves = exports2;
var hash = require_hash();
var curve = require_curve();
var utils = require_utils3();
var assert = utils.assert;
function PresetCurve(options) {
if (options.type === "short")
this.curve = new curve.short(options);
else if (options.type === "edwards")
this.curve = new curve.edwards(options);
else
this.curve = new curve.mont(options);
this.g = this.curve.g;
this.n = this.curve.n;
this.hash = options.hash;
assert(this.g.validate(), "Invalid curve");
assert(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
}
curves.PresetCurve = PresetCurve;
function defineCurve(name, options) {
Object.defineProperty(curves, name, {
configurable: true,
enumerable: true,
get: function() {
var curve2 = new PresetCurve(options);
Object.defineProperty(curves, name, {
configurable: true,
enumerable: true,
value: curve2
});
return curve2;
}
});
}
defineCurve("p192", {
type: "short",
prime: "p192",
p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff",
a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
hash: hash.sha256,
gRed: false,
g: [
"188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
"07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"
]
});
defineCurve("p224", {
type: "short",
prime: "p224",
p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001",
a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe",
b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4",
n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d",
hash: hash.sha256,
gRed: false,
g: [
"b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
"bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"
]
});
defineCurve("p256", {
type: "short",
prime: null,
p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff",
a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc",
b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b",
n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551",
hash: hash.sha256,
gRed: false,
g: [
"6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
"4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"
]
});
defineCurve("p384", {
type: "short",
prime: null,
p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff",
a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc",
b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef",
n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973",
hash: hash.sha384,
gRed: false,
g: [
"aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7",
"3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"
]
});
defineCurve("p521", {
type: "short",
prime: null,
p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff",
a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc",
b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00",
n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409",
hash: hash.sha512,
gRed: false,
g: [
"000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66",
"00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"
]
});
defineCurve("curve25519", {
type: "mont",
prime: "p25519",
p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
a: "76d06",
b: "1",
n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
hash: hash.sha256,
gRed: false,
g: [
"9"
]
});
defineCurve("ed25519", {
type: "edwards",
prime: "p25519",
p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
a: "-1",
c: "1",
// -121665 * (121666^(-1)) (mod P)
d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
hash: hash.sha256,
gRed: false,
g: [
"216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
// 4/5
"6666666666666666666666666666666666666666666666666666666666666658"
]
});
var pre;
try {
pre = require_secp256k1();
} catch (e) {
pre = void 0;
}
defineCurve("secp256k1", {
type: "short",
prime: "k256",
p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f",
a: "0",
b: "7",
n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141",
h: "1",
hash: hash.sha256,
// Precomputed endomorphism
beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
basis: [
{
a: "3086d221a7d46bcde86c90e49284eb15",
b: "-e4437ed6010e88286f547fa90abfe4c3"
},
{
a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
b: "3086d221a7d46bcde86c90e49284eb15"
}
],
gRed: false,
g: [
"79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
pre
]
});
}
});
// node_modules/hmac-drbg/lib/hmac-drbg.js
var require_hmac_drbg = __commonJS({
"node_modules/hmac-drbg/lib/hmac-drbg.js"(exports2, module2) {
"use strict";
var hash = require_hash();
var utils = require_utils2();
var assert = require_minimalistic_assert();
function HmacDRBG(options) {
if (!(this instanceof HmacDRBG))
return new HmacDRBG(options);
this.hash = options.hash;
this.predResist = !!options.predResist;
this.outLen = this.hash.outSize;
this.minEntropy = options.minEntropy || this.hash.hmacStrength;
this._reseed = null;
this.reseedInterval = null;
this.K = null;
this.V = null;
var entropy = utils.toArray(options.entropy, options.entropyEnc || "hex");
var nonce = utils.toArray(options.nonce, options.nonceEnc || "hex");
var pers = utils.toArray(options.pers, options.persEnc || "hex");
assert(
entropy.length >= this.minEntropy / 8,
"Not enough entropy. Minimum is: " + this.minEntropy + " bits"
);
this._init(entropy, nonce, pers);
}
module2.exports = HmacDRBG;
HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
var seed = entropy.concat(nonce).concat(pers);
this.K = new Array(this.outLen / 8);
this.V = new Array(this.outLen / 8);
for (var i = 0; i < this.V.length; i++) {
this.K[i] = 0;
this.V[i] = 1;
}
this._update(seed);
this._reseed = 1;
this.reseedInterval = 281474976710656;
};
HmacDRBG.prototype._hmac = function hmac() {
return new hash.hmac(this.hash, this.K);
};
HmacDRBG.prototype._update = function update(seed) {
var kmac = this._hmac().update(this.V).update([0]);
if (seed)
kmac = kmac.update(seed);
this.K = kmac.digest();
this.V = this._hmac().update(this.V).digest();
if (!seed)
return;
this.K = this._hmac().update(this.V).update([1]).update(seed).digest();
this.V = this._hmac().update(this.V).digest();
};
HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add2, addEnc) {
if (typeof entropyEnc !== "string") {
addEnc = add2;
add2 = entropyEnc;
entropyEnc = null;
}
entropy = utils.toArray(entropy, entropyEnc);
add2 = utils.toArray(add2, addEnc);
assert(
entropy.length >= this.minEntropy / 8,
"Not enough entropy. Minimum is: " + this.minEntropy + " bits"
);
this._update(entropy.concat(add2 || []));
this._reseed = 1;
};
HmacDRBG.prototype.generate = function generate(len, enc, add2, addEnc) {
if (this._reseed > this.reseedInterval)
throw new Error("Reseed is required");
if (typeof enc !== "string") {
addEnc = add2;
add2 = enc;
enc = null;
}
if (add2) {
add2 = utils.toArray(add2, addEnc || "hex");
this._update(add2);
}
var temp = [];
while (temp.length < len) {
this.V = this._hmac().update(this.V).digest();
temp = temp.concat(this.V);
}
var res = temp.slice(0, len);
this._update(add2);
this._reseed++;
return utils.encode(res, enc);
};
}
});
// node_modules/elliptic/lib/elliptic/ec/key.js
var require_key = __commonJS({
"node_modules/elliptic/lib/elliptic/ec/key.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var utils = require_utils3();
var assert = utils.assert;
function KeyPair2(ec, options) {
this.ec = ec;
this.priv = null;
this.pub = null;
if (options.priv)
this._importPrivate(options.priv, options.privEnc);
if (options.pub)
this._importPublic(options.pub, options.pubEnc);
}
module2.exports = KeyPair2;
KeyPair2.fromPublic = function fromPublic(ec, pub, enc) {
if (pub instanceof KeyPair2)
return pub;
return new KeyPair2(ec, {
pub,
pubEnc: enc
});
};
KeyPair2.fromPrivate = function fromPrivate(ec, priv, enc) {
if (priv instanceof KeyPair2)
return priv;
return new KeyPair2(ec, {
priv,
privEnc: enc
});
};
KeyPair2.prototype.validate = function validate() {
var pub = this.getPublic();
if (pub.isInfinity())
return { result: false, reason: "Invalid public key" };
if (!pub.validate())
return { result: false, reason: "Public key is not a point" };
if (!pub.mul(this.ec.curve.n).isInfinity())
return { result: false, reason: "Public key * N != O" };
return { result: true, reason: null };
};
KeyPair2.prototype.getPublic = function getPublic(compact, enc) {
if (typeof compact === "string") {
enc = compact;
compact = null;
}
if (!this.pub)
this.pub = this.ec.g.mul(this.priv);
if (!enc)
return this.pub;
return this.pub.encode(enc, compact);
};
KeyPair2.prototype.getPrivate = function getPrivate(enc) {
if (enc === "hex")
return this.priv.toString(16, 2);
else
return this.priv;
};
KeyPair2.prototype._importPrivate = function _importPrivate(key, enc) {
this.priv = new BN(key, enc || 16);
this.priv = this.priv.umod(this.ec.curve.n);
};
KeyPair2.prototype._importPublic = function _importPublic(key, enc) {
if (key.x || key.y) {
if (this.ec.curve.type === "mont") {
assert(key.x, "Need x coordinate");
} else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") {
assert(key.x && key.y, "Need both x and y coordinate");
}
this.pub = this.ec.curve.point(key.x, key.y);
return;
}
this.pub = this.ec.curve.decodePoint(key, enc);
};
KeyPair2.prototype.derive = function derive(pub) {
if (!pub.validate()) {
assert(pub.validate(), "public point not validated");
}
return pub.mul(this.priv).getX();
};
KeyPair2.prototype.sign = function sign(msg, enc, options) {
return this.ec.sign(msg, this, enc, options);
};
KeyPair2.prototype.verify = function verify(msg, signature, options) {
return this.ec.verify(msg, signature, this, void 0, options);
};
KeyPair2.prototype.inspect = function inspect() {
return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
};
}
});
// node_modules/elliptic/lib/elliptic/ec/signature.js
var require_signature = __commonJS({
"node_modules/elliptic/lib/elliptic/ec/signature.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var utils = require_utils3();
var assert = utils.assert;
function Signature2(options, enc) {
if (options instanceof Signature2)
return options;
if (this._importDER(options, enc))
return;
assert(options.r && options.s, "Signature without r or s");
this.r = new BN(options.r, 16);
this.s = new BN(options.s, 16);
if (options.recoveryParam === void 0)
this.recoveryParam = null;
else
this.recoveryParam = options.recoveryParam;
}
module2.exports = Signature2;
function Position() {
this.place = 0;
}
function getLength(buf, p) {
var initial = buf[p.place++];
if (!(initial & 128)) {
return initial;
}
var octetLen = initial & 15;
if (octetLen === 0 || octetLen > 4) {
return false;
}
if (buf[p.place] === 0) {
return false;
}
var val = 0;
for (var i = 0, off = p.place; i < octetLen; i++, off++) {
val <<= 8;
val |= buf[off];
val >>>= 0;
}
if (val <= 127) {
return false;
}
p.place = off;
return val;
}
function rmPadding(buf) {
var i = 0;
var len = buf.length - 1;
while (!buf[i] && !(buf[i + 1] & 128) && i < len) {
i++;
}
if (i === 0) {
return buf;
}
return buf.slice(i);
}
Signature2.prototype._importDER = function _importDER(data, enc) {
data = utils.toArray(data, enc);
var p = new Position();
if (data[p.place++] !== 48) {
return false;
}
var len = getLength(data, p);
if (len === false) {
return false;
}
if (len + p.place !== data.length) {
return false;
}
if (data[p.place++] !== 2) {
return false;
}
var rlen = getLength(data, p);
if (rlen === false) {
return false;
}
if ((data[p.place] & 128) !== 0) {
return false;
}
var r = data.slice(p.place, rlen + p.place);
p.place += rlen;
if (data[p.place++] !== 2) {
return false;
}
var slen = getLength(data, p);
if (slen === false) {
return false;
}
if (data.length !== slen + p.place) {
return false;
}
if ((data[p.place] & 128) !== 0) {
return false;
}
var s = data.slice(p.place, slen + p.place);
if (r[0] === 0) {
if (r[1] & 128) {
r = r.slice(1);
} else {
return false;
}
}
if (s[0] === 0) {
if (s[1] & 128) {
s = s.slice(1);
} else {
return false;
}
}
this.r = new BN(r);
this.s = new BN(s);
this.recoveryParam = null;
return true;
};
function constructLength(arr, len) {
if (len < 128) {
arr.push(len);
return;
}
var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
arr.push(octets | 128);
while (--octets) {
arr.push(len >>> (octets << 3) & 255);
}
arr.push(len);
}
Signature2.prototype.toDER = function toDER(enc) {
var r = this.r.toArray();
var s = this.s.toArray();
if (r[0] & 128)
r = [0].concat(r);
if (s[0] & 128)
s = [0].concat(s);
r = rmPadding(r);
s = rmPadding(s);
while (!s[0] && !(s[1] & 128)) {
s = s.slice(1);
}
var arr = [2];
constructLength(arr, r.length);
arr = arr.concat(r);
arr.push(2);
constructLength(arr, s.length);
var backHalf = arr.concat(s);
var res = [48];
constructLength(res, backHalf.length);
res = res.concat(backHalf);
return utils.encode(res, enc);
};
}
});
// node_modules/elliptic/lib/elliptic/ec/index.js
var require_ec = __commonJS({
"node_modules/elliptic/lib/elliptic/ec/index.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var HmacDRBG = require_hmac_drbg();
var utils = require_utils3();
var curves = require_curves();
var rand = require_brorand();
var assert = utils.assert;
var KeyPair2 = require_key();
var Signature2 = require_signature();
function EC(options) {
if (!(this instanceof EC))
return new EC(options);
if (typeof options === "string") {
assert(
Object.prototype.hasOwnProperty.call(curves, options),
"Unknown curve " + options
);
options = curves[options];
}
if (options instanceof curves.PresetCurve)
options = { curve: options };
this.curve = options.curve.curve;
this.n = this.curve.n;
this.nh = this.n.ushrn(1);
this.g = this.curve.g;
this.g = options.curve.g;
this.g.precompute(options.curve.n.bitLength() + 1);
this.hash = options.hash || options.curve.hash;
}
module2.exports = EC;
EC.prototype.keyPair = function keyPair(options) {
return new KeyPair2(this, options);
};
EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
return KeyPair2.fromPrivate(this, priv, enc);
};
EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
return KeyPair2.fromPublic(this, pub, enc);
};
EC.prototype.genKeyPair = function genKeyPair(options) {
if (!options)
options = {};
var drbg = new HmacDRBG({
hash: this.hash,
pers: options.pers,
persEnc: options.persEnc || "utf8",
entropy: options.entropy || rand(this.hash.hmacStrength),
entropyEnc: options.entropy && options.entropyEnc || "utf8",
nonce: this.n.toArray()
});
var bytes = this.n.byteLength();
var ns2 = this.n.sub(new BN(2));
for (; ; ) {
var priv = new BN(drbg.generate(bytes));
if (priv.cmp(ns2) > 0)
continue;
priv.iaddn(1);
return this.keyFromPrivate(priv);
}
};
EC.prototype._truncateToN = function _truncateToN(msg, truncOnly, bitLength) {
var byteLength;
if (BN.isBN(msg) || typeof msg === "number") {
msg = new BN(msg, 16);
byteLength = msg.byteLength();
} else if (typeof msg === "object") {
byteLength = msg.length;
msg = new BN(msg, 16);
} else {
var str = msg.toString();
byteLength = str.length + 1 >>> 1;
msg = new BN(str, 16);
}
if (typeof bitLength !== "number") {
bitLength = byteLength * 8;
}
var delta = bitLength - this.n.bitLength();
if (delta > 0)
msg = msg.ushrn(delta);
if (!truncOnly && msg.cmp(this.n) >= 0)
return msg.sub(this.n);
else
return msg;
};
EC.prototype.sign = function sign(msg, key, enc, options) {
if (typeof enc === "object") {
options = enc;
enc = null;
}
if (!options)
options = {};
if (typeof msg !== "string" && typeof msg !== "number" && !BN.isBN(msg)) {
assert(
typeof msg === "object" && msg && typeof msg.length === "number",
"Expected message to be an array-like, a hex string, or a BN instance"
);
assert(msg.length >>> 0 === msg.length);
for (var i = 0; i < msg.length; i++) assert((msg[i] & 255) === msg[i]);
}
key = this.keyFromPrivate(key, enc);
msg = this._truncateToN(msg, false, options.msgBitLength);
assert(!msg.isNeg(), "Can not sign a negative message");
var bytes = this.n.byteLength();
var bkey = key.getPrivate().toArray("be", bytes);
var nonce = msg.toArray("be", bytes);
assert(new BN(nonce).eq(msg), "Can not sign message");
var drbg = new HmacDRBG({
hash: this.hash,
entropy: bkey,
nonce,
pers: options.pers,
persEnc: options.persEnc || "utf8"
});
var ns1 = this.n.sub(new BN(1));
for (var iter = 0; ; iter++) {
var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
k = this._truncateToN(k, true);
if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
continue;
var kp = this.g.mul(k);
if (kp.isInfinity())
continue;
var kpX = kp.getX();
var r = kpX.umod(this.n);
if (r.cmpn(0) === 0)
continue;
var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
s = s.umod(this.n);
if (s.cmpn(0) === 0)
continue;
var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);
if (options.canonical && s.cmp(this.nh) > 0) {
s = this.n.sub(s);
recoveryParam ^= 1;
}
return new Signature2({ r, s, recoveryParam });
}
};
EC.prototype.verify = function verify(msg, signature, key, enc, options) {
if (!options)
options = {};
msg = this._truncateToN(msg, false, options.msgBitLength);
key = this.keyFromPublic(key, enc);
signature = new Signature2(signature, "hex");
var r = signature.r;
var s = signature.s;
if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
return false;
if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
return false;
var sinv = s.invm(this.n);
var u1 = sinv.mul(msg).umod(this.n);
var u2 = sinv.mul(r).umod(this.n);
var p;
if (!this.curve._maxwellTrick) {
p = this.g.mulAdd(u1, key.getPublic(), u2);
if (p.isInfinity())
return false;
return p.getX().umod(this.n).cmp(r) === 0;
}
p = this.g.jmulAdd(u1, key.getPublic(), u2);
if (p.isInfinity())
return false;
return p.eqXToP(r);
};
EC.prototype.recoverPubKey = function(msg, signature, j, enc) {
assert((3 & j) === j, "The recovery param is more than two bits");
signature = new Signature2(signature, enc);
var n = this.n;
var e = new BN(msg);
var r = signature.r;
var s = signature.s;
var isYOdd = j & 1;
var isSecondKey = j >> 1;
if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
throw new Error("Unable to find sencond key candinate");
if (isSecondKey)
r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
else
r = this.curve.pointFromX(r, isYOdd);
var rInv = signature.r.invm(n);
var s1 = n.sub(e).mul(rInv).umod(n);
var s2 = s.mul(rInv).umod(n);
return this.g.mulAdd(s1, r, s2);
};
EC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {
signature = new Signature2(signature, enc);
if (signature.recoveryParam !== null)
return signature.recoveryParam;
for (var i = 0; i < 4; i++) {
var Qprime;
try {
Qprime = this.recoverPubKey(e, signature, i);
} catch (e2) {
continue;
}
if (Qprime.eq(Q))
return i;
}
throw new Error("Unable to find valid recovery factor");
};
}
});
// node_modules/elliptic/lib/elliptic/eddsa/key.js
var require_key2 = __commonJS({
"node_modules/elliptic/lib/elliptic/eddsa/key.js"(exports2, module2) {
"use strict";
var utils = require_utils3();
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var cachedProperty = utils.cachedProperty;
function KeyPair2(eddsa, params) {
this.eddsa = eddsa;
this._secret = parseBytes(params.secret);
if (eddsa.isPoint(params.pub))
this._pub = params.pub;
else
this._pubBytes = parseBytes(params.pub);
}
KeyPair2.fromPublic = function fromPublic(eddsa, pub) {
if (pub instanceof KeyPair2)
return pub;
return new KeyPair2(eddsa, { pub });
};
KeyPair2.fromSecret = function fromSecret(eddsa, secret) {
if (secret instanceof KeyPair2)
return secret;
return new KeyPair2(eddsa, { secret });
};
KeyPair2.prototype.secret = function secret() {
return this._secret;
};
cachedProperty(KeyPair2, "pubBytes", function pubBytes() {
return this.eddsa.encodePoint(this.pub());
});
cachedProperty(KeyPair2, "pub", function pub() {
if (this._pubBytes)
return this.eddsa.decodePoint(this._pubBytes);
return this.eddsa.g.mul(this.priv());
});
cachedProperty(KeyPair2, "privBytes", function privBytes() {
var eddsa = this.eddsa;
var hash = this.hash();
var lastIx = eddsa.encodingLength - 1;
var a = hash.slice(0, eddsa.encodingLength);
a[0] &= 248;
a[lastIx] &= 127;
a[lastIx] |= 64;
return a;
});
cachedProperty(KeyPair2, "priv", function priv() {
return this.eddsa.decodeInt(this.privBytes());
});
cachedProperty(KeyPair2, "hash", function hash() {
return this.eddsa.hash().update(this.secret()).digest();
});
cachedProperty(KeyPair2, "messagePrefix", function messagePrefix() {
return this.hash().slice(this.eddsa.encodingLength);
});
KeyPair2.prototype.sign = function sign(message) {
assert(this._secret, "KeyPair can only verify");
return this.eddsa.sign(message, this);
};
KeyPair2.prototype.verify = function verify(message, sig) {
return this.eddsa.verify(message, sig, this);
};
KeyPair2.prototype.getSecret = function getSecret(enc) {
assert(this._secret, "KeyPair is public only");
return utils.encode(this.secret(), enc);
};
KeyPair2.prototype.getPublic = function getPublic(enc) {
return utils.encode(this.pubBytes(), enc);
};
module2.exports = KeyPair2;
}
});
// node_modules/elliptic/lib/elliptic/eddsa/signature.js
var require_signature2 = __commonJS({
"node_modules/elliptic/lib/elliptic/eddsa/signature.js"(exports2, module2) {
"use strict";
var BN = require_bn();
var utils = require_utils3();
var assert = utils.assert;
var cachedProperty = utils.cachedProperty;
var parseBytes = utils.parseBytes;
function Signature2(eddsa, sig) {
this.eddsa = eddsa;
if (typeof sig !== "object")
sig = parseBytes(sig);
if (Array.isArray(sig)) {
assert(sig.length === eddsa.encodingLength * 2, "Signature has invalid size");
sig = {
R: sig.slice(0, eddsa.encodingLength),
S: sig.slice(eddsa.encodingLength)
};
}
assert(sig.R && sig.S, "Signature without R or S");
if (eddsa.isPoint(sig.R))
this._R = sig.R;
if (sig.S instanceof BN)
this._S = sig.S;
this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
}
cachedProperty(Signature2, "S", function S() {
return this.eddsa.decodeInt(this.Sencoded());
});
cachedProperty(Signature2, "R", function R() {
return this.eddsa.decodePoint(this.Rencoded());
});
cachedProperty(Signature2, "Rencoded", function Rencoded() {
return this.eddsa.encodePoint(this.R());
});
cachedProperty(Signature2, "Sencoded", function Sencoded() {
return this.eddsa.encodeInt(this.S());
});
Signature2.prototype.toBytes = function toBytes2() {
return this.Rencoded().concat(this.Sencoded());
};
Signature2.prototype.toHex = function toHex() {
return utils.encode(this.toBytes(), "hex").toUpperCase();
};
module2.exports = Signature2;
}
});
// node_modules/elliptic/lib/elliptic/eddsa/index.js
var require_eddsa = __commonJS({
"node_modules/elliptic/lib/elliptic/eddsa/index.js"(exports2, module2) {
"use strict";
var hash = require_hash();
var curves = require_curves();
var utils = require_utils3();
var assert = utils.assert;
var parseBytes = utils.parseBytes;
var KeyPair2 = require_key2();
var Signature2 = require_signature2();
function EDDSA(curve) {
assert(curve === "ed25519", "only tested with ed25519 so far");
if (!(this instanceof EDDSA))
return new EDDSA(curve);
curve = curves[curve].curve;
this.curve = curve;
this.g = curve.g;
this.g.precompute(curve.n.bitLength() + 1);
this.pointClass = curve.point().constructor;
this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
this.hash = hash.sha512;
}
module2.exports = EDDSA;
EDDSA.prototype.sign = function sign(message, secret) {
message = parseBytes(message);
var key = this.keyFromSecret(secret);
var r = this.hashInt(key.messagePrefix(), message);
var R = this.g.mul(r);
var Rencoded = this.encodePoint(R);
var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());
var S = r.add(s_).umod(this.curve.n);
return this.makeSignature({ R, S, Rencoded });
};
EDDSA.prototype.verify = function verify(message, sig, pub) {
message = parseBytes(message);
sig = this.makeSignature(sig);
if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) {
return false;
}
var key = this.keyFromPublic(pub);
var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
var SG = this.g.mul(sig.S());
var RplusAh = sig.R().add(key.pub().mul(h));
return RplusAh.eq(SG);
};
EDDSA.prototype.hashInt = function hashInt() {
var hash2 = this.hash();
for (var i = 0; i < arguments.length; i++)
hash2.update(arguments[i]);
return utils.intFromLE(hash2.digest()).umod(this.curve.n);
};
EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
return KeyPair2.fromPublic(this, pub);
};
EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
return KeyPair2.fromSecret(this, secret);
};
EDDSA.prototype.makeSignature = function makeSignature(sig) {
if (sig instanceof Signature2)
return sig;
return new Signature2(this, sig);
};
EDDSA.prototype.encodePoint = function encodePoint(point) {
var enc = point.getY().toArray("le", this.encodingLength);
enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
return enc;
};
EDDSA.prototype.decodePoint = function decodePoint(bytes) {
bytes = utils.parseBytes(bytes);
var lastIx = bytes.length - 1;
var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~128);
var xIsOdd = (bytes[lastIx] & 128) !== 0;
var y = utils.intFromLE(normed);
return this.curve.pointFromY(y, xIsOdd);
};
EDDSA.prototype.encodeInt = function encodeInt(num) {
return num.toArray("le", this.encodingLength);
};
EDDSA.prototype.decodeInt = function decodeInt(bytes) {
return utils.intFromLE(bytes);
};
EDDSA.prototype.isPoint = function isPoint(val) {
return val instanceof this.pointClass;
};
}
});
// node_modules/elliptic/lib/elliptic.js
var require_elliptic = __commonJS({
"node_modules/elliptic/lib/elliptic.js"(exports2) {
"use strict";
var elliptic = exports2;
elliptic.version = require_package2().version;
elliptic.utils = require_utils3();
elliptic.rand = require_brorand();
elliptic.curve = require_curve();
elliptic.curves = require_curves();
elliptic.ec = require_ec();
elliptic.eddsa = require_eddsa();
}
});
// node_modules/secp256k1/lib/elliptic.js
var require_elliptic2 = __commonJS({
"node_modules/secp256k1/lib/elliptic.js"(exports2, module2) {
var EC = require_elliptic().ec;
var ec = new EC("secp256k1");
var ecparams = ec.curve;
var BN = ecparams.n.constructor;
function loadCompressedPublicKey(first, xbuf) {
let x = new BN(xbuf);
if (x.cmp(ecparams.p) >= 0) return null;
x = x.toRed(ecparams.red);
let y = x.redSqr().redIMul(x).redIAdd(ecparams.b).redSqrt();
if (first === 3 !== y.isOdd()) y = y.redNeg();
const x3 = x.redSqr().redIMul(x);
if (!y.redSqr().redISub(x3.redIAdd(ecparams.b)).isZero()) return null;
return ec.keyPair({ pub: { x, y } });
}
function loadUncompressedPublicKey(first, xbuf, ybuf) {
let x = new BN(xbuf);
let y = new BN(ybuf);
if (x.cmp(ecparams.p) >= 0 || y.cmp(ecparams.p) >= 0) return null;
x = x.toRed(ecparams.red);
y = y.toRed(ecparams.red);
if ((first === 6 || first === 7) && y.isOdd() !== (first === 7)) return null;
const x3 = x.redSqr().redIMul(x);
if (!y.redSqr().redISub(x3.redIAdd(ecparams.b)).isZero()) return null;
return ec.keyPair({ pub: { x, y } });
}
function loadPublicKey(pubkey) {
const first = pubkey[0];
switch (first) {
case 2:
case 3:
if (pubkey.length !== 33) return null;
return loadCompressedPublicKey(first, pubkey.subarray(1, 33));
case 4:
case 6:
case 7:
if (pubkey.length !== 65) return null;
return loadUncompressedPublicKey(first, pubkey.subarray(1, 33), pubkey.subarray(33, 65));
default:
return null;
}
}
function savePublicKey(output, point) {
const pubkey = point.encode(null, output.length === 33);
for (let i = 0; i < output.length; ++i) output[i] = pubkey[i];
}
module2.exports = {
contextRandomize() {
return 0;
},
privateKeyVerify(seckey) {
const bn = new BN(seckey);
return bn.cmp(ecparams.n) < 0 && !bn.isZero() ? 0 : 1;
},
privateKeyNegate(seckey) {
const bn = new BN(seckey);
const negate = ecparams.n.sub(bn).umod(ecparams.n).toArrayLike(Uint8Array, "be", 32);
seckey.set(negate);
return 0;
},
privateKeyTweakAdd(seckey, tweak) {
const bn = new BN(tweak);
if (bn.cmp(ecparams.n) >= 0) return 1;
bn.iadd(new BN(seckey));
if (bn.cmp(ecparams.n) >= 0) bn.isub(ecparams.n);
if (bn.isZero()) return 1;
const tweaked = bn.toArrayLike(Uint8Array, "be", 32);
seckey.set(tweaked);
return 0;
},
privateKeyTweakMul(seckey, tweak) {
let bn = new BN(tweak);
if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1;
bn.imul(new BN(seckey));
if (bn.cmp(ecparams.n) >= 0) bn = bn.umod(ecparams.n);
const tweaked = bn.toArrayLike(Uint8Array, "be", 32);
seckey.set(tweaked);
return 0;
},
publicKeyVerify(pubkey) {
const pair = loadPublicKey(pubkey);
return pair === null ? 1 : 0;
},
publicKeyCreate(output, seckey) {
const bn = new BN(seckey);
if (bn.cmp(ecparams.n) >= 0 || bn.isZero()) return 1;
const point = ec.keyFromPrivate(seckey).getPublic();
savePublicKey(output, point);
return 0;
},
publicKeyConvert(output, pubkey) {
const pair = loadPublicKey(pubkey);
if (pair === null) return 1;
const point = pair.getPublic();
savePublicKey(output, point);
return 0;
},
publicKeyNegate(output, pubkey) {
const pair = loadPublicKey(pubkey);
if (pair === null) return 1;
const point = pair.getPublic();
point.y = point.y.redNeg();
savePublicKey(output, point);
return 0;
},
publicKeyCombine(output, pubkeys) {
const pairs = new Array(pubkeys.length);
for (let i = 0; i < pubkeys.length; ++i) {
pairs[i] = loadPublicKey(pubkeys[i]);
if (pairs[i] === null) return 1;
}
let point = pairs[0].getPublic();
for (let i = 1; i < pairs.length; ++i) point = point.add(pairs[i].pub);
if (point.isInfinity()) return 2;
savePublicKey(output, point);
return 0;
},
publicKeyTweakAdd(output, pubkey, tweak) {
const pair = loadPublicKey(pubkey);
if (pair === null) return 1;
tweak = new BN(tweak);
if (tweak.cmp(ecparams.n) >= 0) return 2;
const point = pair.getPublic().add(ecparams.g.mul(tweak));
if (point.isInfinity()) return 2;
savePublicKey(output, point);
return 0;
},
publicKeyTweakMul(output, pubkey, tweak) {
const pair = loadPublicKey(pubkey);
if (pair === null) return 1;
tweak = new BN(tweak);
if (tweak.cmp(ecparams.n) >= 0 || tweak.isZero()) return 2;
const point = pair.getPublic().mul(tweak);
savePublicKey(output, point);
return 0;
},
signatureNormalize(sig) {
const r = new BN(sig.subarray(0, 32));
const s = new BN(sig.subarray(32, 64));
if (r.cmp(ecparams.n) >= 0 || s.cmp(ecparams.n) >= 0) return 1;
if (s.cmp(ec.nh) === 1) {
sig.set(ecparams.n.sub(s).toArrayLike(Uint8Array, "be", 32), 32);
}
return 0;
},
// Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js
// Adapted for Uint8Array instead Buffer
signatureExport(obj, sig) {
const sigR = sig.subarray(0, 32);
const sigS = sig.subarray(32, 64);
if (new BN(sigR).cmp(ecparams.n) >= 0) return 1;
if (new BN(sigS).cmp(ecparams.n) >= 0) return 1;
const { output } = obj;
let r = output.subarray(4, 4 + 33);
r[0] = 0;
r.set(sigR, 1);
let lenR = 33;
let posR = 0;
for (; lenR > 1 && r[posR] === 0 && !(r[posR + 1] & 128); --lenR, ++posR) ;
r = r.subarray(posR);
if (r[0] & 128) return 1;
if (lenR > 1 && r[0] === 0 && !(r[1] & 128)) return 1;
let s = output.subarray(6 + 33, 6 + 33 + 33);
s[0] = 0;
s.set(sigS, 1);
let lenS = 33;
let posS = 0;
for (; lenS > 1 && s[posS] === 0 && !(s[posS + 1] & 128); --lenS, ++posS) ;
s = s.subarray(posS);
if (s[0] & 128) return 1;
if (lenS > 1 && s[0] === 0 && !(s[1] & 128)) return 1;
obj.outputlen = 6 + lenR + lenS;
output[0] = 48;
output[1] = obj.outputlen - 2;
output[2] = 2;
output[3] = r.length;
output.set(r, 4);
output[4 + lenR] = 2;
output[5 + lenR] = s.length;
output.set(s, 6 + lenR);
return 0;
},
// Copied 1-to-1 from https://github.com/bitcoinjs/bip66/blob/master/index.js
// Adapted for Uint8Array instead Buffer
signatureImport(output, sig) {
if (sig.length < 8) return 1;
if (sig.length > 72) return 1;
if (sig[0] !== 48) return 1;
if (sig[1] !== sig.length - 2) return 1;
if (sig[2] !== 2) return 1;
const lenR = sig[3];
if (lenR === 0) return 1;
if (5 + lenR >= sig.length) return 1;
if (sig[4 + lenR] !== 2) return 1;
const lenS = sig[5 + lenR];
if (lenS === 0) return 1;
if (6 + lenR + lenS !== sig.length) return 1;
if (sig[4] & 128) return 1;
if (lenR > 1 && sig[4] === 0 && !(sig[5] & 128)) return 1;
if (sig[lenR + 6] & 128) return 1;
if (lenS > 1 && sig[lenR + 6] === 0 && !(sig[lenR + 7] & 128)) return 1;
let sigR = sig.subarray(4, 4 + lenR);
if (sigR.length === 33 && sigR[0] === 0) sigR = sigR.subarray(1);
if (sigR.length > 32) return 1;
let sigS = sig.subarray(6 + lenR);
if (sigS.length === 33 && sigS[0] === 0) sigS = sigS.slice(1);
if (sigS.length > 32) throw new Error("S length is too long");
let r = new BN(sigR);
if (r.cmp(ecparams.n) >= 0) r = new BN(0);
let s = new BN(sig.subarray(6 + lenR));
if (s.cmp(ecparams.n) >= 0) s = new BN(0);
output.set(r.toArrayLike(Uint8Array, "be", 32), 0);
output.set(s.toArrayLike(Uint8Array, "be", 32), 32);
return 0;
},
ecdsaSign(obj, message, seckey, data, noncefn) {
if (noncefn) {
const _noncefn = noncefn;
noncefn = (counter) => {
const nonce = _noncefn(message, seckey, null, data, counter);
const isValid = nonce instanceof Uint8Array && nonce.length === 32;
if (!isValid) throw new Error("This is the way");
return new BN(nonce);
};
}
const d = new BN(seckey);
if (d.cmp(ecparams.n) >= 0 || d.isZero()) return 1;
let sig;
try {
sig = ec.sign(message, seckey, { canonical: true, k: noncefn, pers: data });
} catch (err) {
return 1;
}
obj.signature.set(sig.r.toArrayLike(Uint8Array, "be", 32), 0);
obj.signature.set(sig.s.toArrayLike(Uint8Array, "be", 32), 32);
obj.recid = sig.recoveryParam;
return 0;
},
ecdsaVerify(sig, msg32, pubkey) {
const sigObj = { r: sig.subarray(0, 32), s: sig.subarray(32, 64) };
const sigr = new BN(sigObj.r);
const sigs = new BN(sigObj.s);
if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1;
if (sigs.cmp(ec.nh) === 1 || sigr.isZero() || sigs.isZero()) return 3;
const pair = loadPublicKey(pubkey);
if (pair === null) return 2;
const point = pair.getPublic();
const isValid = ec.verify(msg32, sigObj, point);
return isValid ? 0 : 3;
},
ecdsaRecover(output, sig, recid, msg32) {
const sigObj = { r: sig.slice(0, 32), s: sig.slice(32, 64) };
const sigr = new BN(sigObj.r);
const sigs = new BN(sigObj.s);
if (sigr.cmp(ecparams.n) >= 0 || sigs.cmp(ecparams.n) >= 0) return 1;
if (sigr.isZero() || sigs.isZero()) return 2;
let point;
try {
point = ec.recoverPubKey(msg32, sigObj, recid);
} catch (err) {
return 2;
}
savePublicKey(output, point);
return 0;
},
ecdh(output, pubkey, seckey, data, hashfn, xbuf, ybuf) {
const pair = loadPublicKey(pubkey);
if (pair === null) return 1;
const scalar = new BN(seckey);
if (scalar.cmp(ecparams.n) >= 0 || scalar.isZero()) return 2;
const point = pair.getPublic().mul(scalar);
if (hashfn === void 0) {
const data2 = point.encode(null, true);
const sha2562 = ec.hash().update(data2).digest();
for (let i = 0; i < 32; ++i) output[i] = sha2562[i];
} else {
if (!xbuf) xbuf = new Uint8Array(32);
const x = point.getX().toArray("be", 32);
for (let i = 0; i < 32; ++i) xbuf[i] = x[i];
if (!ybuf) ybuf = new Uint8Array(32);
const y = point.getY().toArray("be", 32);
for (let i = 0; i < 32; ++i) ybuf[i] = y[i];
const hash = hashfn(xbuf, ybuf, data);
const isValid = hash instanceof Uint8Array && hash.length === output.length;
if (!isValid) return 2;
output.set(hash);
}
return 0;
}
};
}
});
// node_modules/secp256k1/elliptic.js
var require_elliptic3 = __commonJS({
"node_modules/secp256k1/elliptic.js"(exports2, module2) {
module2.exports = require_lib()(require_elliptic2());
}
});
// node_modules/secp256k1/index.js
var require_secp256k12 = __commonJS({
"node_modules/secp256k1/index.js"(exports2, module2) {
try {
module2.exports = require_bindings();
} catch (err) {
module2.exports = require_elliptic3();
}
}
});
// node_modules/exponential-backoff/dist/options.js
var require_options = __commonJS({
"node_modules/exponential-backoff/dist/options.js"(exports2) {
"use strict";
var __assign = exports2 && exports2.__assign || function() {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
Object.defineProperty(exports2, "__esModule", { value: true });
var defaultOptions = {
delayFirstAttempt: false,
jitter: "none",
maxDelay: Infinity,
numOfAttempts: 10,
retry: function() {
return true;
},
startingDelay: 100,
timeMultiple: 2
};
function getSanitizedOptions(options) {
var sanitized = __assign(__assign({}, defaultOptions), options);
if (sanitized.numOfAttempts < 1) {
sanitized.numOfAttempts = 1;
}
return sanitized;
}
exports2.getSanitizedOptions = getSanitizedOptions;
}
});
// node_modules/exponential-backoff/dist/jitter/full/full.jitter.js
var require_full_jitter = __commonJS({
"node_modules/exponential-backoff/dist/jitter/full/full.jitter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
function fullJitter(delay) {
var jitteredDelay = Math.random() * delay;
return Math.round(jitteredDelay);
}
exports2.fullJitter = fullJitter;
}
});
// node_modules/exponential-backoff/dist/jitter/no/no.jitter.js
var require_no_jitter = __commonJS({
"node_modules/exponential-backoff/dist/jitter/no/no.jitter.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
function noJitter(delay) {
return delay;
}
exports2.noJitter = noJitter;
}
});
// node_modules/exponential-backoff/dist/jitter/jitter.factory.js
var require_jitter_factory = __commonJS({
"node_modules/exponential-backoff/dist/jitter/jitter.factory.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var full_jitter_1 = require_full_jitter();
var no_jitter_1 = require_no_jitter();
function JitterFactory(options) {
switch (options.jitter) {
case "full":
return full_jitter_1.fullJitter;
case "none":
default:
return no_jitter_1.noJitter;
}
}
exports2.JitterFactory = JitterFactory;
}
});
// node_modules/exponential-backoff/dist/delay/delay.base.js
var require_delay_base = __commonJS({
"node_modules/exponential-backoff/dist/delay/delay.base.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var jitter_factory_1 = require_jitter_factory();
var Delay = (
/** @class */
function() {
function Delay2(options) {
this.options = options;
this.attempt = 0;
}
Delay2.prototype.apply = function() {
var _this = this;
return new Promise(function(resolve) {
return setTimeout(resolve, _this.jitteredDelay);
});
};
Delay2.prototype.setAttemptNumber = function(attempt) {
this.attempt = attempt;
};
Object.defineProperty(Delay2.prototype, "jitteredDelay", {
get: function() {
var jitter = jitter_factory_1.JitterFactory(this.options);
return jitter(this.delay);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Delay2.prototype, "delay", {
get: function() {
var constant = this.options.startingDelay;
var base = this.options.timeMultiple;
var power = this.numOfDelayedAttempts;
var delay = constant * Math.pow(base, power);
return Math.min(delay, this.options.maxDelay);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Delay2.prototype, "numOfDelayedAttempts", {
get: function() {
return this.attempt;
},
enumerable: true,
configurable: true
});
return Delay2;
}()
);
exports2.Delay = Delay;
}
});
// node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js
var require_skip_first_delay = __commonJS({
"node_modules/exponential-backoff/dist/delay/skip-first/skip-first.delay.js"(exports2) {
"use strict";
var __extends2 = exports2 && exports2.__extends || /* @__PURE__ */ function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = exports2 && exports2.__generator || function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports2, "__esModule", { value: true });
var delay_base_1 = require_delay_base();
var SkipFirstDelay = (
/** @class */
function(_super) {
__extends2(SkipFirstDelay2, _super);
function SkipFirstDelay2() {
return _super !== null && _super.apply(this, arguments) || this;
}
SkipFirstDelay2.prototype.apply = function() {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a2) {
return [2, this.isFirstAttempt ? true : _super.prototype.apply.call(this)];
});
});
};
Object.defineProperty(SkipFirstDelay2.prototype, "isFirstAttempt", {
get: function() {
return this.attempt === 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(SkipFirstDelay2.prototype, "numOfDelayedAttempts", {
get: function() {
return this.attempt - 1;
},
enumerable: true,
configurable: true
});
return SkipFirstDelay2;
}(delay_base_1.Delay)
);
exports2.SkipFirstDelay = SkipFirstDelay;
}
});
// node_modules/exponential-backoff/dist/delay/always/always.delay.js
var require_always_delay = __commonJS({
"node_modules/exponential-backoff/dist/delay/always/always.delay.js"(exports2) {
"use strict";
var __extends2 = exports2 && exports2.__extends || /* @__PURE__ */ function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
Object.defineProperty(exports2, "__esModule", { value: true });
var delay_base_1 = require_delay_base();
var AlwaysDelay = (
/** @class */
function(_super) {
__extends2(AlwaysDelay2, _super);
function AlwaysDelay2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return AlwaysDelay2;
}(delay_base_1.Delay)
);
exports2.AlwaysDelay = AlwaysDelay;
}
});
// node_modules/exponential-backoff/dist/delay/delay.factory.js
var require_delay_factory = __commonJS({
"node_modules/exponential-backoff/dist/delay/delay.factory.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
var skip_first_delay_1 = require_skip_first_delay();
var always_delay_1 = require_always_delay();
function DelayFactory(options, attempt) {
var delay = initDelayClass(options);
delay.setAttemptNumber(attempt);
return delay;
}
exports2.DelayFactory = DelayFactory;
function initDelayClass(options) {
if (!options.delayFirstAttempt) {
return new skip_first_delay_1.SkipFirstDelay(options);
}
return new always_delay_1.AlwaysDelay(options);
}
}
});
// node_modules/exponential-backoff/dist/backoff.js
var require_backoff = __commonJS({
"node_modules/exponential-backoff/dist/backoff.js"(exports2) {
"use strict";
var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = exports2 && exports2.__generator || function(thisArg, body) {
var _ = { label: 0, sent: function() {
if (t[0] & 1) throw t[1];
return t[1];
}, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2]) _.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
} catch (e) {
op = [6, e];
y = 0;
} finally {
f = t = 0;
}
if (op[0] & 5) throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports2, "__esModule", { value: true });
var options_1 = require_options();
var delay_factory_1 = require_delay_factory();
function backOff2(request, options) {
if (options === void 0) {
options = {};
}
return __awaiter(this, void 0, void 0, function() {
var sanitizedOptions, backOff3;
return __generator(this, function(_a2) {
switch (_a2.label) {
case 0:
sanitizedOptions = options_1.getSanitizedOptions(options);
backOff3 = new BackOff(request, sanitizedOptions);
return [4, backOff3.execute()];
case 1:
return [2, _a2.sent()];
}
});
});
}
exports2.backOff = backOff2;
var BackOff = (
/** @class */
function() {
function BackOff2(request, options) {
this.request = request;
this.options = options;
this.attemptNumber = 0;
}
BackOff2.prototype.execute = function() {
return __awaiter(this, void 0, void 0, function() {
var e_1, shouldRetry;
return __generator(this, function(_a2) {
switch (_a2.label) {
case 0:
if (!!this.attemptLimitReached) return [3, 7];
_a2.label = 1;
case 1:
_a2.trys.push([1, 4, , 6]);
return [4, this.applyDelay()];
case 2:
_a2.sent();
return [4, this.request()];
case 3:
return [2, _a2.sent()];
case 4:
e_1 = _a2.sent();
this.attemptNumber++;
return [4, this.options.retry(e_1, this.attemptNumber)];
case 5:
shouldRetry = _a2.sent();
if (!shouldRetry || this.attemptLimitReached) {
throw e_1;
}
return [3, 6];
case 6:
return [3, 0];
case 7:
throw new Error("Something went wrong.");
}
});
});
};
Object.defineProperty(BackOff2.prototype, "attemptLimitReached", {
get: function() {
return this.attemptNumber >= this.options.numOfAttempts;
},
enumerable: true,
configurable: true
});
BackOff2.prototype.applyDelay = function() {
return __awaiter(this, void 0, void 0, function() {
var delay;
return __generator(this, function(_a2) {
switch (_a2.label) {
case 0:
delay = delay_factory_1.DelayFactory(this.options, this.attemptNumber);
return [4, delay.apply()];
case 1:
_a2.sent();
return [
2
/*return*/
];
}
});
});
};
return BackOff2;
}()
);
}
});
// src/agentHelpers.ts
var agentHelpers_exports = {};
__export(agentHelpers_exports, {
deriveAgentAccount: () => deriveAgentAccount,
registerAgent: () => registerAgent
});
module.exports = __toCommonJS(agentHelpers_exports);
var dotenv2 = __toESM(require_main(), 1);
// src/tappd.ts
var import_net = __toESM(require("net"), 1);
var import_crypto = __toESM(require("crypto"), 1);
var import_http = __toESM(require("http"), 1);
var import_https = __toESM(require("https"), 1);
var import_url = require("url");
function to_hex(data) {
if (typeof data === "string") {
return Buffer.from(data).toString("hex");
}
if (data instanceof Uint8Array) {
return Buffer.from(data).toString("hex");
}
return data.toString("hex");
}
function x509key_to_uint8array(pem, max_length) {
const content = pem.replace(/-----BEGIN PRIVATE KEY-----/, "").replace(/-----END PRIVATE KEY-----/, "").replace(/\n/g, "");
const binaryDer = atob(content);
if (!max_length) {
max_length = binaryDer.length;
}
const result = new Uint8Array(max_length);
for (let i = 0; i < max_length; i++) {
result[i] = binaryDer.charCodeAt(i);
}
return result;
}
function replay_rtmr(history) {
const INIT_MR = "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
if (history.length === 0) {
return INIT_MR;
}
let mr = Buffer.from(INIT_MR, "hex");
for (const content of history) {
let contentBuffer = Buffer.from(content, "hex");
if (contentBuffer.length < 48) {
const padding = Buffer.alloc(48 - contentBuffer.length, 0);
contentBuffer = Buffer.concat([contentBuffer, padding]);
}
mr = import_crypto.default.createHash("sha384").update(Buffer.concat([mr, contentBuffer])).digest();
}
return mr.toString("hex");
}
function reply_rtmrs(event_log) {
const rtmrs = [];
for (let idx = 0; idx < 4; idx++) {
const history = event_log.filter((event) => event.imr === idx).map((event) => event.digest);
rtmrs[idx] = replay_rtmr(history);
}
return rtmrs;
}
function send_rpc_request(endpoint2, path, payload) {
return new Promise((resolve, reject) => {
const abortController = new AbortController();
const timeout = setTimeout(() => {
abortController.abort();
reject(new Error("Request timed out"));
}, 3e4);
const isHttp = endpoint2.startsWith("http://") || endpoint2.startsWith("https://");
if (isHttp) {
const url = new import_url.URL(path, endpoint2);
const options = {
method: "POST",
headers: {
"Content-Type": "application/json",
"Content-Length": Buffer.byteLength(payload)
}
};
const req = (url.protocol === "https:" ? import_https.default : import_http.default).request(
url,
options,
(res) => {
let data = "";
res.on("data", (chunk) => {
data += chunk;
});
res.on("end", () => {
clearTimeout(timeout);
try {
const result = JSON.parse(data);
resolve(result);
} catch (error) {
reject(new Error("Failed to parse response"));
}
});
}
);
req.on("error", (error) => {
clearTimeout(timeout);
reject(error);
});
abortController.signal.addEventListener("abort", () => {
req.destroy();
reject(new Error("Request aborted"));
});
req.write(payload);
req.end();
} else {
const client = import_net.default.createConnection({ path: endpoint2 }, () => {
client.write(`POST ${path} HTTP/1.1\r
`);
client.write(`Host: localhost\r
`);
client.write(`Content-Type: application/json\r
`);
client.write(`Content-Length: ${payload.length}\r
`);
client.write("\r\n");
client.write(payload);
});
let data = "";
let headers = {};
let headersParsed = false;
let contentLength = 0;
let bodyData = "";
client.on("data", (chunk) => {
data += chunk;
if (!headersParsed) {
const headerEndIndex = data.indexOf("\r\n\r\n");
if (headerEndIndex !== -1) {
const headerLines = data.slice(0, headerEndIndex).split("\r\n");
headerLines.forEach((line) => {
const [key, value] = line.split(": ");
if (key && value) {
headers[key.toLowerCase()] = value;
}
});
headersParsed = true;
contentLength = parseInt(
headers["content-length"] || "0",
10
);
bodyData = data.slice(headerEndIndex + 4);
}
} else {
bodyData += chunk;
}
if (headersParsed && bodyData.length >= contentLength) {
client.end();
}
});
client.on("end", () => {
clearTimeout(timeout);
try {
const result = JSON.parse(bodyData.slice(0, contentLength));
resolve(result);
} catch (error) {
reject(new Error("Failed to parse response"));
}
});
client.on("error", (error) => {
clearTimeout(timeout);
reject(error);
});
abortController.signal.addEventListener("abort", () => {
client.destroy();
reject(new Error("Request aborted"));
});
}
});
}
var TappdClient = class {
constructor(endpoint2 = "/var/run/tappd.sock") {
if (process.env.DSTACK_SIMULATOR_ENDPOINT) {
console.debug(
`Using simulator endpoint: ${process.env.DSTACK_SIMULATOR_ENDPOINT}`
);
endpoint2 = process.env.DSTACK_SIMULATOR_ENDPOINT;
}
this.endpoint = endpoint2;
}
async getInfo() {
const result = await send_rpc_request(
this.endpoint,
"/prpc/Tappd.Info",
""
);
return result;
}
async extendRtmr3(event, payload) {
const payloadJson = typeof payload === "string" ? payload : JSON.stringify(payload);
const result = await send_rpc_request(
this.endpoint,
"/prpc/Tappd.EmitEvent",
JSON.stringify({ event, payload: payloadJson })
);
return result;
}
async deriveKey(path, subject, alt_names) {
let raw = {
path: path || "",
subject: subject || path || ""
};
if (alt_names && alt_names.length) {
raw["alt_names"] = alt_names;
}
const payload = JSON.stringify(raw);
const result = await send_rpc_request(
this.endpoint,
"/prpc/Tappd.DeriveKey",
payload
);
Object.defineProperty(result, "asUint8Array", {
get: () => (length) => x509key_to_uint8array(result.key, length),
enumerable: true,
configurable: false
});
return Object.freeze(result);
}
async tdxQuote(report_data, hash_algorithm) {
let hex = to_hex(report_data);
if (hash_algorithm === "raw") {
if (hex.length > 128) {
throw new Error(
`Report data is too large, it should less then 64 bytes when hash_algorithm is raw.`
);
}
if (hex.length < 128) {
hex = hex.padStart(128, "0");
}
}
const payload = JSON.stringify({ report_data: hex, hash_algorithm });
const result = await send_rpc_request(
this.endpoint,
"/prpc/Tappd.TdxQuote",
payload
);
if ("error" in result) {
const err = result["error"];
throw new Error(err);
}
Object.defineProperty(result, "replayRtmrs", {
get: () => () => reply_rtmrs(JSON.parse(result.event_log)),
enumerable: true,
configurable: false
});
return Object.freeze(result);
}
};
// src/agentHelpers.ts
var import_near_seed_phrase2 = __toESM(require_near_seed_phrase(), 1);
// src/near.ts
var dotenv = __toESM(require_main(), 1);
var import_near_seed_phrase = __toESM(require_near_seed_phrase(), 1);
// node_modules/@near-js/providers/lib/esm/exponential-backoff.js
async function exponentialBackoff(startWaitTime, retryNumber, waitBackoff, getResult) {
let waitTime = startWaitTime;
for (let i = 0; i < retryNumber; i++) {
const result = await getResult();
if (result) {
return result;
}
await sleep(waitTime);
waitTime *= waitBackoff;
}
return null;
}
function sleep(millis) {
return new Promise((resolve) => setTimeout(resolve, millis));
}
// node_modules/@near-js/types/lib/esm/enum.js
var Enum = class {
constructor(properties) {
if (Object.keys(properties).length !== 1) {
throw new Error("Enum can only take single value");
}
Object.keys(properties).map((key) => {
this[key] = properties[key];
});
}
};
// node_modules/@near-js/types/lib/esm/errors.js
var PositionalArgsError = class extends Error {
constructor() {
super("Contract method calls expect named arguments wrapped in object, e.g. { argName1: argValue1, argName2: argValue2 }");
}
};
var TypedError = class extends Error {
constructor(message, type, context) {
super(message);
__publicField(this, "type");
__publicField(this, "context");
this.type = type || "UntypedError";
this.context = context;
}
};
var ErrorContext = class {
constructor(transactionHash) {
__publicField(this, "transactionHash");
this.transactionHash = transactionHash;
}
};
// node_modules/@near-js/utils/lib/esm/index.js
var import_mustache = __toESM(require_mustache(), 1);
// node_modules/@scure/base/lib/esm/index.js
function isBytes(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
}
function isArrayOf(isString2, arr) {
if (!Array.isArray(arr))
return false;
if (arr.length === 0)
return true;
if (isString2) {
return arr.every((item) => typeof item === "string");
} else {
return arr.every((item) => Number.isSafeInteger(item));
}
}
function astr(label, input) {
if (typeof input !== "string")
throw new Error(`${label}: string expected`);
return true;
}
function anumber(n) {
if (!Number.isSafeInteger(n))
throw new Error(`invalid integer: ${n}`);
}
function aArr(input) {
if (!Array.isArray(input))
throw new Error("array expected");
}
function astrArr(label, input) {
if (!isArrayOf(true, input))
throw new Error(`${label}: array of strings expected`);
}
function anumArr(label, input) {
if (!isArrayOf(false, input))
throw new Error(`${label}: array of numbers expected`);
}
// @__NO_SIDE_EFFECTS__
function chain(...args) {
const id = (a) => a;
const wrap = (a, b) => (c) => a(b(c));
const encode = args.map((x) => x.encode).reduceRight(wrap, id);
const decode = args.map((x) => x.decode).reduce(wrap, id);
return { encode, decode };
}
// @__NO_SIDE_EFFECTS__
function alphabet(letters) {
const lettersA = typeof letters === "string" ? letters.split("") : letters;
const len = lettersA.length;
astrArr("alphabet", lettersA);
const indexes = new Map(lettersA.map((l, i) => [l, i]));
return {
encode: (digits) => {
aArr(digits);
return digits.map((i) => {
if (!Number.isSafeInteger(i) || i < 0 || i >= len)
throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
return lettersA[i];
});
},
decode: (input) => {
aArr(input);
return input.map((letter) => {
astr("alphabet.decode", letter);
const i = indexes.get(letter);
if (i === void 0)
throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
return i;
});
}
};
}
// @__NO_SIDE_EFFECTS__
function join(separator = "") {
astr("join", separator);
return {
encode: (from) => {
astrArr("join.decode", from);
return from.join(separator);
},
decode: (to) => {
astr("join.decode", to);
return to.split(separator);
}
};
}
function convertRadix(data, from, to) {
if (from < 2)
throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
if (to < 2)
throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
aArr(data);
if (!data.length)
return [];
let pos = 0;
const res = [];
const digits = Array.from(data, (d) => {
anumber(d);
if (d < 0 || d >= from)
throw new Error(`invalid integer: ${d}`);
return d;
});
const dlen = digits.length;
while (true) {
let carry = 0;
let done = true;
for (let i = pos; i < dlen; i++) {
const digit = digits[i];
const fromCarry = from * carry;
const digitBase = fromCarry + digit;
if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
throw new Error("convertRadix: carry overflow");
}
const div = digitBase / to;
carry = digitBase % to;
const rounded = Math.floor(div);
digits[i] = rounded;
if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
throw new Error("convertRadix: carry overflow");
if (!done)
continue;
else if (!rounded)
pos = i;
else
done = false;
}
res.push(carry);
if (done)
break;
}
for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
res.push(0);
return res.reverse();
}
// @__NO_SIDE_EFFECTS__
function radix(num) {
anumber(num);
const _256 = 2 ** 8;
return {
encode: (bytes) => {
if (!isBytes(bytes))
throw new Error("radix.encode input should be Uint8Array");
return convertRadix(Array.from(bytes), _256, num);
},
decode: (digits) => {
anumArr("radix.decode", digits);
return Uint8Array.from(convertRadix(digits, num, _256));
}
};
}
var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
// node_modules/@near-js/utils/lib/esm/index.js
var import_depd = __toESM(require_depd(), 1);
var DEFAULT_FUNCTION_CALL_GAS = 30000000000000n;
var error_messages_default = {
GasLimitExceeded: "Exceeded the maximum amount of gas allowed to burn per contract",
MethodEmptyName: "Method name is empty",
WasmerCompileError: "Wasmer compilation error: {{msg}}",
GuestPanic: "Smart contract panicked: {{panic_msg}}",
Memory: "Error creating Wasm memory",
GasExceeded: "Exceeded the prepaid gas",
MethodUTF8Error: "Method name is not valid UTF8 string",
BadUTF16: "String encoding is bad UTF-16 sequence",
WasmTrap: "WebAssembly trap: {{msg}}",
GasInstrumentation: "Gas instrumentation failed or contract has denied instructions.",
InvalidPromiseIndex: "{{promise_idx}} does not correspond to existing promises",
InvalidPromiseResultIndex: "Accessed invalid promise result index: {{result_idx}}",
Deserialization: "Error happened while deserializing the module",
MethodNotFound: "Contract method is not found",
InvalidRegisterId: "Accessed invalid register id: {{register_id}}",
InvalidReceiptIndex: "VM Logic returned an invalid receipt index: {{receipt_index}}",
EmptyMethodName: "Method name is empty in contract call",
CannotReturnJointPromise: "Returning joint promise is currently prohibited",
StackHeightInstrumentation: "Stack instrumentation failed",
CodeDoesNotExist: "Cannot find contract code for account {{account_id}}",
MethodInvalidSignature: "Invalid method signature",
IntegerOverflow: "Integer overflow happened during contract execution",
MemoryAccessViolation: "MemoryAccessViolation",
InvalidIteratorIndex: "Iterator index {{iterator_index}} does not exist",
IteratorWasInvalidated: "Iterator {{iterator_index}} was invalidated after its creation by performing a mutable operation on trie",
InvalidAccountId: "VM Logic returned an invalid account id",
Serialization: "Error happened while serializing the module",
CannotAppendActionToJointPromise: "Actions can only be appended to non-joint promise.",
InternalMemoryDeclared: "Internal memory declaration has been found in the module",
Instantiate: "Error happened during instantiation",
ProhibitedInView: "{{method_name}} is not allowed in view calls",
InvalidMethodName: "VM Logic returned an invalid method name",
BadUTF8: "String encoding is bad UTF-8 sequence",
BalanceExceeded: "Exceeded the account balance",
LinkError: "Wasm contract link error: {{msg}}",
InvalidPublicKey: "VM Logic provided an invalid public key",
ActorNoPermission: "Actor {{actor_id}} doesn't have permission to account {{account_id}} to complete the action",
LackBalanceForState: "The account {{account_id}} wouldn't have enough balance to cover storage, required to have {{amount}} yoctoNEAR more",
ReceiverMismatch: "Wrong AccessKey used for transaction: transaction is sent to receiver_id={{tx_receiver}}, but is signed with function call access key that restricted to only use with receiver_id={{ak_receiver}}. Either change receiver_id in your transaction or switch to use a FullAccessKey.",
CostOverflow: "Transaction gas or balance cost is too high",
InvalidSignature: "Transaction is not signed with the given public key",
AccessKeyNotFound: `Signer "{{account_id}}" doesn't have access key with the given public_key {{public_key}}`,
NotEnoughBalance: "Sender {{signer_id}} does not have enough balance {{#formatNear}}{{balance}}{{/formatNear}} for operation costing {{#formatNear}}{{cost}}{{/formatNear}}",
NotEnoughAllowance: "Access Key {account_id}:{public_key} does not have enough balance {{#formatNear}}{{allowance}}{{/formatNear}} for transaction costing {{#formatNear}}{{cost}}{{/formatNear}}",
Expired: "Transaction has expired",
DeleteAccountStaking: "Account {{account_id}} is staking and can not be deleted",
SignerDoesNotExist: "Signer {{signer_id}} does not exist",
TriesToStake: "Account {{account_id}} tried to stake {{#formatNear}}{{stake}}{{/formatNear}}, but has staked {{#formatNear}}{{locked}}{{/formatNear}} and only has {{#formatNear}}{{balance}}{{/formatNear}}",
AddKeyAlreadyExists: "The public key {{public_key}} is already used for an existing access key",
InvalidSigner: "Invalid signer account ID {{signer_id}} according to requirements",
CreateAccountNotAllowed: "The new account_id {{account_id}} can't be created by {{predecessor_id}}",
RequiresFullAccess: "The transaction contains more then one action, but it was signed with an access key which allows transaction to apply only one specific action. To apply more then one actions TX must be signed with a full access key",
TriesToUnstake: "Account {{account_id}} is not yet staked, but tried to unstake",
InvalidNonce: "Transaction nonce {{tx_nonce}} must be larger than nonce of the used access key {{ak_nonce}}",
AccountAlreadyExists: "Can't create a new account {{account_id}}, because it already exists",
InvalidChain: "Transaction parent block hash doesn't belong to the current chain",
AccountDoesNotExist: "Can't complete the action because account {{account_id}} doesn't exist",
AccessKeyDoesNotExist: "Can't complete the action because access key {{public_key}} doesn't exist",
MethodNameMismatch: "Transaction method name {{method_name}} isn't allowed by the access key",
DeleteAccountHasRent: "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover the rent",
DeleteAccountHasEnoughBalance: "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover it's storage",
InvalidReceiver: "Invalid receiver account ID {{receiver_id}} according to requirements",
DeleteKeyDoesNotExist: "Account {{account_id}} tries to remove an access key that doesn't exist",
Timeout: "Timeout exceeded",
Closed: "Connection closed",
ShardCongested: "Shard {{shard_id}} rejected the transaction due to congestion level {{congestion_level}}, try again later",
ShardStuck: "Shard {{shard_id}} rejected the transaction because it missed {{missed_chunks}} chunks and needs to recover before accepting new transactions, try again later"
};
var ErrorMessages = error_messages_default;
var NEAR_NOMINATION_EXP = 24;
var NEAR_NOMINATION = 10n ** BigInt(NEAR_NOMINATION_EXP);
var ROUNDING_OFFSETS = [];
var BN10 = 10n;
for (let i = 0, offset = 5n; i < NEAR_NOMINATION_EXP; i++, offset = offset * BN10) {
ROUNDING_OFFSETS[i] = offset;
}
function formatNearAmount(balance, fracDigits = NEAR_NOMINATION_EXP) {
let balanceBN = BigInt(balance);
if (fracDigits !== NEAR_NOMINATION_EXP) {
const roundingExp = NEAR_NOMINATION_EXP - fracDigits - 1;
if (roundingExp > 0) {
balanceBN += ROUNDING_OFFSETS[roundingExp];
}
}
balance = balanceBN.toString();
const wholeStr = balance.substring(0, balance.length - NEAR_NOMINATION_EXP) || "0";
const fractionStr = balance.substring(balance.length - NEAR_NOMINATION_EXP).padStart(NEAR_NOMINATION_EXP, "0").substring(0, fracDigits);
return trimTrailingZeroes(`${formatWithCommas(wholeStr)}.${fractionStr}`);
}
function trimTrailingZeroes(value) {
return value.replace(/\.?0*$/, "");
}
function formatWithCommas(value) {
const pattern = /(-?\d+)(\d{3})/;
while (pattern.test(value)) {
value = value.replace(pattern, "$1,$2");
}
return value;
}
function baseEncode(value) {
if (typeof value === "string") {
const bytes = [];
for (let c = 0; c < value.length; c++) {
bytes.push(value.charCodeAt(c));
}
value = new Uint8Array(bytes);
}
return base58.encode(value);
}
function baseDecode(value) {
return base58.decode(value);
}
var rpc_error_schema_default = {
schema: {
AccessKeyNotFound: {
name: "AccessKeyNotFound",
subtypes: [],
props: {
account_id: "",
public_key: ""
}
},
AccountAlreadyExists: {
name: "AccountAlreadyExists",
subtypes: [],
props: {
account_id: ""
}
},
AccountDoesNotExist: {
name: "AccountDoesNotExist",
subtypes: [],
props: {
account_id: ""
}
},
ActionError: {
name: "ActionError",
subtypes: [
"AccountAlreadyExists",
"AccountDoesNotExist",
"CreateAccountOnlyByRegistrar",
"CreateAccountNotAllowed",
"ActorNoPermission",
"DeleteKeyDoesNotExist",
"AddKeyAlreadyExists",
"DeleteAccountStaking",
"LackBalanceForState",
"TriesToUnstake",
"TriesToStake",
"InsufficientStake",
"FunctionCallError",
"NewReceiptValidationError",
"OnlyImplicitAccountCreationAllowed",
"DeleteAccountWithLargeState",
"DelegateActionInvalidSignature",
"DelegateActionSenderDoesNotMatchTxReceiver",
"DelegateActionExpired",
"DelegateActionAccessKeyError",
"DelegateActionInvalidNonce",
"DelegateActionNonceTooLarge"
],
props: {
index: ""
}
},
ActionsValidationError: {
name: "ActionsValidationError",
subtypes: [
"DeleteActionMustBeFinal",
"TotalPrepaidGasExceeded",
"TotalNumberOfActionsExceeded",
"AddKeyMethodNamesNumberOfBytesExceeded",
"AddKeyMethodNameLengthExceeded",
"IntegerOverflow",
"InvalidAccountId",
"ContractSizeExceeded",
"FunctionCallMethodNameLengthExceeded",
"FunctionCallArgumentsLengthExceeded",
"UnsuitableStakingKey",
"FunctionCallZeroAttachedGas",
"DelegateActionMustBeOnlyOne",
"UnsupportedProtocolFeature"
],
props: {}
},
ActorNoPermission: {
name: "ActorNoPermission",
subtypes: [],
props: {
account_id: "",
actor_id: ""
}
},
AddKeyAlreadyExists: {
name: "AddKeyAlreadyExists",
subtypes: [],
props: {
account_id: "",
public_key: ""
}
},
AddKeyMethodNameLengthExceeded: {
name: "AddKeyMethodNameLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
AddKeyMethodNamesNumberOfBytesExceeded: {
name: "AddKeyMethodNamesNumberOfBytesExceeded",
subtypes: [],
props: {
limit: "",
total_number_of_bytes: ""
}
},
AltBn128InvalidInput: {
name: "AltBn128InvalidInput",
subtypes: [],
props: {
msg: ""
}
},
BadUTF16: {
name: "BadUTF16",
subtypes: [],
props: {}
},
BadUTF8: {
name: "BadUTF8",
subtypes: [],
props: {}
},
BalanceExceeded: {
name: "BalanceExceeded",
subtypes: [],
props: {}
},
BalanceMismatchError: {
name: "BalanceMismatchError",
subtypes: [],
props: {
final_accounts_balance: "",
final_postponed_receipts_balance: "",
forwarded_buffered_receipts_balance: "",
incoming_receipts_balance: "",
incoming_validator_rewards: "",
initial_accounts_balance: "",
initial_postponed_receipts_balance: "",
new_buffered_receipts_balance: "",
new_delayed_receipts_balance: "",
other_burnt_amount: "",
outgoing_receipts_balance: "",
processed_delayed_receipts_balance: "",
slashed_burnt_amount: "",
tx_burnt_amount: ""
}
},
CallIndirectOOB: {
name: "CallIndirectOOB",
subtypes: [],
props: {}
},
CannotAppendActionToJointPromise: {
name: "CannotAppendActionToJointPromise",
subtypes: [],
props: {}
},
CannotReturnJointPromise: {
name: "CannotReturnJointPromise",
subtypes: [],
props: {}
},
CodeDoesNotExist: {
name: "CodeDoesNotExist",
subtypes: [],
props: {
account_id: ""
}
},
CompilationError: {
name: "CompilationError",
subtypes: [
"CodeDoesNotExist",
"PrepareError",
"WasmerCompileError"
],
props: {}
},
ContractSizeExceeded: {
name: "ContractSizeExceeded",
subtypes: [],
props: {
limit: "",
size: ""
}
},
CostOverflow: {
name: "CostOverflow",
subtypes: [],
props: {}
},
CreateAccountNotAllowed: {
name: "CreateAccountNotAllowed",
subtypes: [],
props: {
account_id: "",
predecessor_id: ""
}
},
CreateAccountOnlyByRegistrar: {
name: "CreateAccountOnlyByRegistrar",
subtypes: [],
props: {
account_id: "",
predecessor_id: "",
registrar_account_id: ""
}
},
DelegateActionExpired: {
name: "DelegateActionExpired",
subtypes: [],
props: {}
},
DelegateActionInvalidNonce: {
name: "DelegateActionInvalidNonce",
subtypes: [],
props: {
ak_nonce: "",
delegate_nonce: ""
}
},
DelegateActionInvalidSignature: {
name: "DelegateActionInvalidSignature",
subtypes: [],
props: {}
},
DelegateActionMustBeOnlyOne: {
name: "DelegateActionMustBeOnlyOne",
subtypes: [],
props: {}
},
DelegateActionNonceTooLarge: {
name: "DelegateActionNonceTooLarge",
subtypes: [],
props: {
delegate_nonce: "",
upper_bound: ""
}
},
DelegateActionSenderDoesNotMatchTxReceiver: {
name: "DelegateActionSenderDoesNotMatchTxReceiver",
subtypes: [],
props: {
receiver_id: "",
sender_id: ""
}
},
DeleteAccountStaking: {
name: "DeleteAccountStaking",
subtypes: [],
props: {
account_id: ""
}
},
DeleteAccountWithLargeState: {
name: "DeleteAccountWithLargeState",
subtypes: [],
props: {
account_id: ""
}
},
DeleteActionMustBeFinal: {
name: "DeleteActionMustBeFinal",
subtypes: [],
props: {}
},
DeleteKeyDoesNotExist: {
name: "DeleteKeyDoesNotExist",
subtypes: [],
props: {
account_id: "",
public_key: ""
}
},
DepositWithFunctionCall: {
name: "DepositWithFunctionCall",
subtypes: [],
props: {}
},
Deprecated: {
name: "Deprecated",
subtypes: [],
props: {
method_name: ""
}
},
Deserialization: {
name: "Deserialization",
subtypes: [],
props: {}
},
ECRecoverError: {
name: "ECRecoverError",
subtypes: [],
props: {
msg: ""
}
},
Ed25519VerifyInvalidInput: {
name: "Ed25519VerifyInvalidInput",
subtypes: [],
props: {
msg: ""
}
},
EmptyMethodName: {
name: "EmptyMethodName",
subtypes: [],
props: {}
},
Expired: {
name: "Expired",
subtypes: [],
props: {}
},
FunctionCallArgumentsLengthExceeded: {
name: "FunctionCallArgumentsLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
FunctionCallMethodNameLengthExceeded: {
name: "FunctionCallMethodNameLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
FunctionCallZeroAttachedGas: {
name: "FunctionCallZeroAttachedGas",
subtypes: [],
props: {}
},
GasExceeded: {
name: "GasExceeded",
subtypes: [],
props: {}
},
GasInstrumentation: {
name: "GasInstrumentation",
subtypes: [],
props: {}
},
GasLimitExceeded: {
name: "GasLimitExceeded",
subtypes: [],
props: {}
},
GenericTrap: {
name: "GenericTrap",
subtypes: [],
props: {}
},
GuestPanic: {
name: "GuestPanic",
subtypes: [],
props: {
panic_msg: ""
}
},
HostError: {
name: "HostError",
subtypes: [
"BadUTF16",
"BadUTF8",
"GasExceeded",
"GasLimitExceeded",
"BalanceExceeded",
"EmptyMethodName",
"GuestPanic",
"IntegerOverflow",
"InvalidPromiseIndex",
"CannotAppendActionToJointPromise",
"CannotReturnJointPromise",
"InvalidPromiseResultIndex",
"InvalidRegisterId",
"IteratorWasInvalidated",
"MemoryAccessViolation",
"InvalidReceiptIndex",
"InvalidIteratorIndex",
"InvalidAccountId",
"InvalidMethodName",
"InvalidPublicKey",
"ProhibitedInView",
"NumberOfLogsExceeded",
"KeyLengthExceeded",
"ValueLengthExceeded",
"TotalLogLengthExceeded",
"NumberPromisesExceeded",
"NumberInputDataDependenciesExceeded",
"ReturnedValueLengthExceeded",
"ContractSizeExceeded",
"Deprecated",
"ECRecoverError",
"AltBn128InvalidInput",
"Ed25519VerifyInvalidInput"
],
props: {}
},
IllegalArithmetic: {
name: "IllegalArithmetic",
subtypes: [],
props: {}
},
IncorrectCallIndirectSignature: {
name: "IncorrectCallIndirectSignature",
subtypes: [],
props: {}
},
IndirectCallToNull: {
name: "IndirectCallToNull",
subtypes: [],
props: {}
},
Instantiate: {
name: "Instantiate",
subtypes: [],
props: {}
},
InsufficientStake: {
name: "InsufficientStake",
subtypes: [],
props: {
account_id: "",
minimum_stake: "",
stake: ""
}
},
IntegerOverflow: {
name: "IntegerOverflow",
subtypes: [],
props: {}
},
InternalMemoryDeclared: {
name: "InternalMemoryDeclared",
subtypes: [],
props: {}
},
InvalidAccessKeyError: {
name: "InvalidAccessKeyError",
subtypes: [
"AccessKeyNotFound",
"ReceiverMismatch",
"MethodNameMismatch",
"RequiresFullAccess",
"NotEnoughAllowance",
"DepositWithFunctionCall"
],
props: {}
},
InvalidAccountId: {
name: "InvalidAccountId",
subtypes: [],
props: {}
},
InvalidChain: {
name: "InvalidChain",
subtypes: [],
props: {}
},
InvalidDataReceiverId: {
name: "InvalidDataReceiverId",
subtypes: [],
props: {
account_id: ""
}
},
InvalidIteratorIndex: {
name: "InvalidIteratorIndex",
subtypes: [],
props: {
iterator_index: ""
}
},
InvalidMethodName: {
name: "InvalidMethodName",
subtypes: [],
props: {}
},
InvalidNonce: {
name: "InvalidNonce",
subtypes: [],
props: {
ak_nonce: "",
tx_nonce: ""
}
},
InvalidPredecessorId: {
name: "InvalidPredecessorId",
subtypes: [],
props: {
account_id: ""
}
},
InvalidPromiseIndex: {
name: "InvalidPromiseIndex",
subtypes: [],
props: {
promise_idx: ""
}
},
InvalidPromiseResultIndex: {
name: "InvalidPromiseResultIndex",
subtypes: [],
props: {
result_idx: ""
}
},
InvalidPublicKey: {
name: "InvalidPublicKey",
subtypes: [],
props: {}
},
InvalidReceiptIndex: {
name: "InvalidReceiptIndex",
subtypes: [],
props: {
receipt_index: ""
}
},
InvalidReceiverId: {
name: "InvalidReceiverId",
subtypes: [],
props: {
account_id: ""
}
},
InvalidRegisterId: {
name: "InvalidRegisterId",
subtypes: [],
props: {
register_id: ""
}
},
InvalidSignature: {
name: "InvalidSignature",
subtypes: [],
props: {}
},
InvalidSignerId: {
name: "InvalidSignerId",
subtypes: [],
props: {
account_id: ""
}
},
InvalidTxError: {
name: "InvalidTxError",
subtypes: [
"InvalidAccessKeyError",
"InvalidSignerId",
"SignerDoesNotExist",
"InvalidNonce",
"NonceTooLarge",
"InvalidReceiverId",
"InvalidSignature",
"NotEnoughBalance",
"LackBalanceForState",
"CostOverflow",
"InvalidChain",
"Expired",
"ActionsValidation",
"TransactionSizeExceeded",
"StorageError",
"ShardCongested",
"ShardStuck"
],
props: {}
},
IteratorWasInvalidated: {
name: "IteratorWasInvalidated",
subtypes: [],
props: {
iterator_index: ""
}
},
KeyLengthExceeded: {
name: "KeyLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
LackBalanceForState: {
name: "LackBalanceForState",
subtypes: [],
props: {
account_id: "",
amount: ""
}
},
Memory: {
name: "Memory",
subtypes: [],
props: {}
},
MemoryAccessViolation: {
name: "MemoryAccessViolation",
subtypes: [],
props: {}
},
MemoryOutOfBounds: {
name: "MemoryOutOfBounds",
subtypes: [],
props: {}
},
MethodEmptyName: {
name: "MethodEmptyName",
subtypes: [],
props: {}
},
MethodInvalidSignature: {
name: "MethodInvalidSignature",
subtypes: [],
props: {}
},
MethodNameMismatch: {
name: "MethodNameMismatch",
subtypes: [],
props: {
method_name: ""
}
},
MethodNotFound: {
name: "MethodNotFound",
subtypes: [],
props: {}
},
MethodResolveError: {
name: "MethodResolveError",
subtypes: [
"MethodEmptyName",
"MethodNotFound",
"MethodInvalidSignature"
],
props: {}
},
MisalignedAtomicAccess: {
name: "MisalignedAtomicAccess",
subtypes: [],
props: {}
},
NonceTooLarge: {
name: "NonceTooLarge",
subtypes: [],
props: {
tx_nonce: "",
upper_bound: ""
}
},
NotEnoughAllowance: {
name: "NotEnoughAllowance",
subtypes: [],
props: {
account_id: "",
allowance: "",
cost: "",
public_key: ""
}
},
NotEnoughBalance: {
name: "NotEnoughBalance",
subtypes: [],
props: {
balance: "",
cost: "",
signer_id: ""
}
},
NumberInputDataDependenciesExceeded: {
name: "NumberInputDataDependenciesExceeded",
subtypes: [],
props: {
limit: "",
number_of_input_data_dependencies: ""
}
},
NumberOfLogsExceeded: {
name: "NumberOfLogsExceeded",
subtypes: [],
props: {
limit: ""
}
},
NumberPromisesExceeded: {
name: "NumberPromisesExceeded",
subtypes: [],
props: {
limit: "",
number_of_promises: ""
}
},
OnlyImplicitAccountCreationAllowed: {
name: "OnlyImplicitAccountCreationAllowed",
subtypes: [],
props: {
account_id: ""
}
},
PrepareError: {
name: "PrepareError",
subtypes: [
"Serialization",
"Deserialization",
"InternalMemoryDeclared",
"GasInstrumentation",
"StackHeightInstrumentation",
"Instantiate",
"Memory",
"TooManyFunctions",
"TooManyLocals"
],
props: {}
},
ProhibitedInView: {
name: "ProhibitedInView",
subtypes: [],
props: {
method_name: ""
}
},
ReceiptSizeExceeded: {
name: "ReceiptSizeExceeded",
subtypes: [],
props: {
limit: "",
size: ""
}
},
ReceiptValidationError: {
name: "ReceiptValidationError",
subtypes: [
"InvalidPredecessorId",
"InvalidReceiverId",
"InvalidSignerId",
"InvalidDataReceiverId",
"ReturnedValueLengthExceeded",
"NumberInputDataDependenciesExceeded",
"ActionsValidation",
"ReceiptSizeExceeded"
],
props: {}
},
ReceiverMismatch: {
name: "ReceiverMismatch",
subtypes: [],
props: {
ak_receiver: "",
tx_receiver: ""
}
},
RequiresFullAccess: {
name: "RequiresFullAccess",
subtypes: [],
props: {}
},
ReturnedValueLengthExceeded: {
name: "ReturnedValueLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
Serialization: {
name: "Serialization",
subtypes: [],
props: {}
},
ShardCongested: {
name: "ShardCongested",
subtypes: [],
props: {
congestion_level: "",
shard_id: ""
}
},
ShardStuck: {
name: "ShardStuck",
subtypes: [],
props: {
missed_chunks: "",
shard_id: ""
}
},
SignerDoesNotExist: {
name: "SignerDoesNotExist",
subtypes: [],
props: {
signer_id: ""
}
},
StackHeightInstrumentation: {
name: "StackHeightInstrumentation",
subtypes: [],
props: {}
},
StackOverflow: {
name: "StackOverflow",
subtypes: [],
props: {}
},
TooManyFunctions: {
name: "TooManyFunctions",
subtypes: [],
props: {}
},
TooManyLocals: {
name: "TooManyLocals",
subtypes: [],
props: {}
},
TotalLogLengthExceeded: {
name: "TotalLogLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
TotalNumberOfActionsExceeded: {
name: "TotalNumberOfActionsExceeded",
subtypes: [],
props: {
limit: "",
total_number_of_actions: ""
}
},
TotalPrepaidGasExceeded: {
name: "TotalPrepaidGasExceeded",
subtypes: [],
props: {
limit: "",
total_prepaid_gas: ""
}
},
TransactionSizeExceeded: {
name: "TransactionSizeExceeded",
subtypes: [],
props: {
limit: "",
size: ""
}
},
TriesToStake: {
name: "TriesToStake",
subtypes: [],
props: {
account_id: "",
balance: "",
locked: "",
stake: ""
}
},
TriesToUnstake: {
name: "TriesToUnstake",
subtypes: [],
props: {
account_id: ""
}
},
TxExecutionError: {
name: "TxExecutionError",
subtypes: [
"ActionError",
"InvalidTxError"
],
props: {}
},
Unreachable: {
name: "Unreachable",
subtypes: [],
props: {}
},
UnsuitableStakingKey: {
name: "UnsuitableStakingKey",
subtypes: [],
props: {
public_key: ""
}
},
UnsupportedProtocolFeature: {
name: "UnsupportedProtocolFeature",
subtypes: [],
props: {
protocol_feature: "",
version: ""
}
},
ValueLengthExceeded: {
name: "ValueLengthExceeded",
subtypes: [],
props: {
length: "",
limit: ""
}
},
WasmTrap: {
name: "WasmTrap",
subtypes: [
"Unreachable",
"IncorrectCallIndirectSignature",
"MemoryOutOfBounds",
"CallIndirectOOB",
"IllegalArithmetic",
"MisalignedAtomicAccess",
"IndirectCallToNull",
"StackOverflow",
"GenericTrap"
],
props: {}
},
WasmerCompileError: {
name: "WasmerCompileError",
subtypes: [],
props: {
msg: ""
}
},
Closed: {
name: "Closed",
subtypes: [],
props: {}
},
ServerError: {
name: "ServerError",
subtypes: [
"TxExecutionError",
"Timeout",
"Closed"
],
props: {}
},
Timeout: {
name: "Timeout",
subtypes: [],
props: {}
}
}
};
var mustacheHelpers = {
formatNear: () => (n, render) => formatNearAmount(render(n))
};
var ServerError = class extends TypedError {
};
var ServerTransactionError = class extends ServerError {
constructor() {
super(...arguments);
__publicField(this, "transaction_outcome");
}
};
function parseRpcError(errorObj) {
const result = {};
const errorClassName = walkSubtype(errorObj, rpc_error_schema_default.schema, result, "");
const error = new ServerError(formatError(errorClassName, result), errorClassName);
Object.assign(error, result);
return error;
}
function parseResultError(result) {
const server_error = parseRpcError(result.status.Failure);
const server_tx_error = new ServerTransactionError();
Object.assign(server_tx_error, server_error);
server_tx_error.type = server_error.type;
server_tx_error.message = server_error.message;
server_tx_error.transaction_outcome = result.transaction_outcome;
return server_tx_error;
}
function formatError(errorClassName, errorData) {
if (typeof ErrorMessages[errorClassName] === "string") {
return import_mustache.default.render(ErrorMessages[errorClassName], {
...errorData,
...mustacheHelpers
});
}
return JSON.stringify(errorData);
}
function walkSubtype(errorObj, schema, result, typeName) {
let error;
let type;
let errorTypeName;
for (const errorName in schema) {
if (isString(errorObj[errorName])) {
return errorObj[errorName];
}
if (isObject(errorObj[errorName])) {
error = errorObj[errorName];
type = schema[errorName];
errorTypeName = errorName;
} else if (isObject(errorObj.kind) && isObject(errorObj.kind[errorName])) {
error = errorObj.kind[errorName];
type = schema[errorName];
errorTypeName = errorName;
} else {
continue;
}
}
if (error && type) {
for (const prop of Object.keys(type.props)) {
result[prop] = error[prop];
}
return walkSubtype(error, schema, result, errorTypeName);
} else {
result.kind = errorObj;
return typeName;
}
}
function getErrorTypeFromErrorMessage(errorMessage, errorType) {
switch (true) {
case /^account .*? does not exist while viewing$/.test(errorMessage):
return "AccountDoesNotExist";
case /^Account .*? doesn't exist$/.test(errorMessage):
return "AccountDoesNotExist";
case /^access key .*? does not exist while viewing$/.test(errorMessage):
return "AccessKeyDoesNotExist";
case /wasm execution failed with error: FunctionCallError\(CompilationError\(CodeDoesNotExist/.test(errorMessage):
return "CodeDoesNotExist";
case /wasm execution failed with error: CompilationError\(CodeDoesNotExist/.test(errorMessage):
return "CodeDoesNotExist";
case /wasm execution failed with error: FunctionCallError\(MethodResolveError\(MethodNotFound/.test(errorMessage):
return "MethodNotFound";
case /wasm execution failed with error: MethodResolveError\(MethodNotFound/.test(errorMessage):
return "MethodNotFound";
case /Transaction nonce \d+ must be larger than nonce of the used access key \d+/.test(errorMessage):
return "InvalidNonce";
default:
return errorType;
}
}
function isObject(n) {
return Object.prototype.toString.call(n) === "[object Object]";
}
function isString(n) {
return Object.prototype.toString.call(n) === "[object String]";
}
var ConsoleLogger = class {
constructor(logLevels) {
__publicField(this, "isLevelEnabled", (level) => {
return this.logLevels.includes(level);
});
this.logLevels = logLevels;
}
print(level, message, ...optionalParams) {
switch (level) {
case "error":
case "fatal":
return console.error(message, ...optionalParams);
case "warn":
return console.warn(message, ...optionalParams);
case "log":
return console.log(message, ...optionalParams);
case "debug":
case "verbose":
return console.debug(message, ...optionalParams);
}
}
verbose(message, ...optionalParams) {
if (!this.isLevelEnabled("verbose")) return;
this.print("verbose", message, ...optionalParams);
}
debug(message, ...optionalParams) {
if (!this.isLevelEnabled("debug")) return;
this.print("debug", message, ...optionalParams);
}
log(message, ...optionalParams) {
if (!this.isLevelEnabled("log")) return;
this.print("log", message, ...optionalParams);
}
warn(message, ...optionalParams) {
if (!this.isLevelEnabled("warn")) return;
this.print("warn", message, ...optionalParams);
}
error(message, ...optionalParams) {
if (!this.isLevelEnabled("error")) return;
this.print("error", message, ...optionalParams);
}
fatal(message, ...optionalParams) {
if (!this.isLevelEnabled("fatal")) return;
this.print("fatal", message, ...optionalParams);
}
};
var DEFAULT_LOG_LEVELS = [
"verbose",
"debug",
"log",
"warn",
"error",
"fatal"
];
var DEFAULT_LOGGER = new ConsoleLogger(DEFAULT_LOG_LEVELS);
var _a;
var Logger = (_a = class {
static error(message, ...optionalParams) {
this.instanceRef?.error(message, ...optionalParams);
}
/**
* Write a 'log' level log.
*/
static log(message, ...optionalParams) {
this.instanceRef?.log(message, ...optionalParams);
}
/**
* Write a 'warn' level log.
*/
static warn(message, ...optionalParams) {
this.instanceRef?.warn(message, ...optionalParams);
}
/**
* Write a 'debug' level log.
*/
static debug(message, ...optionalParams) {
this.instanceRef?.debug?.(message, ...optionalParams);
}
/**
* Write a 'verbose' level log.
*/
static verbose(message, ...optionalParams) {
this.instanceRef?.verbose?.(message, ...optionalParams);
}
static fatal(message, ...optionalParams) {
this.instanceRef?.fatal?.(message, ...optionalParams);
}
}, __publicField(_a, "instanceRef", DEFAULT_LOGGER), __publicField(_a, "overrideLogger", (logger) => {
_a.instanceRef = logger;
}), _a);
function printTxOutcomeLogsAndFailures({
contractId: contractId2,
outcome
}) {
const flatLogs = [outcome.transaction_outcome, ...outcome.receipts_outcome].reduce((acc, it) => {
const isFailure = typeof it.outcome.status === "object" && typeof it.outcome.status.Failure === "object";
if (it.outcome.logs.length || isFailure) {
return acc.concat({
receiptIds: it.outcome.receipt_ids,
logs: it.outcome.logs,
failure: typeof it.outcome.status === "object" && it.outcome.status.Failure !== void 0 ? parseRpcError(it.outcome.status.Failure) : null
});
} else {
return acc;
}
}, []);
for (const result of flatLogs) {
Logger.log(`Receipt${result.receiptIds.length > 1 ? "s" : ""}: ${result.receiptIds.join(", ")}`);
printTxOutcomeLogs({
contractId: contractId2,
logs: result.logs,
prefix: " "
});
if (result.failure) {
Logger.warn(` Failure [${contractId2}]: ${result.failure}`);
}
}
}
function printTxOutcomeLogs({
contractId: contractId2,
logs,
prefix = ""
}) {
for (const log of logs) {
Logger.log(`${prefix}Log [${contractId2}]: ${log}`);
}
}
function getTransactionLastResult(txResult) {
if (typeof txResult.status === "object" && typeof txResult.status.SuccessValue === "string") {
const value = Buffer.from(txResult.status.SuccessValue, "base64").toString();
try {
return JSON.parse(value);
} catch (e) {
return value;
}
}
return null;
}
function sortBigIntAsc(a, b) {
return a < b ? -1 : a > b ? 1 : 0;
}
function findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio, protocolVersion) {
if (protocolVersion && protocolVersion < 49) {
return findSeatPriceForProtocolBefore49(validators, maxNumberOfSeats);
}
if (!minimumStakeRatio) {
const deprecate = (0, import_depd.default)("findSeatPrice(validators, maxNumberOfSeats)");
deprecate("`use `findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio)` instead");
minimumStakeRatio = [1, 6250];
}
return findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumStakeRatio);
}
function findSeatPriceForProtocolBefore49(validators, numSeats) {
const stakes = validators.map((v) => BigInt(v.stake)).sort(sortBigIntAsc);
const num = BigInt(numSeats);
const stakesSum = stakes.reduce((a, b) => a + b);
if (stakesSum < num) {
throw new Error("Stakes are below seats");
}
let left = 1n, right = stakesSum + 1n;
while (left !== right - 1n) {
const mid = (left + right) / 2n;
let found = false;
let currentSum = 0n;
for (let i = 0; i < stakes.length; ++i) {
currentSum = currentSum + stakes[i] / mid;
if (currentSum >= num) {
left = mid;
found = true;
break;
}
}
if (!found) {
right = mid;
}
}
return left;
}
function findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumStakeRatio) {
if (minimumStakeRatio.length != 2) {
throw Error("minimumStakeRatio should have 2 elements");
}
const stakes = validators.map((v) => BigInt(v.stake)).sort(sortBigIntAsc);
const stakesSum = stakes.reduce((a, b) => a + b);
if (validators.length < maxNumberOfSeats) {
return stakesSum * BigInt(minimumStakeRatio[0]) / BigInt(minimumStakeRatio[1]);
} else {
return stakes[0] + 1n;
}
}
// node_modules/@near-js/transactions/lib/esm/actions.js
var FunctionCallPermission = class {
constructor({ allowance, receiverId, methodNames }) {
__publicField(this, "allowance");
__publicField(this, "receiverId");
__publicField(this, "methodNames");
this.allowance = allowance;
this.receiverId = receiverId;
this.methodNames = methodNames;
}
};
var FullAccessPermission = class {
};
var AccessKeyPermission = class extends Enum {
constructor(props) {
super(props);
__publicField(this, "enum");
__publicField(this, "functionCall");
__publicField(this, "fullAccess");
for (const [k, v] of Object.entries(props || {})) {
this[k] = v;
this.enum = k;
}
}
};
var AccessKey = class {
constructor({ nonce, permission }) {
__publicField(this, "nonce");
__publicField(this, "permission");
this.nonce = nonce;
this.permission = permission;
}
};
var CreateAccount = class {
};
var DeployContract = class {
constructor({ code }) {
__publicField(this, "code");
this.code = code;
}
};
var FunctionCall = class {
constructor({ methodName, args, gas, deposit }) {
__publicField(this, "methodName");
__publicField(this, "args");
__publicField(this, "gas");
__publicField(this, "deposit");
this.methodName = methodName;
this.args = args;
this.gas = gas;
this.deposit = deposit;
}
};
var GlobalContractDeployMode = class extends Enum {
constructor(props) {
super(props);
__publicField(this, "enum");
__publicField(this, "CodeHash");
__publicField(this, "AccountId");
for (const [k, v] of Object.entries(props || {})) {
this[k] = v;
this.enum = k;
}
}
};
var GlobalContractIdentifier = class extends Enum {
constructor(props) {
super(props);
__publicField(this, "enum");
__publicField(this, "CodeHash");
__publicField(this, "AccountId");
for (const [k, v] of Object.entries(props || {})) {
this[k] = v;
this.enum = k;
}
}
};
var DeployGlobalContract = class {
constructor({ code, deployMode }) {
__publicField(this, "code");
__publicField(this, "deployMode");
this.code = code;
this.deployMode = deployMode;
}
};
var UseGlobalContract = class {
constructor({ contractIdentifier }) {
__publicField(this, "contractIdentifier");
this.contractIdentifier = contractIdentifier;
}
};
var Transfer = class {
constructor({ deposit }) {
__publicField(this, "deposit");
this.deposit = deposit;
}
};
var Stake = class {
constructor({ stake: stake3, publicKey }) {
__publicField(this, "stake");
__publicField(this, "publicKey");
this.stake = stake3;
this.publicKey = publicKey;
}
};
var AddKey = class {
constructor({ publicKey, accessKey }) {
__publicField(this, "publicKey");
__publicField(this, "accessKey");
this.publicKey = publicKey;
this.accessKey = accessKey;
}
};
var DeleteKey = class {
constructor({ publicKey }) {
__publicField(this, "publicKey");
this.publicKey = publicKey;
}
};
var DeleteAccount = class {
constructor({ beneficiaryId }) {
__publicField(this, "beneficiaryId");
this.beneficiaryId = beneficiaryId;
}
};
var SignedDelegate = class {
constructor({ delegateAction, signature }) {
__publicField(this, "delegateAction");
__publicField(this, "signature");
this.delegateAction = delegateAction;
this.signature = signature;
}
};
var Action = class extends Enum {
constructor(props) {
super(props);
__publicField(this, "enum");
__publicField(this, "createAccount");
__publicField(this, "deployContract");
__publicField(this, "functionCall");
__publicField(this, "transfer");
__publicField(this, "stake");
__publicField(this, "addKey");
__publicField(this, "deleteKey");
__publicField(this, "deleteAccount");
__publicField(this, "signedDelegate");
__publicField(this, "deployGlobalContract");
__publicField(this, "useGlobalContract");
for (const [k, v] of Object.entries(props || {})) {
this[k] = v;
this.enum = k;
}
}
};
// node_modules/@near-js/transactions/lib/esm/action_creators.js
function fullAccessKey() {
return new AccessKey({
nonce: 0n,
permission: new AccessKeyPermission({
fullAccess: new FullAccessPermission()
})
});
}
function functionCallAccessKey(receiverId, methodNames, allowance) {
return new AccessKey({
nonce: 0n,
permission: new AccessKeyPermission({
functionCall: new FunctionCallPermission({
receiverId,
allowance,
methodNames
})
})
});
}
function createAccount() {
return new Action({ createAccount: new CreateAccount() });
}
function deployContract(code) {
return new Action({ deployContract: new DeployContract({ code }) });
}
function stringifyJsonOrBytes(args) {
const isUint8Array = args.byteLength !== void 0 && args.byteLength === args.length;
return isUint8Array ? args : Buffer.from(JSON.stringify(args));
}
function functionCall(methodName, args, gas = 0n, deposit = 0n, stringify = stringifyJsonOrBytes) {
return new Action({
functionCall: new FunctionCall({
methodName,
args: stringify(args),
gas,
deposit
})
});
}
function transfer(deposit = 0n) {
return new Action({ transfer: new Transfer({ deposit }) });
}
function stake(stake22 = 0n, publicKey) {
return new Action({ stake: new Stake({ stake: stake22, publicKey }) });
}
function addKey(publicKey, accessKey) {
return new Action({ addKey: new AddKey({ publicKey, accessKey }) });
}
function deleteKey(publicKey) {
return new Action({ deleteKey: new DeleteKey({ publicKey }) });
}
function deleteAccount(beneficiaryId) {
return new Action({ deleteAccount: new DeleteAccount({ beneficiaryId }) });
}
function signedDelegate({
delegateAction,
signature
}) {
return new Action({
signedDelegate: new SignedDelegate({ delegateAction, signature })
});
}
function deployGlobalContract(code, deployMode) {
return new Action({ deployGlobalContract: new DeployGlobalContract({ code, deployMode }) });
}
function useGlobalContract(contractIdentifier) {
return new Action({ useGlobalContract: new UseGlobalContract({ contractIdentifier }) });
}
var actionCreators = {
addKey,
createAccount,
deleteAccount,
deleteKey,
deployContract,
fullAccessKey,
functionCall,
functionCallAccessKey,
signedDelegate,
stake,
transfer,
deployGlobalContract,
useGlobalContract
};
// node_modules/borsh/lib/esm/types.js
var integers = ["u8", "u16", "u32", "u64", "u128", "i8", "i16", "i32", "i64", "i128", "f32", "f64"];
// node_modules/borsh/lib/esm/buffer.js
var EncodeBuffer = (
/** @class */
function() {
function EncodeBuffer2() {
this.offset = 0;
this.buffer_size = 256;
this.buffer = new ArrayBuffer(this.buffer_size);
this.view = new DataView(this.buffer);
}
EncodeBuffer2.prototype.resize_if_necessary = function(needed_space) {
if (this.buffer_size - this.offset < needed_space) {
this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);
var new_buffer = new ArrayBuffer(this.buffer_size);
new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));
this.buffer = new_buffer;
this.view = new DataView(new_buffer);
}
};
EncodeBuffer2.prototype.get_used_buffer = function() {
return new Uint8Array(this.buffer).slice(0, this.offset);
};
EncodeBuffer2.prototype.store_value = function(value, type) {
var bSize = type.substring(1);
var size = parseInt(bSize) / 8;
this.resize_if_necessary(size);
var toCall = type[0] === "f" ? "setFloat".concat(bSize) : type[0] === "i" ? "setInt".concat(bSize) : "setUint".concat(bSize);
this.view[toCall](this.offset, value, true);
this.offset += size;
};
EncodeBuffer2.prototype.store_bytes = function(from) {
this.resize_if_necessary(from.length);
new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);
this.offset += from.length;
};
return EncodeBuffer2;
}()
);
var DecodeBuffer = (
/** @class */
function() {
function DecodeBuffer2(buf) {
this.offset = 0;
this.buffer_size = buf.length;
this.buffer = new ArrayBuffer(buf.length);
new Uint8Array(this.buffer).set(buf);
this.view = new DataView(this.buffer);
}
DecodeBuffer2.prototype.assert_enough_buffer = function(size) {
if (this.offset + size > this.buffer.byteLength) {
throw new Error("Error in schema, the buffer is smaller than expected");
}
};
DecodeBuffer2.prototype.consume_value = function(type) {
var bSize = type.substring(1);
var size = parseInt(bSize) / 8;
this.assert_enough_buffer(size);
var toCall = type[0] === "f" ? "getFloat".concat(bSize) : type[0] === "i" ? "getInt".concat(bSize) : "getUint".concat(bSize);
var ret = this.view[toCall](this.offset, true);
this.offset += size;
return ret;
};
DecodeBuffer2.prototype.consume_bytes = function(size) {
this.assert_enough_buffer(size);
var ret = this.buffer.slice(this.offset, this.offset + size);
this.offset += size;
return ret;
};
return DecodeBuffer2;
}()
);
// node_modules/borsh/lib/esm/utils.js
var __extends = /* @__PURE__ */ function() {
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
return function(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
function isArrayLike(value) {
return Array.isArray(value) || !!value && typeof value === "object" && "length" in value && typeof value.length === "number" && (value.length === 0 || value.length > 0 && value.length - 1 in value);
}
function expect_type(value, type, fieldPath) {
if (typeof value !== type) {
throw new Error("Expected ".concat(type, " not ").concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
}
}
function expect_bigint(value, fieldPath) {
var basicType = ["number", "string", "bigint", "boolean"].includes(typeof value);
var strObject = typeof value === "object" && value !== null && "toString" in value;
if (!basicType && !strObject) {
throw new Error("Expected bigint, number, boolean or string not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
}
}
function expect_same_size(length, expected, fieldPath) {
if (length !== expected) {
throw new Error("Array length ".concat(length, " does not match schema length ").concat(expected, " at ").concat(fieldPath.join(".")));
}
}
function expect_enum(value, fieldPath) {
if (typeof value !== "object" || value === null) {
throw new Error("Expected object not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
}
}
var VALID_STRING_TYPES = integers.concat(["bool", "string"]);
var VALID_OBJECT_KEYS = ["option", "enum", "array", "set", "map", "struct"];
var ErrorSchema = (
/** @class */
function(_super) {
__extends(ErrorSchema2, _super);
function ErrorSchema2(schema, expected) {
var message = "Invalid schema: ".concat(JSON.stringify(schema), " expected ").concat(expected);
return _super.call(this, message) || this;
}
return ErrorSchema2;
}(Error)
);
function validate_schema(schema) {
if (typeof schema === "string" && VALID_STRING_TYPES.includes(schema)) {
return;
}
if (schema && typeof schema === "object") {
var keys = Object.keys(schema);
if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {
var key = keys[0];
if (key === "option")
return validate_schema(schema[key]);
if (key === "enum")
return validate_enum_schema(schema[key]);
if (key === "array")
return validate_array_schema(schema[key]);
if (key === "set")
return validate_schema(schema[key]);
if (key === "map")
return validate_map_schema(schema[key]);
if (key === "struct")
return validate_struct_schema(schema[key]);
}
}
throw new ErrorSchema(schema, VALID_OBJECT_KEYS.join(", ") + " or " + VALID_STRING_TYPES.join(", "));
}
function validate_enum_schema(schema) {
if (!Array.isArray(schema))
throw new ErrorSchema(schema, "Array");
for (var _i = 0, schema_1 = schema; _i < schema_1.length; _i++) {
var sch = schema_1[_i];
if (typeof sch !== "object" || !("struct" in sch)) {
throw new Error('Missing "struct" key in enum schema');
}
if (typeof sch.struct !== "object" || Object.keys(sch.struct).length !== 1) {
throw new Error('The "struct" in each enum must have a single key');
}
validate_schema({ struct: sch.struct });
}
}
function validate_array_schema(schema) {
if (typeof schema !== "object")
throw new ErrorSchema(schema, "{ type, len? }");
if (schema.len && typeof schema.len !== "number") {
throw new Error("Invalid schema: ".concat(schema));
}
if ("type" in schema)
return validate_schema(schema.type);
throw new ErrorSchema(schema, "{ type, len? }");
}
function validate_map_schema(schema) {
if (typeof schema === "object" && "key" in schema && "value" in schema) {
validate_schema(schema.key);
validate_schema(schema.value);
} else {
throw new ErrorSchema(schema, "{ key, value }");
}
}
function validate_struct_schema(schema) {
if (typeof schema !== "object")
throw new ErrorSchema(schema, "object");
for (var key in schema) {
validate_schema(schema[key]);
}
}
// node_modules/borsh/lib/esm/serialize.js
var BorshSerializer = (
/** @class */
function() {
function BorshSerializer2(checkTypes) {
this.encoded = new EncodeBuffer();
this.fieldPath = ["value"];
this.checkTypes = checkTypes;
}
BorshSerializer2.prototype.encode = function(value, schema) {
this.encode_value(value, schema);
return this.encoded.get_used_buffer();
};
BorshSerializer2.prototype.encode_value = function(value, schema) {
if (typeof schema === "string") {
if (integers.includes(schema))
return this.encode_integer(value, schema);
if (schema === "string")
return this.encode_string(value);
if (schema === "bool")
return this.encode_boolean(value);
}
if (typeof schema === "object") {
if ("option" in schema)
return this.encode_option(value, schema);
if ("enum" in schema)
return this.encode_enum(value, schema);
if ("array" in schema)
return this.encode_array(value, schema);
if ("set" in schema)
return this.encode_set(value, schema);
if ("map" in schema)
return this.encode_map(value, schema);
if ("struct" in schema)
return this.encode_struct(value, schema);
}
};
BorshSerializer2.prototype.encode_integer = function(value, schema) {
var size = parseInt(schema.substring(1));
if (size <= 32 || schema == "f64") {
this.checkTypes && expect_type(value, "number", this.fieldPath);
this.encoded.store_value(value, schema);
} else {
this.checkTypes && expect_bigint(value, this.fieldPath);
this.encode_bigint(BigInt(value), size);
}
};
BorshSerializer2.prototype.encode_bigint = function(value, size) {
var buffer_len = size / 8;
var buffer = new Uint8Array(buffer_len);
for (var i = 0; i < buffer_len; i++) {
buffer[i] = Number(value & BigInt(255));
value = value >> BigInt(8);
}
this.encoded.store_bytes(new Uint8Array(buffer));
};
BorshSerializer2.prototype.encode_string = function(value) {
this.checkTypes && expect_type(value, "string", this.fieldPath);
var _value = value;
this.encoded.store_value(_value.length, "u32");
for (var i = 0; i < _value.length; i++) {
this.encoded.store_value(_value.charCodeAt(i), "u8");
}
};
BorshSerializer2.prototype.encode_boolean = function(value) {
this.checkTypes && expect_type(value, "boolean", this.fieldPath);
this.encoded.store_value(value ? 1 : 0, "u8");
};
BorshSerializer2.prototype.encode_option = function(value, schema) {
if (value === null || value === void 0) {
this.encoded.store_value(0, "u8");
} else {
this.encoded.store_value(1, "u8");
this.encode_value(value, schema.option);
}
};
BorshSerializer2.prototype.encode_enum = function(value, schema) {
this.checkTypes && expect_enum(value, this.fieldPath);
var valueKey = Object.keys(value)[0];
for (var i = 0; i < schema["enum"].length; i++) {
var valueSchema = schema["enum"][i];
if (valueKey === Object.keys(valueSchema.struct)[0]) {
this.encoded.store_value(i, "u8");
return this.encode_struct(value, valueSchema);
}
}
throw new Error("Enum key (".concat(valueKey, ") not found in enum schema: ").concat(JSON.stringify(schema), " at ").concat(this.fieldPath.join(".")));
};
BorshSerializer2.prototype.encode_array = function(value, schema) {
if (isArrayLike(value))
return this.encode_arraylike(value, schema);
if (value instanceof ArrayBuffer)
return this.encode_buffer(value, schema);
throw new Error("Expected Array-like not ".concat(typeof value, "(").concat(value, ") at ").concat(this.fieldPath.join(".")));
};
BorshSerializer2.prototype.encode_arraylike = function(value, schema) {
if (schema.array.len) {
expect_same_size(value.length, schema.array.len, this.fieldPath);
} else {
this.encoded.store_value(value.length, "u32");
}
for (var i = 0; i < value.length; i++) {
this.encode_value(value[i], schema.array.type);
}
};
BorshSerializer2.prototype.encode_buffer = function(value, schema) {
if (schema.array.len) {
expect_same_size(value.byteLength, schema.array.len, this.fieldPath);
} else {
this.encoded.store_value(value.byteLength, "u32");
}
this.encoded.store_bytes(new Uint8Array(value));
};
BorshSerializer2.prototype.encode_set = function(value, schema) {
this.checkTypes && expect_type(value, "object", this.fieldPath);
var isSet = value instanceof Set;
var values = isSet ? Array.from(value.values()) : Object.values(value);
this.encoded.store_value(values.length, "u32");
for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
var value_1 = values_1[_i];
this.encode_value(value_1, schema.set);
}
};
BorshSerializer2.prototype.encode_map = function(value, schema) {
this.checkTypes && expect_type(value, "object", this.fieldPath);
var isMap = value instanceof Map;
var keys = isMap ? Array.from(value.keys()) : Object.keys(value);
this.encoded.store_value(keys.length, "u32");
for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
var key = keys_1[_i];
this.encode_value(key, schema.map.key);
this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);
}
};
BorshSerializer2.prototype.encode_struct = function(value, schema) {
this.checkTypes && expect_type(value, "object", this.fieldPath);
for (var _i = 0, _a2 = Object.keys(schema.struct); _i < _a2.length; _i++) {
var key = _a2[_i];
this.fieldPath.push(key);
this.encode_value(value[key], schema.struct[key]);
this.fieldPath.pop();
}
};
return BorshSerializer2;
}()
);
// node_modules/borsh/lib/esm/deserialize.js
var BorshDeserializer = (
/** @class */
function() {
function BorshDeserializer2(bufferArray) {
this.buffer = new DecodeBuffer(bufferArray);
}
BorshDeserializer2.prototype.decode = function(schema) {
return this.decode_value(schema);
};
BorshDeserializer2.prototype.decode_value = function(schema) {
if (typeof schema === "string") {
if (integers.includes(schema))
return this.decode_integer(schema);
if (schema === "string")
return this.decode_string();
if (schema === "bool")
return this.decode_boolean();
}
if (typeof schema === "object") {
if ("option" in schema)
return this.decode_option(schema);
if ("enum" in schema)
return this.decode_enum(schema);
if ("array" in schema)
return this.decode_array(schema);
if ("set" in schema)
return this.decode_set(schema);
if ("map" in schema)
return this.decode_map(schema);
if ("struct" in schema)
return this.decode_struct(schema);
}
throw new Error("Unsupported type: ".concat(schema));
};
BorshDeserializer2.prototype.decode_integer = function(schema) {
var size = parseInt(schema.substring(1));
if (size <= 32 || schema == "f64") {
return this.buffer.consume_value(schema);
}
return this.decode_bigint(size, schema.startsWith("i"));
};
BorshDeserializer2.prototype.decode_bigint = function(size, signed) {
if (signed === void 0) {
signed = false;
}
var buffer_len = size / 8;
var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));
var bits = buffer.reduceRight(function(r, x) {
return r + x.toString(16).padStart(2, "0");
}, "");
if (signed && buffer[buffer_len - 1]) {
return BigInt.asIntN(size, BigInt("0x".concat(bits)));
}
return BigInt("0x".concat(bits));
};
BorshDeserializer2.prototype.decode_string = function() {
var len = this.decode_integer("u32");
var buffer = new Uint8Array(this.buffer.consume_bytes(len));
return String.fromCharCode.apply(null, buffer);
};
BorshDeserializer2.prototype.decode_boolean = function() {
return this.buffer.consume_value("u8") > 0;
};
BorshDeserializer2.prototype.decode_option = function(schema) {
var option = this.buffer.consume_value("u8");
if (option === 1) {
return this.decode_value(schema.option);
}
if (option !== 0) {
throw new Error("Invalid option ".concat(option));
}
return null;
};
BorshDeserializer2.prototype.decode_enum = function(schema) {
var _a2;
var valueIndex = this.buffer.consume_value("u8");
if (valueIndex > schema["enum"].length) {
throw new Error("Enum option ".concat(valueIndex, " is not available"));
}
var struct = schema["enum"][valueIndex].struct;
var key = Object.keys(struct)[0];
return _a2 = {}, _a2[key] = this.decode_value(struct[key]), _a2;
};
BorshDeserializer2.prototype.decode_array = function(schema) {
var result = [];
var len = schema.array.len ? schema.array.len : this.decode_integer("u32");
for (var i = 0; i < len; ++i) {
result.push(this.decode_value(schema.array.type));
}
return result;
};
BorshDeserializer2.prototype.decode_set = function(schema) {
var len = this.decode_integer("u32");
var result = /* @__PURE__ */ new Set();
for (var i = 0; i < len; ++i) {
result.add(this.decode_value(schema.set));
}
return result;
};
BorshDeserializer2.prototype.decode_map = function(schema) {
var len = this.decode_integer("u32");
var result = /* @__PURE__ */ new Map();
for (var i = 0; i < len; ++i) {
var key = this.decode_value(schema.map.key);
var value = this.decode_value(schema.map.value);
result.set(key, value);
}
return result;
};
BorshDeserializer2.prototype.decode_struct = function(schema) {
var result = {};
for (var key in schema.struct) {
result[key] = this.decode_value(schema.struct[key]);
}
return result;
};
return BorshDeserializer2;
}()
);
// node_modules/borsh/lib/esm/index.js
function serialize(schema, value, validate) {
if (validate === void 0) {
validate = true;
}
if (validate)
validate_schema(schema);
var serializer = new BorshSerializer(validate);
return serializer.encode(value, schema);
}
function deserialize(schema, buffer, validate) {
if (validate === void 0) {
validate = true;
}
if (validate)
validate_schema(schema);
var deserializer = new BorshDeserializer(buffer);
return deserializer.decode(schema);
}
// node_modules/@near-js/transactions/lib/esm/prefix.js
var ACTIONABLE_MESSAGE_BASE = Math.pow(2, 30);
var NEP = {
MetaTransactions: 366
};
var NEPPrefix = class {
constructor({ prefix }) {
__publicField(this, "prefix");
this.prefix = prefix;
}
};
var ActionableMessagePrefix = class extends NEPPrefix {
/** Given the NEP number, set the prefix using 2^30 as the offset **/
constructor(prefix) {
super({ prefix: ACTIONABLE_MESSAGE_BASE + prefix });
}
};
var DelegateActionPrefix = class extends ActionableMessagePrefix {
constructor() {
super(NEP.MetaTransactions);
}
};
// node_modules/@near-js/transactions/lib/esm/schema.js
function encodeDelegateAction(delegateAction) {
return new Uint8Array([
...serialize(SCHEMA.DelegateActionPrefix, new DelegateActionPrefix()),
...serialize(SCHEMA.DelegateAction, delegateAction)
]);
}
function encodeTransaction(transaction) {
const schema = "signature" in transaction ? SCHEMA.SignedTransaction : SCHEMA.Transaction;
return serialize(schema, transaction);
}
function decodeTransaction(bytes) {
return new Transaction(deserialize(SCHEMA.Transaction, bytes));
}
function decodeSignedTransaction(bytes) {
return new SignedTransaction(deserialize(SCHEMA.SignedTransaction, bytes));
}
var Transaction = class {
constructor({ signerId, publicKey, nonce, receiverId, actions, blockHash }) {
__publicField(this, "signerId");
__publicField(this, "publicKey");
__publicField(this, "nonce");
__publicField(this, "receiverId");
__publicField(this, "actions");
__publicField(this, "blockHash");
this.signerId = signerId;
this.publicKey = publicKey;
this.nonce = nonce;
this.receiverId = receiverId;
this.actions = actions;
this.blockHash = blockHash;
}
encode() {
return encodeTransaction(this);
}
static decode(bytes) {
return decodeTransaction(bytes);
}
};
var SignedTransaction = class {
constructor({ transaction, signature }) {
__publicField(this, "transaction");
__publicField(this, "signature");
this.transaction = transaction;
this.signature = signature;
}
encode() {
return encodeTransaction(this);
}
static decode(bytes) {
return decodeSignedTransaction(bytes);
}
};
var SCHEMA = new class BorshSchema {
constructor() {
__publicField(this, "Ed25519Signature", {
struct: {
data: { array: { type: "u8", len: 64 } }
}
});
__publicField(this, "Secp256k1Signature", {
struct: {
data: { array: { type: "u8", len: 65 } }
}
});
__publicField(this, "Signature", {
enum: [
{ struct: { ed25519Signature: this.Ed25519Signature } },
{ struct: { secp256k1Signature: this.Secp256k1Signature } }
]
});
__publicField(this, "Ed25519Data", {
struct: {
data: { array: { type: "u8", len: 32 } }
}
});
__publicField(this, "Secp256k1Data", {
struct: {
data: { array: { type: "u8", len: 64 } }
}
});
__publicField(this, "PublicKey", {
enum: [
{ struct: { ed25519Key: this.Ed25519Data } },
{ struct: { secp256k1Key: this.Secp256k1Data } }
]
});
__publicField(this, "FunctionCallPermission", {
struct: {
allowance: { option: "u128" },
receiverId: "string",
methodNames: { array: { type: "string" } }
}
});
__publicField(this, "FullAccessPermission", {
struct: {}
});
__publicField(this, "AccessKeyPermission", {
enum: [
{ struct: { functionCall: this.FunctionCallPermission } },
{ struct: { fullAccess: this.FullAccessPermission } }
]
});
__publicField(this, "AccessKey", {
struct: {
nonce: "u64",
permission: this.AccessKeyPermission
}
});
__publicField(this, "CreateAccount", {
struct: {}
});
__publicField(this, "DeployContract", {
struct: {
code: { array: { type: "u8" } }
}
});
__publicField(this, "FunctionCall", {
struct: {
methodName: "string",
args: { array: { type: "u8" } },
gas: "u64",
deposit: "u128"
}
});
__publicField(this, "Transfer", {
struct: {
deposit: "u128"
}
});
__publicField(this, "Stake", {
struct: {
stake: "u128",
publicKey: this.PublicKey
}
});
__publicField(this, "AddKey", {
struct: {
publicKey: this.PublicKey,
accessKey: this.AccessKey
}
});
__publicField(this, "DeleteKey", {
struct: {
publicKey: this.PublicKey
}
});
__publicField(this, "DeleteAccount", {
struct: {
beneficiaryId: "string"
}
});
__publicField(this, "GlobalContractDeployMode", {
enum: [
{ struct: { CodeHash: { struct: {} } } },
{ struct: { AccountId: { struct: {} } } }
]
});
__publicField(this, "GlobalContractIdentifier", {
enum: [
{ struct: { CodeHash: { array: { type: "u8", len: 32 } } } },
{ struct: { AccountId: "string" } }
]
});
__publicField(this, "DeployGlobalContract", {
struct: {
code: { array: { type: "u8" } },
deployMode: this.GlobalContractDeployMode
}
});
__publicField(this, "UseGlobalContract", {
struct: {
contractIdentifier: this.GlobalContractIdentifier
}
});
__publicField(this, "DelegateActionPrefix", {
struct: {
prefix: "u32"
}
});
__publicField(this, "ClassicActions", {
enum: [
{ struct: { createAccount: this.CreateAccount } },
{ struct: { deployContract: this.DeployContract } },
{ struct: { functionCall: this.FunctionCall } },
{ struct: { transfer: this.Transfer } },
{ struct: { stake: this.Stake } },
{ struct: { addKey: this.AddKey } },
{ struct: { deleteKey: this.DeleteKey } },
{ struct: { deleteAccount: this.DeleteAccount } },
{ struct: { deployGlobalContract: this.DeployGlobalContract } },
{ struct: { useGlobalContract: this.UseGlobalContract } }
]
});
__publicField(this, "DelegateAction", {
struct: {
senderId: "string",
receiverId: "string",
actions: { array: { type: this.ClassicActions } },
nonce: "u64",
maxBlockHeight: "u64",
publicKey: this.PublicKey
}
});
__publicField(this, "SignedDelegate", {
struct: {
delegateAction: this.DelegateAction,
signature: this.Signature
}
});
__publicField(this, "Action", {
enum: [
{ struct: { createAccount: this.CreateAccount } },
{ struct: { deployContract: this.DeployContract } },
{ struct: { functionCall: this.FunctionCall } },
{ struct: { transfer: this.Transfer } },
{ struct: { stake: this.Stake } },
{ struct: { addKey: this.AddKey } },
{ struct: { deleteKey: this.DeleteKey } },
{ struct: { deleteAccount: this.DeleteAccount } },
{ struct: { signedDelegate: this.SignedDelegate } },
{ struct: { deployGlobalContract: this.DeployGlobalContract } },
{ struct: { useGlobalContract: this.UseGlobalContract } }
]
});
__publicField(this, "Transaction", {
struct: {
signerId: "string",
publicKey: this.PublicKey,
nonce: "u64",
receiverId: "string",
blockHash: { array: { type: "u8", len: 32 } },
actions: { array: { type: this.Action } }
}
});
__publicField(this, "SignedTransaction", {
struct: {
transaction: this.Transaction,
signature: this.Signature
}
});
}
}();
// node_modules/@near-js/transactions/lib/esm/create_transaction.js
function createTransaction(signerId, publicKey, receiverId, nonce, actions, blockHash) {
const txNonce = typeof nonce === "bigint" ? nonce : BigInt(nonce);
return new Transaction({
signerId,
publicKey,
nonce: txNonce,
receiverId,
actions,
blockHash
});
}
// node_modules/@near-js/transactions/lib/esm/delegate.js
var {
addKey: addKey2,
createAccount: createAccount2,
deleteAccount: deleteAccount2,
deleteKey: deleteKey2,
deployContract: deployContract2,
functionCall: functionCall2,
stake: stake2,
transfer: transfer2,
deployGlobalContract: deployGlobalContract2,
useGlobalContract: useGlobalContract2
} = actionCreators;
var DelegateAction = class {
constructor({ senderId, receiverId, actions, nonce, maxBlockHeight, publicKey }) {
__publicField(this, "senderId");
__publicField(this, "receiverId");
__publicField(this, "actions");
__publicField(this, "nonce");
__publicField(this, "maxBlockHeight");
__publicField(this, "publicKey");
this.senderId = senderId;
this.receiverId = receiverId;
this.actions = actions;
this.nonce = nonce;
this.maxBlockHeight = maxBlockHeight;
this.publicKey = publicKey;
}
};
function buildDelegateAction({
actions,
maxBlockHeight,
nonce,
publicKey,
receiverId,
senderId
}) {
return new DelegateAction({
senderId,
receiverId,
actions: actions.map((a) => {
if (!a.type && !a.params) {
return a;
}
switch (a.type) {
case "AddKey": {
const { publicKey: publicKey2, accessKey } = a.params;
return addKey2(publicKey2, accessKey);
}
case "CreateAccount": {
return createAccount2(a.params.createAccount);
}
case "DeleteAccount": {
return deleteAccount2(a.params.deleteAccount);
}
case "DeleteKey": {
return deleteKey2(a.params.publicKey);
}
case "DeployContract": {
return deployContract2(a.params.code);
}
case "FunctionCall": {
const { methodName, args, gas, deposit } = a.params;
return functionCall2(methodName, args, gas, deposit);
}
case "Stake": {
return stake2(a.params.stake, a.params.publicKey);
}
case "Transfer": {
const { deposit } = a.params;
return transfer2(deposit);
}
case "DeployGlobalContract": {
const { code, deployMode } = a.params;
const modeInstance = deployMode instanceof GlobalContractDeployMode ? deployMode : new GlobalContractDeployMode(deployMode);
return deployGlobalContract2(code, modeInstance);
}
case "UseGlobalContract": {
const { identifier } = a.params;
const idInstance = identifier instanceof GlobalContractIdentifier ? identifier : new GlobalContractIdentifier(identifier);
return useGlobalContract2(idInstance);
}
}
throw new Error("Unrecognized action");
}),
nonce,
maxBlockHeight,
publicKey
});
}
// node_modules/@near-js/crypto/lib/esm/constants.js
var KeyType = /* @__PURE__ */ ((KeyType2) => {
KeyType2[KeyType2["ED25519"] = 0] = "ED25519";
KeyType2[KeyType2["SECP256K1"] = 1] = "SECP256K1";
return KeyType2;
})(KeyType || {});
var KeySize = {
SECRET_KEY: 32,
ED25519_PUBLIC_KEY: 32,
SECP256k1_PUBLIC_KEY: 64
};
// node_modules/@near-js/crypto/lib/esm/key_pair_base.js
var KeyPairBase = class {
};
// node_modules/@noble/hashes/esm/_assert.js
function isBytes2(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
}
function abytes(b, ...lengths) {
if (!isBytes2(b))
throw new Error("Uint8Array expected");
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
}
function aexists(instance, checkFinished = true) {
if (instance.destroyed)
throw new Error("Hash instance has been destroyed");
if (checkFinished && instance.finished)
throw new Error("Hash#digest() has already been called");
}
function aoutput(out, instance) {
abytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error("digestInto() expects output buffer of length at least " + min);
}
}
// node_modules/@noble/hashes/esm/cryptoNode.js
var nc = __toESM(require("crypto"), 1);
var crypto3 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
// node_modules/@noble/hashes/esm/utils.js
function createView(arr) {
return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
}
function rotr(word, shift) {
return word << 32 - shift | word >>> shift;
}
function utf8ToBytes(str) {
if (typeof str !== "string")
throw new Error("utf8ToBytes expected string, got " + typeof str);
return new Uint8Array(new TextEncoder().encode(str));
}
function toBytes(data) {
if (typeof data === "string")
data = utf8ToBytes(data);
abytes(data);
return data;
}
var Hash = class {
// Safe version that clones internal state
clone() {
return this._cloneInto();
}
};
function wrapConstructor(hashCons) {
const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function randomBytes(bytesLength = 32) {
if (crypto3 && typeof crypto3.getRandomValues === "function") {
return crypto3.getRandomValues(new Uint8Array(bytesLength));
}
if (crypto3 && typeof crypto3.randomBytes === "function") {
return crypto3.randomBytes(bytesLength);
}
throw new Error("crypto.getRandomValues must be defined");
}
// node_modules/@noble/hashes/esm/_md.js
function setBigUint64(view, byteOffset, value, isLE) {
if (typeof view.setBigUint64 === "function")
return view.setBigUint64(byteOffset, value, isLE);
const _32n2 = BigInt(32);
const _u32_max = BigInt(4294967295);
const wh = Number(value >> _32n2 & _u32_max);
const wl = Number(value & _u32_max);
const h = isLE ? 4 : 0;
const l = isLE ? 0 : 4;
view.setUint32(byteOffset + h, wh, isLE);
view.setUint32(byteOffset + l, wl, isLE);
}
function Chi(a, b, c) {
return a & b ^ ~a & c;
}
function Maj(a, b, c) {
return a & b ^ a & c ^ b & c;
}
var HashMD = class extends Hash {
constructor(blockLen, outputLen, padOffset, isLE) {
super();
this.blockLen = blockLen;
this.outputLen = outputLen;
this.padOffset = padOffset;
this.isLE = isLE;
this.finished = false;
this.length = 0;
this.pos = 0;
this.destroyed = false;
this.buffer = new Uint8Array(blockLen);
this.view = createView(this.buffer);
}
update(data) {
aexists(this);
const { view, buffer, blockLen } = this;
data = toBytes(data);
const len = data.length;
for (let pos = 0; pos < len; ) {
const take = Math.min(blockLen - this.pos, len - pos);
if (take === blockLen) {
const dataView = createView(data);
for (; blockLen <= len - pos; pos += blockLen)
this.process(dataView, pos);
continue;
}
buffer.set(data.subarray(pos, pos + take), this.pos);
this.pos += take;
pos += take;
if (this.pos === blockLen) {
this.process(view, 0);
this.pos = 0;
}
}
this.length += data.length;
this.roundClean();
return this;
}
digestInto(out) {
aexists(this);
aoutput(out, this);
this.finished = true;
const { buffer, view, blockLen, isLE } = this;
let { pos } = this;
buffer[pos++] = 128;
this.buffer.subarray(pos).fill(0);
if (this.padOffset > blockLen - pos) {
this.process(view, 0);
pos = 0;
}
for (let i = pos; i < blockLen; i++)
buffer[i] = 0;
setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
this.process(view, 0);
const oview = createView(out);
const len = this.outputLen;
if (len % 4)
throw new Error("_sha2: outputLen should be aligned to 32bit");
const outLen = len / 4;
const state = this.get();
if (outLen > state.length)
throw new Error("_sha2: outputLen bigger than state");
for (let i = 0; i < outLen; i++)
oview.setUint32(4 * i, state[i], isLE);
}
digest() {
const { buffer, outputLen } = this;
this.digestInto(buffer);
const res = buffer.slice(0, outputLen);
this.destroy();
return res;
}
_cloneInto(to) {
to || (to = new this.constructor());
to.set(...this.get());
const { blockLen, buffer, length, finished, destroyed, pos } = this;
to.length = length;
to.pos = pos;
to.finished = finished;
to.destroyed = destroyed;
if (length % blockLen)
to.buffer.set(buffer);
return to;
}
};
// node_modules/@noble/hashes/esm/_u64.js
var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
var _32n = /* @__PURE__ */ BigInt(32);
function fromBig(n, le = false) {
if (le)
return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
}
function split(lst, le = false) {
let Ah = new Uint32Array(lst.length);
let Al = new Uint32Array(lst.length);
for (let i = 0; i < lst.length; i++) {
const { h, l } = fromBig(lst[i], le);
[Ah[i], Al[i]] = [h, l];
}
return [Ah, Al];
}
var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
var shrSH = (h, _l, s) => h >>> s;
var shrSL = (h, l, s) => h << 32 - s | l >>> s;
var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
var rotr32H = (_h, l) => l;
var rotr32L = (h, _l) => h;
var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
function add(Ah, Al, Bh, Bl) {
const l = (Al >>> 0) + (Bl >>> 0);
return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
}
var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
var u64 = {
fromBig,
split,
toBig,
shrSH,
shrSL,
rotrSH,
rotrSL,
rotrBH,
rotrBL,
rotr32H,
rotr32L,
rotlSH,
rotlSL,
rotlBH,
rotlBL,
add,
add3L,
add3H,
add4L,
add4H,
add5H,
add5L
};
var u64_default = u64;
// node_modules/@noble/hashes/esm/sha512.js
var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64_default.split([
"0x428a2f98d728ae22",
"0x7137449123ef65cd",
"0xb5c0fbcfec4d3b2f",
"0xe9b5dba58189dbbc",
"0x3956c25bf348b538",
"0x59f111f1b605d019",
"0x923f82a4af194f9b",
"0xab1c5ed5da6d8118",
"0xd807aa98a3030242",
"0x12835b0145706fbe",
"0x243185be4ee4b28c",
"0x550c7dc3d5ffb4e2",
"0x72be5d74f27b896f",
"0x80deb1fe3b1696b1",
"0x9bdc06a725c71235",
"0xc19bf174cf692694",
"0xe49b69c19ef14ad2",
"0xefbe4786384f25e3",
"0x0fc19dc68b8cd5b5",
"0x240ca1cc77ac9c65",
"0x2de92c6f592b0275",
"0x4a7484aa6ea6e483",
"0x5cb0a9dcbd41fbd4",
"0x76f988da831153b5",
"0x983e5152ee66dfab",
"0xa831c66d2db43210",
"0xb00327c898fb213f",
"0xbf597fc7beef0ee4",
"0xc6e00bf33da88fc2",
"0xd5a79147930aa725",
"0x06ca6351e003826f",
"0x142929670a0e6e70",
"0x27b70a8546d22ffc",
"0x2e1b21385c26c926",
"0x4d2c6dfc5ac42aed",
"0x53380d139d95b3df",
"0x650a73548baf63de",
"0x766a0abb3c77b2a8",
"0x81c2c92e47edaee6",
"0x92722c851482353b",
"0xa2bfe8a14cf10364",
"0xa81a664bbc423001",
"0xc24b8b70d0f89791",
"0xc76c51a30654be30",
"0xd192e819d6ef5218",
"0xd69906245565a910",
"0xf40e35855771202a",
"0x106aa07032bbd1b8",
"0x19a4c116b8d2d0c8",
"0x1e376c085141ab53",
"0x2748774cdf8eeb99",
"0x34b0bcb5e19b48a8",
"0x391c0cb3c5c95a63",
"0x4ed8aa4ae3418acb",
"0x5b9cca4f7763e373",
"0x682e6ff3d6b2b8a3",
"0x748f82ee5defb2fc",
"0x78a5636f43172f60",
"0x84c87814a1f0ab72",
"0x8cc702081a6439ec",
"0x90befffa23631e28",
"0xa4506cebde82bde9",
"0xbef9a3f7b2c67915",
"0xc67178f2e372532b",
"0xca273eceea26619c",
"0xd186b8c721c0c207",
"0xeada7dd6cde0eb1e",
"0xf57d4f7fee6ed178",
"0x06f067aa72176fba",
"0x0a637dc5a2c898a6",
"0x113f9804bef90dae",
"0x1b710b35131c471b",
"0x28db77f523047d84",
"0x32caab7b40c72493",
"0x3c9ebe0a15c9bebc",
"0x431d67c49c100d4c",
"0x4cc5d4becb3e42b6",
"0x597f299cfc657e2a",
"0x5fcb6fab3ad6faec",
"0x6c44198c4a475817"
].map((n) => BigInt(n))))();
var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
var SHA512 = class extends HashMD {
constructor() {
super(128, 64, 16, false);
this.Ah = 1779033703 | 0;
this.Al = 4089235720 | 0;
this.Bh = 3144134277 | 0;
this.Bl = 2227873595 | 0;
this.Ch = 1013904242 | 0;
this.Cl = 4271175723 | 0;
this.Dh = 2773480762 | 0;
this.Dl = 1595750129 | 0;
this.Eh = 1359893119 | 0;
this.El = 2917565137 | 0;
this.Fh = 2600822924 | 0;
this.Fl = 725511199 | 0;
this.Gh = 528734635 | 0;
this.Gl = 4215389547 | 0;
this.Hh = 1541459225 | 0;
this.Hl = 327033209 | 0;
}
// prettier-ignore
get() {
const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
}
// prettier-ignore
set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
this.Ah = Ah | 0;
this.Al = Al | 0;
this.Bh = Bh | 0;
this.Bl = Bl | 0;
this.Ch = Ch | 0;
this.Cl = Cl | 0;
this.Dh = Dh | 0;
this.Dl = Dl | 0;
this.Eh = Eh | 0;
this.El = El | 0;
this.Fh = Fh | 0;
this.Fl = Fl | 0;
this.Gh = Gh | 0;
this.Gl = Gl | 0;
this.Hh = Hh | 0;
this.Hl = Hl | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) {
SHA512_W_H[i] = view.getUint32(offset);
SHA512_W_L[i] = view.getUint32(offset += 4);
}
for (let i = 16; i < 80; i++) {
const W15h = SHA512_W_H[i - 15] | 0;
const W15l = SHA512_W_L[i - 15] | 0;
const s0h = u64_default.rotrSH(W15h, W15l, 1) ^ u64_default.rotrSH(W15h, W15l, 8) ^ u64_default.shrSH(W15h, W15l, 7);
const s0l = u64_default.rotrSL(W15h, W15l, 1) ^ u64_default.rotrSL(W15h, W15l, 8) ^ u64_default.shrSL(W15h, W15l, 7);
const W2h = SHA512_W_H[i - 2] | 0;
const W2l = SHA512_W_L[i - 2] | 0;
const s1h = u64_default.rotrSH(W2h, W2l, 19) ^ u64_default.rotrBH(W2h, W2l, 61) ^ u64_default.shrSH(W2h, W2l, 6);
const s1l = u64_default.rotrSL(W2h, W2l, 19) ^ u64_default.rotrBL(W2h, W2l, 61) ^ u64_default.shrSL(W2h, W2l, 6);
const SUMl = u64_default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
const SUMh = u64_default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
SHA512_W_H[i] = SUMh | 0;
SHA512_W_L[i] = SUMl | 0;
}
let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
for (let i = 0; i < 80; i++) {
const sigma1h = u64_default.rotrSH(Eh, El, 14) ^ u64_default.rotrSH(Eh, El, 18) ^ u64_default.rotrBH(Eh, El, 41);
const sigma1l = u64_default.rotrSL(Eh, El, 14) ^ u64_default.rotrSL(Eh, El, 18) ^ u64_default.rotrBL(Eh, El, 41);
const CHIh = Eh & Fh ^ ~Eh & Gh;
const CHIl = El & Fl ^ ~El & Gl;
const T1ll = u64_default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
const T1h = u64_default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
const T1l = T1ll | 0;
const sigma0h = u64_default.rotrSH(Ah, Al, 28) ^ u64_default.rotrBH(Ah, Al, 34) ^ u64_default.rotrBH(Ah, Al, 39);
const sigma0l = u64_default.rotrSL(Ah, Al, 28) ^ u64_default.rotrBL(Ah, Al, 34) ^ u64_default.rotrBL(Ah, Al, 39);
const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
Hh = Gh | 0;
Hl = Gl | 0;
Gh = Fh | 0;
Gl = Fl | 0;
Fh = Eh | 0;
Fl = El | 0;
({ h: Eh, l: El } = u64_default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
Dh = Ch | 0;
Dl = Cl | 0;
Ch = Bh | 0;
Cl = Bl | 0;
Bh = Ah | 0;
Bl = Al | 0;
const All = u64_default.add3L(T1l, sigma0l, MAJl);
Ah = u64_default.add3H(All, T1h, sigma0h, MAJh);
Al = All | 0;
}
({ h: Ah, l: Al } = u64_default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
({ h: Bh, l: Bl } = u64_default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
({ h: Ch, l: Cl } = u64_default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
({ h: Dh, l: Dl } = u64_default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
({ h: Eh, l: El } = u64_default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
({ h: Fh, l: Fl } = u64_default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
({ h: Gh, l: Gl } = u64_default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
({ h: Hh, l: Hl } = u64_default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
}
roundClean() {
SHA512_W_H.fill(0);
SHA512_W_L.fill(0);
}
destroy() {
this.buffer.fill(0);
this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
};
var sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
// node_modules/@noble/curves/esm/abstract/utils.js
var _0n = /* @__PURE__ */ BigInt(0);
var _1n = /* @__PURE__ */ BigInt(1);
var _2n = /* @__PURE__ */ BigInt(2);
function isBytes3(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
}
function abytes2(item) {
if (!isBytes3(item))
throw new Error("Uint8Array expected");
}
function abool(title, value) {
if (typeof value !== "boolean")
throw new Error(title + " boolean expected, got " + value);
}
var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
function bytesToHex(bytes) {
abytes2(bytes);
let hex = "";
for (let i = 0; i < bytes.length; i++) {
hex += hexes[bytes[i]];
}
return hex;
}
function hexToNumber(hex) {
if (typeof hex !== "string")
throw new Error("hex string expected, got " + typeof hex);
return hex === "" ? _0n : BigInt("0x" + hex);
}
var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
function asciiToBase16(ch) {
if (ch >= asciis._0 && ch <= asciis._9)
return ch - asciis._0;
if (ch >= asciis.A && ch <= asciis.F)
return ch - (asciis.A - 10);
if (ch >= asciis.a && ch <= asciis.f)
return ch - (asciis.a - 10);
return;
}
function hexToBytes(hex) {
if (typeof hex !== "string")
throw new Error("hex string expected, got " + typeof hex);
const hl = hex.length;
const al = hl / 2;
if (hl % 2)
throw new Error("hex string expected, got unpadded hex of length " + hl);
const array = new Uint8Array(al);
for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
const n1 = asciiToBase16(hex.charCodeAt(hi));
const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
if (n1 === void 0 || n2 === void 0) {
const char = hex[hi] + hex[hi + 1];
throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
}
array[ai] = n1 * 16 + n2;
}
return array;
}
function bytesToNumberBE(bytes) {
return hexToNumber(bytesToHex(bytes));
}
function bytesToNumberLE(bytes) {
abytes2(bytes);
return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
}
function numberToBytesBE(n, len) {
return hexToBytes(n.toString(16).padStart(len * 2, "0"));
}
function numberToBytesLE(n, len) {
return numberToBytesBE(n, len).reverse();
}
function ensureBytes(title, hex, expectedLength) {
let res;
if (typeof hex === "string") {
try {
res = hexToBytes(hex);
} catch (e) {
throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
}
} else if (isBytes3(hex)) {
res = Uint8Array.from(hex);
} else {
throw new Error(title + " must be hex string or Uint8Array");
}
const len = res.length;
if (typeof expectedLength === "number" && len !== expectedLength)
throw new Error(title + " of length " + expectedLength + " expected, got " + len);
return res;
}
function concatBytes(...arrays) {
let sum = 0;
for (let i = 0; i < arrays.length; i++) {
const a = arrays[i];
abytes2(a);
sum += a.length;
}
const res = new Uint8Array(sum);
for (let i = 0, pad = 0; i < arrays.length; i++) {
const a = arrays[i];
res.set(a, pad);
pad += a.length;
}
return res;
}
var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
function inRange(n, min, max) {
return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
}
function aInRange(title, n, min, max) {
if (!inRange(n, min, max))
throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
}
function bitLen(n) {
let len;
for (len = 0; n > _0n; n >>= _1n, len += 1)
;
return len;
}
var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
var validatorFns = {
bigint: (val) => typeof val === "bigint",
function: (val) => typeof val === "function",
boolean: (val) => typeof val === "boolean",
string: (val) => typeof val === "string",
stringOrUint8Array: (val) => typeof val === "string" || isBytes3(val),
isSafeInteger: (val) => Number.isSafeInteger(val),
array: (val) => Array.isArray(val),
field: (val, object) => object.Fp.isValid(val),
hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
};
function validateObject(object, validators, optValidators = {}) {
const checkField = (fieldName, type, isOptional) => {
const checkVal = validatorFns[type];
if (typeof checkVal !== "function")
throw new Error("invalid validator function");
const val = object[fieldName];
if (isOptional && val === void 0)
return;
if (!checkVal(val, object)) {
throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
}
};
for (const [fieldName, type] of Object.entries(validators))
checkField(fieldName, type, false);
for (const [fieldName, type] of Object.entries(optValidators))
checkField(fieldName, type, true);
return object;
}
function memoized(fn) {
const map = /* @__PURE__ */ new WeakMap();
return (arg, ...args) => {
const val = map.get(arg);
if (val !== void 0)
return val;
const computed = fn(arg, ...args);
map.set(arg, computed);
return computed;
};
}
// node_modules/@noble/curves/esm/abstract/modular.js
var _0n2 = BigInt(0);
var _1n2 = BigInt(1);
var _2n2 = /* @__PURE__ */ BigInt(2);
var _3n = /* @__PURE__ */ BigInt(3);
var _4n = /* @__PURE__ */ BigInt(4);
var _5n = /* @__PURE__ */ BigInt(5);
var _8n = /* @__PURE__ */ BigInt(8);
var _9n = /* @__PURE__ */ BigInt(9);
var _16n = /* @__PURE__ */ BigInt(16);
function mod(a, b) {
const result = a % b;
return result >= _0n2 ? result : b + result;
}
function pow(num, power, modulo) {
if (power < _0n2)
throw new Error("invalid exponent, negatives unsupported");
if (modulo <= _0n2)
throw new Error("invalid modulus");
if (modulo === _1n2)
return _0n2;
let res = _1n2;
while (power > _0n2) {
if (power & _1n2)
res = res * num % modulo;
num = num * num % modulo;
power >>= _1n2;
}
return res;
}
function pow2(x, power, modulo) {
let res = x;
while (power-- > _0n2) {
res *= res;
res %= modulo;
}
return res;
}
function invert(number, modulo) {
if (number === _0n2)
throw new Error("invert: expected non-zero number");
if (modulo <= _0n2)
throw new Error("invert: expected positive modulus, got " + modulo);
let a = mod(number, modulo);
let b = modulo;
let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
while (a !== _0n2) {
const q = b / a;
const r = b % a;
const m = x - u * q;
const n = y - v * q;
b = a, a = r, x = u, y = v, u = m, v = n;
}
const gcd = b;
if (gcd !== _1n2)
throw new Error("invert: does not exist");
return mod(x, modulo);
}
function tonelliShanks(P) {
const legendreC = (P - _1n2) / _2n2;
let Q, S, Z;
for (Q = P - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++)
;
for (Z = _2n2; Z < P && pow(Z, legendreC, P) !== P - _1n2; Z++) {
if (Z > 1e3)
throw new Error("Cannot find square root: likely non-prime P");
}
if (S === 1) {
const p1div4 = (P + _1n2) / _4n;
return function tonelliFast(Fp2, n) {
const root = Fp2.pow(n, p1div4);
if (!Fp2.eql(Fp2.sqr(root), n))
throw new Error("Cannot find square root");
return root;
};
}
const Q1div2 = (Q + _1n2) / _2n2;
return function tonelliSlow(Fp2, n) {
if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
throw new Error("Cannot find square root");
let r = S;
let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
let x = Fp2.pow(n, Q1div2);
let b = Fp2.pow(n, Q);
while (!Fp2.eql(b, Fp2.ONE)) {
if (Fp2.eql(b, Fp2.ZERO))
return Fp2.ZERO;
let m = 1;
for (let t2 = Fp2.sqr(b); m < r; m++) {
if (Fp2.eql(t2, Fp2.ONE))
break;
t2 = Fp2.sqr(t2);
}
const ge = Fp2.pow(g, _1n2 << BigInt(r - m - 1));
g = Fp2.sqr(ge);
x = Fp2.mul(x, ge);
b = Fp2.mul(b, g);
r = m;
}
return x;
};
}
function FpSqrt(P) {
if (P % _4n === _3n) {
const p1div4 = (P + _1n2) / _4n;
return function sqrt3mod4(Fp2, n) {
const root = Fp2.pow(n, p1div4);
if (!Fp2.eql(Fp2.sqr(root), n))
throw new Error("Cannot find square root");
return root;
};
}
if (P % _8n === _5n) {
const c1 = (P - _5n) / _8n;
return function sqrt5mod8(Fp2, n) {
const n2 = Fp2.mul(n, _2n2);
const v = Fp2.pow(n2, c1);
const nv = Fp2.mul(n, v);
const i = Fp2.mul(Fp2.mul(nv, _2n2), v);
const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
if (!Fp2.eql(Fp2.sqr(root), n))
throw new Error("Cannot find square root");
return root;
};
}
if (P % _16n === _9n) {
}
return tonelliShanks(P);
}
var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n2) === _1n2;
var FIELD_FIELDS = [
"create",
"isValid",
"is0",
"neg",
"inv",
"sqrt",
"sqr",
"eql",
"add",
"sub",
"mul",
"pow",
"div",
"addN",
"subN",
"mulN",
"sqrN"
];
function validateField(field) {
const initial = {
ORDER: "bigint",
MASK: "bigint",
BYTES: "isSafeInteger",
BITS: "isSafeInteger"
};
const opts = FIELD_FIELDS.reduce((map, val) => {
map[val] = "function";
return map;
}, initial);
return validateObject(field, opts);
}
function FpPow(f, num, power) {
if (power < _0n2)
throw new Error("invalid exponent, negatives unsupported");
if (power === _0n2)
return f.ONE;
if (power === _1n2)
return num;
let p = f.ONE;
let d = num;
while (power > _0n2) {
if (power & _1n2)
p = f.mul(p, d);
d = f.sqr(d);
power >>= _1n2;
}
return p;
}
function FpInvertBatch(f, nums) {
const tmp = new Array(nums.length);
const lastMultiplied = nums.reduce((acc, num, i) => {
if (f.is0(num))
return acc;
tmp[i] = acc;
return f.mul(acc, num);
}, f.ONE);
const inverted = f.inv(lastMultiplied);
nums.reduceRight((acc, num, i) => {
if (f.is0(num))
return acc;
tmp[i] = f.mul(acc, tmp[i]);
return f.mul(acc, num);
}, inverted);
return tmp;
}
function nLength(n, nBitLength) {
const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
const nByteLength = Math.ceil(_nBitLength / 8);
return { nBitLength: _nBitLength, nByteLength };
}
function Field(ORDER, bitLen2, isLE = false, redef = {}) {
if (ORDER <= _0n2)
throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
if (BYTES > 2048)
throw new Error("invalid field: expected ORDER of <= 2048 bytes");
let sqrtP;
const f = Object.freeze({
ORDER,
isLE,
BITS,
BYTES,
MASK: bitMask(BITS),
ZERO: _0n2,
ONE: _1n2,
create: (num) => mod(num, ORDER),
isValid: (num) => {
if (typeof num !== "bigint")
throw new Error("invalid field element: expected bigint, got " + typeof num);
return _0n2 <= num && num < ORDER;
},
is0: (num) => num === _0n2,
isOdd: (num) => (num & _1n2) === _1n2,
neg: (num) => mod(-num, ORDER),
eql: (lhs, rhs) => lhs === rhs,
sqr: (num) => mod(num * num, ORDER),
add: (lhs, rhs) => mod(lhs + rhs, ORDER),
sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
pow: (num, power) => FpPow(f, num, power),
div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
// Same as above, but doesn't normalize
sqrN: (num) => num * num,
addN: (lhs, rhs) => lhs + rhs,
subN: (lhs, rhs) => lhs - rhs,
mulN: (lhs, rhs) => lhs * rhs,
inv: (num) => invert(num, ORDER),
sqrt: redef.sqrt || ((n) => {
if (!sqrtP)
sqrtP = FpSqrt(ORDER);
return sqrtP(f, n);
}),
invertBatch: (lst) => FpInvertBatch(f, lst),
// TODO: do we really need constant cmov?
// We don't have const-time bigints anyway, so probably will be not very useful
cmov: (a, b, c) => c ? b : a,
toBytes: (num) => isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
fromBytes: (bytes) => {
if (bytes.length !== BYTES)
throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
}
});
return Object.freeze(f);
}
// node_modules/@noble/curves/esm/abstract/curve.js
var _0n3 = BigInt(0);
var _1n3 = BigInt(1);
function constTimeNegate(condition, item) {
const neg = item.negate();
return condition ? neg : item;
}
function validateW(W, bits) {
if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
}
function calcWOpts(W, bits) {
validateW(W, bits);
const windows = Math.ceil(bits / W) + 1;
const windowSize = 2 ** (W - 1);
return { windows, windowSize };
}
function validateMSMPoints(points, c) {
if (!Array.isArray(points))
throw new Error("array expected");
points.forEach((p, i) => {
if (!(p instanceof c))
throw new Error("invalid point at index " + i);
});
}
function validateMSMScalars(scalars, field) {
if (!Array.isArray(scalars))
throw new Error("array of scalars expected");
scalars.forEach((s, i) => {
if (!field.isValid(s))
throw new Error("invalid scalar at index " + i);
});
}
var pointPrecomputes = /* @__PURE__ */ new WeakMap();
var pointWindowSizes = /* @__PURE__ */ new WeakMap();
function getW(P) {
return pointWindowSizes.get(P) || 1;
}
function wNAF(c, bits) {
return {
constTimeNegate,
hasPrecomputes(elm) {
return getW(elm) !== 1;
},
// non-const time multiplication ladder
unsafeLadder(elm, n, p = c.ZERO) {
let d = elm;
while (n > _0n3) {
if (n & _1n3)
p = p.add(d);
d = d.double();
n >>= _1n3;
}
return p;
},
/**
* Creates a wNAF precomputation window. Used for caching.
* Default window size is set by `utils.precompute()` and is equal to 8.
* Number of precomputed points depends on the curve size:
* 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
* - 𝑊 is the window size
* - 𝑛 is the bitlength of the curve order.
* For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
* @param elm Point instance
* @param W window size
* @returns precomputed point tables flattened to a single array
*/
precomputeWindow(elm, W) {
const { windows, windowSize } = calcWOpts(W, bits);
const points = [];
let p = elm;
let base = p;
for (let window2 = 0; window2 < windows; window2++) {
base = p;
points.push(base);
for (let i = 1; i < windowSize; i++) {
base = base.add(p);
points.push(base);
}
p = base.double();
}
return points;
},
/**
* Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
* @param W window size
* @param precomputes precomputed tables
* @param n scalar (we don't check here, but should be less than curve order)
* @returns real and fake (for const-time) points
*/
wNAF(W, precomputes, n) {
const { windows, windowSize } = calcWOpts(W, bits);
let p = c.ZERO;
let f = c.BASE;
const mask = BigInt(2 ** W - 1);
const maxNumber = 2 ** W;
const shiftBy = BigInt(W);
for (let window2 = 0; window2 < windows; window2++) {
const offset = window2 * windowSize;
let wbits = Number(n & mask);
n >>= shiftBy;
if (wbits > windowSize) {
wbits -= maxNumber;
n += _1n3;
}
const offset1 = offset;
const offset2 = offset + Math.abs(wbits) - 1;
const cond1 = window2 % 2 !== 0;
const cond2 = wbits < 0;
if (wbits === 0) {
f = f.add(constTimeNegate(cond1, precomputes[offset1]));
} else {
p = p.add(constTimeNegate(cond2, precomputes[offset2]));
}
}
return { p, f };
},
/**
* Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
* @param W window size
* @param precomputes precomputed tables
* @param n scalar (we don't check here, but should be less than curve order)
* @param acc accumulator point to add result of multiplication
* @returns point
*/
wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
const { windows, windowSize } = calcWOpts(W, bits);
const mask = BigInt(2 ** W - 1);
const maxNumber = 2 ** W;
const shiftBy = BigInt(W);
for (let window2 = 0; window2 < windows; window2++) {
const offset = window2 * windowSize;
if (n === _0n3)
break;
let wbits = Number(n & mask);
n >>= shiftBy;
if (wbits > windowSize) {
wbits -= maxNumber;
n += _1n3;
}
if (wbits === 0)
continue;
let curr = precomputes[offset + Math.abs(wbits) - 1];
if (wbits < 0)
curr = curr.negate();
acc = acc.add(curr);
}
return acc;
},
getPrecomputes(W, P, transform) {
let comp = pointPrecomputes.get(P);
if (!comp) {
comp = this.precomputeWindow(P, W);
if (W !== 1)
pointPrecomputes.set(P, transform(comp));
}
return comp;
},
wNAFCached(P, n, transform) {
const W = getW(P);
return this.wNAF(W, this.getPrecomputes(W, P, transform), n);
},
wNAFCachedUnsafe(P, n, transform, prev) {
const W = getW(P);
if (W === 1)
return this.unsafeLadder(P, n, prev);
return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);
},
// We calculate precomputes for elliptic curve point multiplication
// using windowed method. This specifies window size and
// stores precomputed values. Usually only base point would be precomputed.
setWindowSize(P, W) {
validateW(W, bits);
pointWindowSizes.set(P, W);
pointPrecomputes.delete(P);
}
};
}
function pippenger(c, fieldN, points, scalars) {
validateMSMPoints(points, c);
validateMSMScalars(scalars, fieldN);
if (points.length !== scalars.length)
throw new Error("arrays of points and scalars must have equal length");
const zero = c.ZERO;
const wbits = bitLen(BigInt(points.length));
const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
const MASK = (1 << windowSize) - 1;
const buckets = new Array(MASK + 1).fill(zero);
const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
let sum = zero;
for (let i = lastBits; i >= 0; i -= windowSize) {
buckets.fill(zero);
for (let j = 0; j < scalars.length; j++) {
const scalar = scalars[j];
const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
buckets[wbits2] = buckets[wbits2].add(points[j]);
}
let resI = zero;
for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {
sumI = sumI.add(buckets[j]);
resI = resI.add(sumI);
}
sum = sum.add(resI);
if (i !== 0)
for (let j = 0; j < windowSize; j++)
sum = sum.double();
}
return sum;
}
function validateBasic(curve) {
validateField(curve.Fp);
validateObject(curve, {
n: "bigint",
h: "bigint",
Gx: "field",
Gy: "field"
}, {
nBitLength: "isSafeInteger",
nByteLength: "isSafeInteger"
});
return Object.freeze({
...nLength(curve.n, curve.nBitLength),
...curve,
...{ p: curve.Fp.ORDER }
});
}
// node_modules/@noble/curves/esm/abstract/edwards.js
var _0n4 = BigInt(0);
var _1n4 = BigInt(1);
var _2n3 = BigInt(2);
var _8n2 = BigInt(8);
var VERIFY_DEFAULT = { zip215: true };
function validateOpts(curve) {
const opts = validateBasic(curve);
validateObject(curve, {
hash: "function",
a: "bigint",
d: "bigint",
randomBytes: "function"
}, {
adjustScalarBytes: "function",
domain: "function",
uvRatio: "function",
mapToCurve: "function"
});
return Object.freeze({ ...opts });
}
function twistedEdwards(curveDef) {
const CURVE = validateOpts(curveDef);
const { Fp: Fp2, n: CURVE_ORDER, prehash, hash: cHash, randomBytes: randomBytes2, nByteLength, h: cofactor } = CURVE;
const MASK = _2n3 << BigInt(nByteLength * 8) - _1n4;
const modP = Fp2.create;
const Fn = Field(CURVE.n, CURVE.nBitLength);
const uvRatio2 = CURVE.uvRatio || ((u, v) => {
try {
return { isValid: true, value: Fp2.sqrt(u * Fp2.inv(v)) };
} catch (e) {
return { isValid: false, value: _0n4 };
}
});
const adjustScalarBytes2 = CURVE.adjustScalarBytes || ((bytes) => bytes);
const domain = CURVE.domain || ((data, ctx, phflag) => {
abool("phflag", phflag);
if (ctx.length || phflag)
throw new Error("Contexts/pre-hash are not supported");
return data;
});
function aCoordinate(title, n) {
aInRange("coordinate " + title, n, _0n4, MASK);
}
function assertPoint(other) {
if (!(other instanceof Point))
throw new Error("ExtendedPoint expected");
}
const toAffineMemo = memoized((p, iz) => {
const { ex: x, ey: y, ez: z } = p;
const is0 = p.is0();
if (iz == null)
iz = is0 ? _8n2 : Fp2.inv(z);
const ax = modP(x * iz);
const ay = modP(y * iz);
const zz = modP(z * iz);
if (is0)
return { x: _0n4, y: _1n4 };
if (zz !== _1n4)
throw new Error("invZ was invalid");
return { x: ax, y: ay };
});
const assertValidMemo = memoized((p) => {
const { a, d } = CURVE;
if (p.is0())
throw new Error("bad point: ZERO");
const { ex: X, ey: Y, ez: Z, et: T } = p;
const X2 = modP(X * X);
const Y2 = modP(Y * Y);
const Z2 = modP(Z * Z);
const Z4 = modP(Z2 * Z2);
const aX2 = modP(X2 * a);
const left = modP(Z2 * modP(aX2 + Y2));
const right = modP(Z4 + modP(d * modP(X2 * Y2)));
if (left !== right)
throw new Error("bad point: equation left != right (1)");
const XY = modP(X * Y);
const ZT = modP(Z * T);
if (XY !== ZT)
throw new Error("bad point: equation left != right (2)");
return true;
});
class Point {
constructor(ex, ey, ez, et) {
this.ex = ex;
this.ey = ey;
this.ez = ez;
this.et = et;
aCoordinate("x", ex);
aCoordinate("y", ey);
aCoordinate("z", ez);
aCoordinate("t", et);
Object.freeze(this);
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
static fromAffine(p) {
if (p instanceof Point)
throw new Error("extended point not allowed");
const { x, y } = p || {};
aCoordinate("x", x);
aCoordinate("y", y);
return new Point(x, y, _1n4, modP(x * y));
}
static normalizeZ(points) {
const toInv = Fp2.invertBatch(points.map((p) => p.ez));
return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
}
// Multiscalar Multiplication
static msm(points, scalars) {
return pippenger(Point, Fn, points, scalars);
}
// "Private method", don't use it directly
_setWindowSize(windowSize) {
wnaf.setWindowSize(this, windowSize);
}
// Not required for fromHex(), which always creates valid points.
// Could be useful for fromAffine().
assertValidity() {
assertValidMemo(this);
}
// Compare one point to another.
equals(other) {
assertPoint(other);
const { ex: X1, ey: Y1, ez: Z1 } = this;
const { ex: X2, ey: Y2, ez: Z2 } = other;
const X1Z2 = modP(X1 * Z2);
const X2Z1 = modP(X2 * Z1);
const Y1Z2 = modP(Y1 * Z2);
const Y2Z1 = modP(Y2 * Z1);
return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
}
is0() {
return this.equals(Point.ZERO);
}
negate() {
return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));
}
// Fast algo for doubling Extended Point.
// https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
// Cost: 4M + 4S + 1*a + 6add + 1*2.
double() {
const { a } = CURVE;
const { ex: X1, ey: Y1, ez: Z1 } = this;
const A = modP(X1 * X1);
const B = modP(Y1 * Y1);
const C = modP(_2n3 * modP(Z1 * Z1));
const D = modP(a * A);
const x1y1 = X1 + Y1;
const E = modP(modP(x1y1 * x1y1) - A - B);
const G2 = D + B;
const F = G2 - C;
const H = D - B;
const X3 = modP(E * F);
const Y3 = modP(G2 * H);
const T3 = modP(E * H);
const Z3 = modP(F * G2);
return new Point(X3, Y3, Z3, T3);
}
// Fast algo for adding 2 Extended Points.
// https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
// Cost: 9M + 1*a + 1*d + 7add.
add(other) {
assertPoint(other);
const { a, d } = CURVE;
const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
if (a === BigInt(-1)) {
const A2 = modP((Y1 - X1) * (Y2 + X2));
const B2 = modP((Y1 + X1) * (Y2 - X2));
const F2 = modP(B2 - A2);
if (F2 === _0n4)
return this.double();
const C2 = modP(Z1 * _2n3 * T2);
const D2 = modP(T1 * _2n3 * Z2);
const E2 = D2 + C2;
const G3 = B2 + A2;
const H2 = D2 - C2;
const X32 = modP(E2 * F2);
const Y32 = modP(G3 * H2);
const T32 = modP(E2 * H2);
const Z32 = modP(F2 * G3);
return new Point(X32, Y32, Z32, T32);
}
const A = modP(X1 * X2);
const B = modP(Y1 * Y2);
const C = modP(T1 * d * T2);
const D = modP(Z1 * Z2);
const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
const F = D - C;
const G2 = D + C;
const H = modP(B - a * A);
const X3 = modP(E * F);
const Y3 = modP(G2 * H);
const T3 = modP(E * H);
const Z3 = modP(F * G2);
return new Point(X3, Y3, Z3, T3);
}
subtract(other) {
return this.add(other.negate());
}
wNAF(n) {
return wnaf.wNAFCached(this, n, Point.normalizeZ);
}
// Constant-time multiplication.
multiply(scalar) {
const n = scalar;
aInRange("scalar", n, _1n4, CURVE_ORDER);
const { p, f } = this.wNAF(n);
return Point.normalizeZ([p, f])[0];
}
// Non-constant-time multiplication. Uses double-and-add algorithm.
// It's faster, but should only be used when you don't care about
// an exposed private key e.g. sig verification.
// Does NOT allow scalars higher than CURVE.n.
// Accepts optional accumulator to merge with multiply (important for sparse scalars)
multiplyUnsafe(scalar, acc = Point.ZERO) {
const n = scalar;
aInRange("scalar", n, _0n4, CURVE_ORDER);
if (n === _0n4)
return I;
if (this.is0() || n === _1n4)
return this;
return wnaf.wNAFCachedUnsafe(this, n, Point.normalizeZ, acc);
}
// Checks if point is of small order.
// If you add something to small order point, you will have "dirty"
// point with torsion component.
// Multiplies point by cofactor and checks if the result is 0.
isSmallOrder() {
return this.multiplyUnsafe(cofactor).is0();
}
// Multiplies point by curve order and checks if the result is 0.
// Returns `false` is the point is dirty.
isTorsionFree() {
return wnaf.unsafeLadder(this, CURVE_ORDER).is0();
}
// Converts Extended point to default (x, y) coordinates.
// Can accept precomputed Z^-1 - for example, from invertBatch.
toAffine(iz) {
return toAffineMemo(this, iz);
}
clearCofactor() {
const { h: cofactor2 } = CURVE;
if (cofactor2 === _1n4)
return this;
return this.multiplyUnsafe(cofactor2);
}
// Converts hash string or Uint8Array to Point.
// Uses algo from RFC8032 5.1.3.
static fromHex(hex, zip215 = false) {
const { d, a } = CURVE;
const len = Fp2.BYTES;
hex = ensureBytes("pointHex", hex, len);
abool("zip215", zip215);
const normed = hex.slice();
const lastByte = hex[len - 1];
normed[len - 1] = lastByte & ~128;
const y = bytesToNumberLE(normed);
const max = zip215 ? MASK : Fp2.ORDER;
aInRange("pointHex.y", y, _0n4, max);
const y2 = modP(y * y);
const u = modP(y2 - _1n4);
const v = modP(d * y2 - a);
let { isValid, value: x } = uvRatio2(u, v);
if (!isValid)
throw new Error("Point.fromHex: invalid y coordinate");
const isXOdd = (x & _1n4) === _1n4;
const isLastByteOdd = (lastByte & 128) !== 0;
if (!zip215 && x === _0n4 && isLastByteOdd)
throw new Error("Point.fromHex: x=0 and x_0=1");
if (isLastByteOdd !== isXOdd)
x = modP(-x);
return Point.fromAffine({ x, y });
}
static fromPrivateKey(privKey) {
return getExtendedPublicKey(privKey).point;
}
toRawBytes() {
const { x, y } = this.toAffine();
const bytes = numberToBytesLE(y, Fp2.BYTES);
bytes[bytes.length - 1] |= x & _1n4 ? 128 : 0;
return bytes;
}
toHex() {
return bytesToHex(this.toRawBytes());
}
}
Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n4, modP(CURVE.Gx * CURVE.Gy));
Point.ZERO = new Point(_0n4, _1n4, _1n4, _0n4);
const { BASE: G, ZERO: I } = Point;
const wnaf = wNAF(Point, nByteLength * 8);
function modN(a) {
return mod(a, CURVE_ORDER);
}
function modN_LE(hash) {
return modN(bytesToNumberLE(hash));
}
function getExtendedPublicKey(key) {
const len = Fp2.BYTES;
key = ensureBytes("private key", key, len);
const hashed = ensureBytes("hashed private key", cHash(key), 2 * len);
const head = adjustScalarBytes2(hashed.slice(0, len));
const prefix = hashed.slice(len, 2 * len);
const scalar = modN_LE(head);
const point = G.multiply(scalar);
const pointBytes = point.toRawBytes();
return { head, prefix, scalar, point, pointBytes };
}
function getPublicKey(privKey) {
return getExtendedPublicKey(privKey).pointBytes;
}
function hashDomainToScalar(context = new Uint8Array(), ...msgs) {
const msg = concatBytes(...msgs);
return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
}
function sign(msg, privKey, options = {}) {
msg = ensureBytes("message", msg);
if (prehash)
msg = prehash(msg);
const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
const r = hashDomainToScalar(options.context, prefix, msg);
const R = G.multiply(r).toRawBytes();
const k = hashDomainToScalar(options.context, R, pointBytes, msg);
const s = modN(r + k * scalar);
aInRange("signature.s", s, _0n4, CURVE_ORDER);
const res = concatBytes(R, numberToBytesLE(s, Fp2.BYTES));
return ensureBytes("result", res, Fp2.BYTES * 2);
}
const verifyOpts = VERIFY_DEFAULT;
function verify(sig, msg, publicKey, options = verifyOpts) {
const { context, zip215 } = options;
const len = Fp2.BYTES;
sig = ensureBytes("signature", sig, 2 * len);
msg = ensureBytes("message", msg);
publicKey = ensureBytes("publicKey", publicKey, len);
if (zip215 !== void 0)
abool("zip215", zip215);
if (prehash)
msg = prehash(msg);
const s = bytesToNumberLE(sig.slice(len, 2 * len));
let A, R, SB;
try {
A = Point.fromHex(publicKey, zip215);
R = Point.fromHex(sig.slice(0, len), zip215);
SB = G.multiplyUnsafe(s);
} catch (error) {
return false;
}
if (!zip215 && A.isSmallOrder())
return false;
const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
const RkA = R.add(A.multiplyUnsafe(k));
return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);
}
G._setWindowSize(8);
const utils = {
getExtendedPublicKey,
// ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.
randomPrivateKey: () => randomBytes2(Fp2.BYTES),
/**
* We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
* values. This slows down first getPublicKey() by milliseconds (see Speed section),
* but allows to speed-up subsequent getPublicKey() calls up to 20x.
* @param windowSize 2, 4, 8, 16
*/
precompute(windowSize = 8, point = Point.BASE) {
point._setWindowSize(windowSize);
point.multiply(BigInt(3));
return point;
}
};
return {
CURVE,
getPublicKey,
sign,
verify,
ExtendedPoint: Point,
utils
};
}
// node_modules/@noble/curves/esm/ed25519.js
var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
var _0n5 = BigInt(0);
var _1n5 = BigInt(1);
var _2n4 = BigInt(2);
var _3n2 = BigInt(3);
var _5n2 = BigInt(5);
var _8n3 = BigInt(8);
function ed25519_pow_2_252_3(x) {
const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
const P = ED25519_P;
const x2 = x * x % P;
const b2 = x2 * x % P;
const b4 = pow2(b2, _2n4, P) * b2 % P;
const b5 = pow2(b4, _1n5, P) * x % P;
const b10 = pow2(b5, _5n2, P) * b5 % P;
const b20 = pow2(b10, _10n, P) * b10 % P;
const b40 = pow2(b20, _20n, P) * b20 % P;
const b80 = pow2(b40, _40n, P) * b40 % P;
const b160 = pow2(b80, _80n, P) * b80 % P;
const b240 = pow2(b160, _80n, P) * b80 % P;
const b250 = pow2(b240, _10n, P) * b10 % P;
const pow_p_5_8 = pow2(b250, _2n4, P) * x % P;
return { pow_p_5_8, b2 };
}
function adjustScalarBytes(bytes) {
bytes[0] &= 248;
bytes[31] &= 127;
bytes[31] |= 64;
return bytes;
}
function uvRatio(u, v) {
const P = ED25519_P;
const v3 = mod(v * v * v, P);
const v7 = mod(v3 * v3 * v, P);
const pow3 = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
let x = mod(u * v3 * pow3, P);
const vx2 = mod(v * x * x, P);
const root1 = x;
const root2 = mod(x * ED25519_SQRT_M1, P);
const useRoot1 = vx2 === u;
const useRoot2 = vx2 === mod(-u, P);
const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
if (useRoot1)
x = root1;
if (useRoot2 || noRoot)
x = root2;
if (isNegativeLE(x, P))
x = mod(-x, P);
return { isValid: useRoot1 || useRoot2, value: x };
}
var Fp = /* @__PURE__ */ (() => Field(ED25519_P, void 0, true))();
var ed25519Defaults = /* @__PURE__ */ (() => ({
// Param: a
a: BigInt(-1),
// Fp.create(-1) is proper; our way still works and is faster
// d is equal to -121665/121666 over finite field.
// Negative number is P - number, and division is invert(number, P)
d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
// Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n
Fp,
// Subgroup order: how many points curve has
// 2n**252n + 27742317777372353535851937790883648493n;
n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
// Cofactor
h: _8n3,
// Base point (x, y) aka generator point
Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
hash: sha512,
randomBytes,
adjustScalarBytes,
// dom2
// Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
// Constant-time, u/√v
uvRatio
}))();
var ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
// node_modules/@near-js/crypto/lib/esm/key_pair_ed25519.js
var import_randombytes = __toESM(require_randombytes(), 1);
// node_modules/@near-js/crypto/lib/esm/public_key.js
var import_secp256k1 = __toESM(require_secp256k12(), 1);
function key_type_to_str(keyType) {
switch (keyType) {
case KeyType.ED25519:
return "ed25519";
case KeyType.SECP256K1:
return "secp256k1";
default:
throw new Error(`Unknown key type ${keyType}`);
}
}
function str_to_key_type(keyType) {
switch (keyType.toLowerCase()) {
case "ed25519":
return KeyType.ED25519;
case "secp256k1":
return KeyType.SECP256K1;
default:
throw new Error(`Unknown key type ${keyType}`);
}
}
function resolveEnumKeyName(keyType) {
switch (keyType) {
case KeyType.ED25519: {
return "ed25519Key";
}
case KeyType.SECP256K1: {
return "secp256k1Key";
}
default: {
throw Error(`unknown type ${keyType}`);
}
}
}
var Enum2 = class {
constructor(properties) {
if (Object.keys(properties).length !== 1) {
throw new Error("Enum can only take single value");
}
Object.keys(properties).map((key) => {
this[key] = properties[key];
});
}
};
var PublicKey = class _PublicKey extends Enum2 {
constructor(publicKey) {
const keyName = resolveEnumKeyName(publicKey.keyType);
super({ [keyName]: publicKey });
__publicField(this, "enum");
__publicField(this, "ed25519Key");
__publicField(this, "secp256k1Key");
this[keyName] = publicKey;
this.enum = keyName;
}
/**
* Creates a PublicKey instance from a string or an existing PublicKey instance.
* @param value The string or PublicKey instance to create a PublicKey from.
* @returns {PublicKey} The PublicKey instance.
*/
static from(value) {
if (typeof value === "string") {
return _PublicKey.fromString(value);
}
return value;
}
/**
* Creates a PublicKey instance from an encoded key string.
* @param encodedKey The encoded key string.
* @returns {PublicKey} The PublicKey instance created from the encoded key string.
*/
static fromString(encodedKey) {
const parts = encodedKey.split(":");
let publicKey;
let keyType;
if (parts.length === 1) {
publicKey = parts[0];
} else if (parts.length === 2) {
publicKey = parts[1];
keyType = str_to_key_type(parts[0]);
} else {
throw new Error("Invalid encoded key format, must be <curve>:<encoded key>");
}
const decodedPublicKey = baseDecode(publicKey);
if (!keyType) {
keyType = decodedPublicKey.length === KeySize.SECP256k1_PUBLIC_KEY ? KeyType.SECP256K1 : KeyType.ED25519;
}
const keySize = keyType === KeyType.ED25519 ? KeySize.ED25519_PUBLIC_KEY : KeySize.SECP256k1_PUBLIC_KEY;
if (decodedPublicKey.length !== keySize) {
throw new Error(`Invalid public key size (${decodedPublicKey.length}), must be ${keySize}`);
}
return new _PublicKey({ keyType, data: decodedPublicKey });
}
/**
* Returns a string representation of the public key.
* @returns {string} The string representation of the public key.
*/
toString() {
const encodedKey = baseEncode(this.data);
return `${key_type_to_str(this.keyType)}:${encodedKey}`;
}
/**
* Verifies a message signature using the public key.
* @param message The message to be verified.
* @param signature The signature to be verified.
* @returns {boolean} `true` if the signature is valid, otherwise `false`.
*/
verify(message, signature) {
const keyType = this.keyType;
const data = this.data;
switch (keyType) {
case KeyType.ED25519:
return ed25519.verify(signature, message, data);
case KeyType.SECP256K1:
return import_secp256k1.default.ecdsaVerify(signature.subarray(0, 64), message, new Uint8Array([4, ...data]));
default:
throw new Error(`Unknown key type: ${keyType}`);
}
}
get keyPair() {
return this.ed25519Key || this.secp256k1Key;
}
get keyType() {
return this.keyPair.keyType;
}
get data() {
return this.keyPair.data;
}
};
// node_modules/@near-js/crypto/lib/esm/key_pair_ed25519.js
var KeyPairEd25519 = class _KeyPairEd25519 extends KeyPairBase {
/**
* Construct an instance of key pair given a secret key.
* It's generally assumed that these are encoded in base58.
* @param extendedSecretKey
*/
constructor(extendedSecretKey) {
super();
__publicField(this, "publicKey");
__publicField(this, "secretKey");
__publicField(this, "extendedSecretKey");
const decoded = baseDecode(extendedSecretKey);
const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));
const publicKey = ed25519.getPublicKey(new Uint8Array(secretKey));
this.publicKey = new PublicKey({ keyType: KeyType.ED25519, data: publicKey });
this.secretKey = baseEncode(secretKey);
this.extendedSecretKey = extendedSecretKey;
}
/**
* Generate a new random keypair.
* @example
* const keyRandom = KeyPair.fromRandom();
* keyRandom.publicKey
* // returns [PUBLIC_KEY]
*
* keyRandom.secretKey
* // returns [SECRET_KEY]
*/
static fromRandom() {
const secretKey = (0, import_randombytes.default)(KeySize.SECRET_KEY);
const publicKey = ed25519.getPublicKey(new Uint8Array(secretKey));
const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);
return new _KeyPairEd25519(baseEncode(extendedSecretKey));
}
/**
* Signs a message using the key pair's secret key.
* @param message The message to be signed.
* @returns {Signature} The signature object containing the signature and the public key.
*/
sign(message) {
const signature = ed25519.sign(message, baseDecode(this.secretKey));
return { signature, publicKey: this.publicKey };
}
/**
* Verifies the signature of a message using the key pair's public key.
* @param message The message to be verified.
* @param signature The signature to be verified.
* @returns {boolean} `true` if the signature is valid, otherwise `false`.
*/
verify(message, signature) {
return this.publicKey.verify(message, signature);
}
/**
* Returns a string representation of the key pair in the format 'ed25519:[extendedSecretKey]'.
* @returns {string} The string representation of the key pair.
*/
toString() {
return `ed25519:${this.extendedSecretKey}`;
}
/**
* Retrieves the public key associated with the key pair.
* @returns {PublicKey} The public key.
*/
getPublicKey() {
return this.publicKey;
}
};
// node_modules/@near-js/crypto/lib/esm/key_pair_secp256k1.js
var import_randombytes2 = __toESM(require_randombytes(), 1);
var import_secp256k12 = __toESM(require_secp256k12(), 1);
var KeyPairSecp256k1 = class _KeyPairSecp256k1 extends KeyPairBase {
/**
* Construct an instance of key pair given a secret key.
* It's generally assumed that these are encoded in base58.
* @param {string} extendedSecretKey
*/
constructor(extendedSecretKey) {
super();
__publicField(this, "publicKey");
__publicField(this, "secretKey");
__publicField(this, "extendedSecretKey");
const decoded = baseDecode(extendedSecretKey);
const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));
const withHeader = import_secp256k12.default.publicKeyCreate(new Uint8Array(secretKey), false);
const data = withHeader.subarray(1, withHeader.length);
this.publicKey = new PublicKey({
keyType: KeyType.SECP256K1,
data
});
this.secretKey = baseEncode(secretKey);
this.extendedSecretKey = extendedSecretKey;
}
/**
* Generate a new random keypair.
* @example
* const keyRandom = KeyPair.fromRandom();
* keyRandom.publicKey
* // returns [PUBLIC_KEY]
*
* keyRandom.secretKey
* // returns [SECRET_KEY]
*/
static fromRandom() {
const secretKey = (0, import_randombytes2.default)(KeySize.SECRET_KEY);
const withHeader = import_secp256k12.default.publicKeyCreate(new Uint8Array(secretKey), false);
const publicKey = withHeader.subarray(1, withHeader.length);
const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);
return new _KeyPairSecp256k1(baseEncode(extendedSecretKey));
}
sign(message) {
const { signature, recid } = import_secp256k12.default.ecdsaSign(message, baseDecode(this.secretKey));
return { signature: new Uint8Array([...signature, recid]), publicKey: this.publicKey };
}
verify(message, signature) {
return this.publicKey.verify(message, signature);
}
toString() {
return `secp256k1:${this.extendedSecretKey}`;
}
getPublicKey() {
return this.publicKey;
}
};
// node_modules/@near-js/crypto/lib/esm/key_pair.js
var KeyPair = class extends KeyPairBase {
/**
* @param curve Name of elliptical curve, case-insensitive
* @returns Random KeyPair based on the curve
*/
static fromRandom(curve) {
switch (curve.toUpperCase()) {
case "ED25519":
return KeyPairEd25519.fromRandom();
case "SECP256K1":
return KeyPairSecp256k1.fromRandom();
default:
throw new Error(`Unknown curve ${curve}`);
}
}
/**
* Creates a key pair from an encoded key string.
* @param encodedKey The encoded key string.
* @returns {KeyPair} The key pair created from the encoded key string.
*/
static fromString(encodedKey) {
const parts = encodedKey.split(":");
if (parts.length === 2) {
switch (parts[0].toUpperCase()) {
case "ED25519":
return new KeyPairEd25519(parts[1]);
case "SECP256K1":
return new KeyPairSecp256k1(parts[1]);
default:
throw new Error(`Unknown curve: ${parts[0]}`);
}
} else {
throw new Error("Invalid encoded key format, must be <curve>:<encoded key>");
}
}
};
// node_modules/@near-js/transactions/lib/esm/signature.js
function resolveEnumKeyName2(keyType) {
switch (keyType) {
case KeyType.ED25519: {
return "ed25519Signature";
}
case KeyType.SECP256K1: {
return "secp256k1Signature";
}
default: {
throw Error(`unknown type ${keyType}`);
}
}
}
var Signature = class extends Enum {
constructor(signature) {
const keyName = resolveEnumKeyName2(signature.keyType);
super({ [keyName]: signature });
__publicField(this, "enum");
__publicField(this, "ed25519Signature");
__publicField(this, "secp256k1Signature");
this[keyName] = signature;
this.enum = keyName;
}
get signature() {
return this.ed25519Signature || this.secp256k1Signature;
}
get signatureType() {
return this.signature.keyType;
}
get data() {
return this.signature.data;
}
};
// node_modules/@near-js/providers/lib/esm/fetch_json.js
var import_exponential_backoff = __toESM(require_backoff(), 1);
var BACKOFF_MULTIPLIER = 1.5;
var RETRY_NUMBER = 10;
var RETRY_DELAY = 0;
function retryConfig(numOfAttempts = RETRY_NUMBER, timeMultiple = BACKOFF_MULTIPLIER, startingDelay = RETRY_DELAY) {
return {
numOfAttempts,
timeMultiple,
startingDelay,
retry: (e) => {
if ([503, 500, 408].includes(e.cause)) {
return true;
}
if (e.toString().includes("FetchError") || e.toString().includes("Failed to fetch")) {
return true;
}
return false;
}
};
}
var ProviderError = class extends Error {
constructor(message, options) {
super(message, options);
__publicField(this, "cause");
if (options.cause) {
this.cause = options.cause;
}
}
};
async function fetchJsonRpc(url, json, headers, retryConfig2) {
const response = await (0, import_exponential_backoff.backOff)(async () => {
const res = await fetch(url, {
method: "POST",
body: JSON.stringify(json),
headers: { ...headers, "Content-Type": "application/json" }
});
const { ok, status } = res;
if (status === 500) {
throw new ProviderError("Internal server error", { cause: status });
} else if (status === 408) {
throw new ProviderError("Timeout error", { cause: status });
} else if (status === 400) {
throw new ProviderError("Request validation error", { cause: status });
} else if (status === 503) {
throw new ProviderError(`${url} unavailable`, { cause: status });
}
if (!ok) {
throw new ProviderError(await res.text(), { cause: status });
}
return res;
}, retryConfig2);
if (!response) {
throw new TypedError(`Exceeded ${RETRY_NUMBER} attempts for ${url}.`, "RetriesExceeded");
}
return await response.json();
}
// node_modules/@near-js/providers/lib/esm/json-rpc-provider.js
var REQUEST_RETRY_NUMBER = 12;
var REQUEST_RETRY_WAIT = 500;
var REQUEST_RETRY_WAIT_BACKOFF = 1.5;
var _nextId = 123;
var JsonRpcProvider = class {
/**
* @param connectionInfo Connection info
*/
constructor(connectionInfo, options) {
/** @hidden */
__publicField(this, "connection");
/** @hidden */
__publicField(this, "options");
/** @hidden */
__publicField(this, "networkId");
this.connection = connectionInfo || { url: "" };
const defaultOptions = {
retries: REQUEST_RETRY_NUMBER,
wait: REQUEST_RETRY_WAIT,
backoff: REQUEST_RETRY_WAIT_BACKOFF
};
this.options = Object.assign({}, defaultOptions, options);
this.networkId = void 0;
}
async getNetworkId() {
if (this.networkId) return this.networkId;
const { chain_id } = await this.viewNodeStatus();
this.networkId = chain_id;
return this.networkId;
}
async getCurrentEpochSeatPrice() {
const { minimum_stake_ratio: minStakeRatio, protocol_version: protocolVersion } = await this.experimental_protocolConfig({ finality: "final" });
const { current_validators: currentValidators } = await this.viewValidators();
const maxNumberOfSeats = 300;
return findSeatPrice(currentValidators, maxNumberOfSeats, minStakeRatio, protocolVersion);
}
async getNextEpochSeatPrice() {
const { minimum_stake_ratio: minStakeRatio, protocol_version: protocolVersion } = await this.experimental_protocolConfig({ finality: "final" });
const { next_validators: nextValidators } = await this.viewValidators();
const maxNumberOfSeats = 300;
return findSeatPrice(nextValidators, maxNumberOfSeats, minStakeRatio, protocolVersion);
}
async viewAccessKey(accountId, publicKey, finalityQuery = { finality: "final" }) {
const data = await this.query({
...finalityQuery,
request_type: "view_access_key",
account_id: accountId,
public_key: publicKey.toString()
});
return {
...data,
nonce: BigInt(data.nonce)
};
}
async viewAccessKeyList(accountId, finalityQuery = { finality: "final" }) {
return this.query({
...finalityQuery,
request_type: "view_access_key_list",
account_id: accountId
});
}
async viewAccount(accountId, blockQuery = { finality: "final" }) {
const data = await this.query({
...blockQuery,
request_type: "view_account",
account_id: accountId
});
return {
...data,
amount: BigInt(data.amount),
locked: BigInt(data.locked)
};
}
async viewContractCode(contractId2, blockQuery = { finality: "final" }) {
const data = await this.query({
...blockQuery,
request_type: "view_code",
account_id: contractId2
});
return {
...data,
code: new Uint8Array(Buffer.from(data.code_base64, "base64"))
};
}
async viewContractState(contractId2, prefix, blockQuery = { finality: "final" }) {
const prefixBase64 = Buffer.from(prefix || "").toString("base64");
return this.query({
...blockQuery,
request_type: "view_state",
account_id: contractId2,
prefix_base64: prefixBase64
});
}
async callFunction(contractId2, method, args, blockQuery = { finality: "final" }) {
const argsBase64 = Buffer.from(JSON.stringify(args)).toString("base64");
const data = await this.query({
...blockQuery,
request_type: "call_function",
account_id: contractId2,
method_name: method,
args_base64: argsBase64
});
if (data.result.length === 0) {
return void 0;
}
return JSON.parse(Buffer.from(data.result).toString());
}
async callFunctionRaw(contractId2, method, args, blockQuery = { finality: "final" }) {
const argsBase64 = Buffer.from(JSON.stringify(args)).toString("base64");
return await this.query({
...blockQuery,
request_type: "call_function",
account_id: contractId2,
method_name: method,
args_base64: argsBase64
});
}
async viewBlock(blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("block", { block_id: blockId, finality });
}
async viewChunk(chunkId) {
return this.sendJsonRpc("chunk", [chunkId]);
}
async viewGasPrice(blockId) {
return this.sendJsonRpc("gas_price", [blockId || null]);
}
async viewNodeStatus() {
return this.sendJsonRpc("status", []);
}
async viewValidators(blockId) {
return this.sendJsonRpc("validators", [blockId || null]);
}
async viewTransactionStatus(txHash, accountId, waitUntil) {
const encodedTxHash = typeof txHash === "string" ? txHash : baseEncode(txHash);
return this.sendJsonRpc("tx", {
tx_hash: encodedTxHash,
sender_account_id: accountId,
wait_until: waitUntil
});
}
async viewTransactionStatusWithReceipts(txHash, accountId, waitUntil) {
const encodedTxHash = typeof txHash === "string" ? txHash : baseEncode(txHash);
return this.sendJsonRpc("EXPERIMENTAL_tx_status", {
tx_hash: encodedTxHash,
sender_account_id: accountId,
wait_until: waitUntil
});
}
async viewTransactionReceipt(receiptId) {
return this.sendJsonRpc("EXPERIMENTAL_receipt", {
receipt_id: receiptId
});
}
/**
* Gets the RPC's status
* @see [https://docs.near.org/docs/develop/front-end/rpc#general-validator-status](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*/
async status() {
return this.sendJsonRpc("status", []);
}
/**
* Sends a signed transaction to the RPC
*
* @param signedTransaction The signed transaction being sent
* @param waitUntil
*/
async sendTransactionUntil(signedTransaction, waitUntil) {
const bytes = encodeTransaction(signedTransaction);
return this.sendJsonRpc("send_tx", { signed_tx_base64: Buffer.from(bytes).toString("base64"), wait_until: waitUntil });
}
/**
* Sends a signed transaction to the RPC and waits until transaction is fully complete
* @see [https://docs.near.org/docs/develop/front-end/rpc#send-transaction-await](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*
* @param signedTransaction The signed transaction being sent
*/
async sendTransaction(signedTransaction) {
return this.sendTransactionUntil(signedTransaction, "EXECUTED_OPTIMISTIC");
}
/**
* Sends a signed transaction to the RPC and immediately returns transaction hash
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#send-transaction-async)
* @param signedTransaction The signed transaction being sent
* @returns {Promise<FinalExecutionOutcome>}
*/
async sendTransactionAsync(signedTransaction) {
return this.sendTransactionUntil(signedTransaction, "NONE");
}
/**
* Gets a transaction's status from the RPC
* @see [https://docs.near.org/docs/develop/front-end/rpc#transaction-status](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*
* @param txHash A transaction hash as either a Uint8Array or a base58 encoded string
* @param accountId The NEAR account that signed the transaction
* @param waitUntil
*/
async txStatus(txHash, accountId, waitUntil = "EXECUTED_OPTIMISTIC") {
if (typeof txHash === "string") {
return this.txStatusString(txHash, accountId, waitUntil);
} else {
return this.txStatusUint8Array(txHash, accountId, waitUntil);
}
}
async txStatusUint8Array(txHash, accountId, waitUntil) {
return this.sendJsonRpc("tx", { tx_hash: baseEncode(txHash), sender_account_id: accountId, wait_until: waitUntil });
}
async txStatusString(txHash, accountId, waitUntil) {
return this.sendJsonRpc("tx", { tx_hash: txHash, sender_account_id: accountId, wait_until: waitUntil });
}
/**
* Gets a transaction's status from the RPC with receipts
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#transaction-status-with-receipts)
* @param txHash The hash of the transaction
* @param accountId The NEAR account that signed the transaction
* @param waitUntil
* @returns {Promise<FinalExecutionOutcome>}
*/
async txStatusReceipts(txHash, accountId, waitUntil = "EXECUTED_OPTIMISTIC") {
if (typeof txHash === "string") {
return this.sendJsonRpc("EXPERIMENTAL_tx_status", { tx_hash: txHash, sender_account_id: accountId, wait_until: waitUntil });
} else {
return this.sendJsonRpc("EXPERIMENTAL_tx_status", { tx_hash: baseEncode(txHash), sender_account_id: accountId, wait_until: waitUntil });
}
}
/**
* Query the RPC by passing an {@link "@near-js/types".provider/request.RpcQueryRequest | RpcQueryRequest }
* @see [https://docs.near.org/api/rpc/contracts](https://docs.near.org/api/rpc/contracts)
*
* @typeParam T the shape of the returned query response
*/
async query(...args) {
let result;
if (args.length === 1) {
const { block_id, blockId, ...otherParams } = args[0];
result = await this.sendJsonRpc("query", { ...otherParams, block_id: block_id || blockId });
} else {
const [path, data] = args;
result = await this.sendJsonRpc("query", [path, data]);
}
if (result && result.error) {
throw new TypedError(
`Querying failed: ${result.error}.
${JSON.stringify(result, null, 2)}`,
getErrorTypeFromErrorMessage(result.error, result.error.name)
);
}
return result;
}
/**
* Query for block info from the RPC
* pass block_id OR finality as blockQuery, not both
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*
* @param blockQuery {@link BlockReference} (passing a {@link BlockId} is deprecated)
*/
async block(blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("block", { block_id: blockId, finality });
}
/**
* Query changes in block from the RPC
* pass block_id OR finality as blockQuery, not both
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*/
async blockChanges(blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes_in_block", { block_id: blockId, finality });
}
/**
* Queries for details about a specific chunk appending details of receipts and transactions to the same chunk data provided by a block
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*
* @param chunkId Hash of a chunk ID or shard ID
*/
async chunk(chunkId) {
return this.sendJsonRpc("chunk", [chunkId]);
}
/**
* Query validators of the epoch defined by the given block id.
* @see [https://docs.near.org/api/rpc/network#validation-status](https://docs.near.org/api/rpc/network#validation-status)
*
* @param blockId Block hash or height, or null for latest.
*/
async validators(blockId) {
return this.sendJsonRpc("validators", [blockId]);
}
/**
* Gets the protocol config at a block from RPC
*
* @param blockReference specifies the block to get the protocol config for
*/
async experimental_protocolConfig(blockReference) {
const { blockId, ...otherParams } = blockReference;
return await this.sendJsonRpc("EXPERIMENTAL_protocol_config", { ...otherParams, block_id: blockId });
}
/**
* Gets a light client execution proof for verifying execution outcomes
* @see [https://github.com/nearprotocol/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-proof](https://github.com/nearprotocol/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-proof)
*/
async lightClientProof(request) {
return await this.sendJsonRpc("EXPERIMENTAL_light_client_proof", request);
}
/**
* Returns the next light client block as far in the future as possible from the last known hash
* to still be able to validate from that hash. This will either return the last block of the
* next epoch, or the last final known block.
*
* @see [https://github.com/near/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-block](https://github.com/near/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-block)
*/
async nextLightClientBlock(request) {
return await this.sendJsonRpc("next_light_client_block", request);
}
/**
* Gets access key changes for a given array of accountIds
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-access-key-changes-all)
* @returns {Promise<ChangeResult>}
*/
async accessKeyChanges(accountIdArray, blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes", {
changes_type: "all_access_key_changes",
account_ids: accountIdArray,
block_id: blockId,
finality
});
}
/**
* Gets single access key changes for a given array of access keys
* pass block_id OR finality as blockQuery, not both
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-access-key-changes-single)
* @returns {Promise<ChangeResult>}
*/
async singleAccessKeyChanges(accessKeyArray, blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes", {
changes_type: "single_access_key_changes",
keys: accessKeyArray,
block_id: blockId,
finality
});
}
/**
* Gets account changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-account-changes)
* @returns {Promise<ChangeResult>}
*/
async accountChanges(accountIdArray, blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes", {
changes_type: "account_changes",
account_ids: accountIdArray,
block_id: blockId,
finality
});
}
/**
* Gets contract state changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* Note: If you pass a keyPrefix it must be base64 encoded
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-contract-state-changes)
* @returns {Promise<ChangeResult>}
*/
async contractStateChanges(accountIdArray, blockQuery, keyPrefix = "") {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes", {
changes_type: "data_changes",
account_ids: accountIdArray,
key_prefix_base64: keyPrefix,
block_id: blockId,
finality
});
}
/**
* Gets contract code changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* Note: Change is returned in a base64 encoded WASM file
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-contract-code-changes)
* @returns {Promise<ChangeResult>}
*/
async contractCodeChanges(accountIdArray, blockQuery) {
const { finality } = blockQuery;
const { blockId } = blockQuery;
return this.sendJsonRpc("EXPERIMENTAL_changes", {
changes_type: "contract_code_changes",
account_ids: accountIdArray,
block_id: blockId,
finality
});
}
/**
* Returns gas price for a specific block_height or block_hash.
* @see [https://docs.near.org/api/rpc/gas](https://docs.near.org/api/rpc/gas)
*
* @param blockId Block hash or height, or null for latest.
*/
async gasPrice(blockId) {
return await this.sendJsonRpc("gas_price", [blockId]);
}
/**
* Directly call the RPC specifying the method and params
*
* @param method RPC method
* @param params Parameters to the method
*/
async sendJsonRpc(method, params) {
const request = {
method,
params,
id: _nextId++,
jsonrpc: "2.0"
};
const response = await fetchJsonRpc(this.connection.url, request, this.connection.headers, retryConfig(this.options.retries, this.options.backoff, this.options.wait));
if (response.error) {
if (typeof response.error.data === "object") {
if (typeof response.error.data.error_message === "string" && typeof response.error.data.error_type === "string") {
throw new TypedError(response.error.data.error_message, response.error.data.error_type);
}
throw parseRpcError(response.error.data);
} else {
const errorMessage = `[${response.error.code}] ${response.error.message}: ${response.error.data}`;
const errorType = getErrorTypeFromErrorMessage(response.error.data, "");
if (errorType) {
throw new TypedError(formatError(errorType, params), errorType);
}
throw new TypedError(errorMessage, response.error.name);
}
} else if (typeof response.result?.error === "string") {
const errorType = getErrorTypeFromErrorMessage(response.result.error, "");
if (errorType) {
throw new ServerError(formatError(errorType, params), errorType);
}
}
const { result } = response;
if (typeof result === "undefined") {
throw new TypedError(
`Exceeded ${this.options.retries} attempts for request to ${method}.`,
"RetriesExceeded"
);
}
return result;
}
};
// node_modules/@near-js/providers/lib/esm/failover-rpc-provider.js
var FailoverRpcProvider = class {
/**
* @param providers list of providers
*/
constructor(providers) {
/** @hidden */
__publicField(this, "providers");
__publicField(this, "currentProviderIndex");
if (providers.length === 0) {
throw new Error("At least one provider must be specified");
}
this.providers = providers;
this.currentProviderIndex = 0;
}
switchToNextProvider() {
if (this.providers.length === 1) return;
if (this.providers.length - 1 <= this.currentProviderIndex) {
this.currentProviderIndex = 0;
} else {
this.currentProviderIndex += 1;
}
Logger.debug(
`Switched to provider at the index ${this.currentProviderIndex}`
);
}
get currentProvider() {
const provider2 = this.providers[this.currentProviderIndex];
if (!provider2)
throw new Error(
`Provider wasn't found at index ${this.currentProviderIndex}`
);
return provider2;
}
async withBackoff(getResult) {
for (let i = 0; i < this.providers.length; i++) {
try {
const result = await getResult(this.currentProvider);
if (result) return result;
} catch (e) {
console.error(e);
this.switchToNextProvider();
}
}
throw new TypedError(
`Exceeded ${this.providers.length} providers to execute request`,
"RetriesExceeded"
);
}
/**
* Gets the RPC's status
* @see [https://docs.near.org/docs/develop/front-end/rpc#general-validator-status](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*/
async status() {
return this.withBackoff((currentProvider) => currentProvider.status());
}
async getNetworkId() {
return this.withBackoff((currentProvider) => currentProvider.getNetworkId());
}
async getCurrentEpochSeatPrice() {
return this.withBackoff((currentProvider) => currentProvider.getCurrentEpochSeatPrice());
}
async getNextEpochSeatPrice() {
return this.withBackoff((currentProvider) => currentProvider.getNextEpochSeatPrice());
}
async viewAccessKey(accountId, publicKey, finalityQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewAccessKey(accountId, publicKey, finalityQuery));
}
async viewAccessKeyList(accountId, finalityQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewAccessKeyList(accountId, finalityQuery));
}
async viewAccount(accountId, blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewAccount(accountId, blockQuery));
}
async viewContractCode(accountId, blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewContractCode(accountId, blockQuery));
}
async viewContractState(accountId, prefix, blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewContractState(accountId, prefix, blockQuery));
}
async callFunction(accountId, method, args, blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.callFunction(accountId, method, args, blockQuery));
}
async callFunctionRaw(accountId, method, args, blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.callFunctionRaw(accountId, method, args, blockQuery));
}
async viewBlock(blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.viewBlock(blockQuery));
}
async viewChunk(chunkId) {
return this.withBackoff((currentProvider) => currentProvider.viewChunk(chunkId));
}
async viewGasPrice(blockId) {
return this.withBackoff((currentProvider) => currentProvider.viewGasPrice(blockId));
}
async viewNodeStatus() {
return this.withBackoff((currentProvider) => currentProvider.viewNodeStatus());
}
async viewValidators(blockId) {
return this.withBackoff((currentProvider) => currentProvider.viewValidators(blockId));
}
async viewTransactionStatus(txHash, accountId, waitUntil) {
return this.withBackoff((currentProvider) => currentProvider.viewTransactionStatus(txHash, accountId, waitUntil));
}
async viewTransactionStatusWithReceipts(txHash, accountId, waitUntil) {
return this.withBackoff((currentProvider) => currentProvider.viewTransactionStatusWithReceipts(txHash, accountId, waitUntil));
}
async viewTransactionReceipt(receiptId) {
return this.withBackoff((currentProvider) => currentProvider.viewTransactionReceipt(receiptId));
}
async sendTransactionUntil(signedTransaction, waitUntil) {
return this.withBackoff((currentProvider) => currentProvider.sendTransactionUntil(signedTransaction, waitUntil));
}
/**
* Sends a signed transaction to the RPC and waits until transaction is fully complete
* @see [https://docs.near.org/docs/develop/front-end/rpc#send-transaction-await](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*
* @param signedTransaction The signed transaction being sent
*/
async sendTransaction(signedTransaction) {
return this.withBackoff(
(currentProvider) => currentProvider.sendTransaction(signedTransaction)
);
}
/**
* Sends a signed transaction to the RPC and immediately returns transaction hash
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#send-transaction-async)
* @param signedTransaction The signed transaction being sent
* @returns {Promise<FinalExecutionOutcome>}
*/
async sendTransactionAsync(signedTransaction) {
return this.withBackoff(
(currentProvider) => currentProvider.sendTransactionAsync(signedTransaction)
);
}
/**
* Gets a transaction's status from the RPC
* @see [https://docs.near.org/docs/develop/front-end/rpc#transaction-status](https://docs.near.org/docs/develop/front-end/rpc#general-validator-status)
*
* @param txHash A transaction hash as either a Uint8Array or a base58 encoded string
* @param accountId The NEAR account that signed the transaction
*/
async txStatus(txHash, accountId, waitUntil) {
return this.withBackoff(
(currentProvider) => currentProvider.txStatus(txHash, accountId, waitUntil)
);
}
/**
* Gets a transaction's status from the RPC with receipts
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#transaction-status-with-receipts)
* @param txHash The hash of the transaction
* @param accountId The NEAR account that signed the transaction
* @returns {Promise<FinalExecutionOutcome>}
*/
async txStatusReceipts(txHash, accountId, waitUntil) {
return this.withBackoff(
(currentProvider) => currentProvider.txStatusReceipts(txHash, accountId, waitUntil)
);
}
async query(paramsOrPath, data) {
if (data) {
return this.withBackoff(
(currentProvider) => currentProvider.query(paramsOrPath, data)
);
}
return this.withBackoff(
(currentProvider) => currentProvider.query(paramsOrPath)
);
}
/**
* Query for block info from the RPC
* pass block_id OR finality as blockQuery, not both
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*
* @param blockQuery {@link BlockReference} (passing a {@link BlockId} is deprecated)
*/
async block(blockQuery) {
return this.withBackoff((currentProvider) => currentProvider.block(blockQuery));
}
/**
* Query changes in block from the RPC
* pass block_id OR finality as blockQuery, not both
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*/
async blockChanges(blockQuery) {
return this.withBackoff(
(currentProvider) => currentProvider.blockChanges(blockQuery)
);
}
/**
* Queries for details about a specific chunk appending details of receipts and transactions to the same chunk data provided by a block
* @see [https://docs.near.org/api/rpc/block-chunk](https://docs.near.org/api/rpc/block-chunk)
*
* @param chunkId Hash of a chunk ID or shard ID
*/
async chunk(chunkId) {
return this.withBackoff((currentProvider) => currentProvider.chunk(chunkId));
}
/**
* Query validators of the epoch defined by the given block id.
* @see [https://docs.near.org/api/rpc/network#validation-status](https://docs.near.org/api/rpc/network#validation-status)
*
* @param blockId Block hash or height, or null for latest.
*/
async validators(blockId) {
return this.withBackoff((currentProvider) => currentProvider.validators(blockId));
}
/**
* Gets the protocol config at a block from RPC
*
* @param blockReference specifies the block to get the protocol config for
*/
async experimental_protocolConfig(blockReference) {
return this.withBackoff(
(currentProvider) => currentProvider.experimental_protocolConfig(blockReference)
);
}
/**
* Gets a light client execution proof for verifying execution outcomes
* @see [https://github.com/nearprotocol/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-proof](https://github.com/nearprotocol/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-proof)
*/
async lightClientProof(request) {
return this.withBackoff(
(currentProvider) => currentProvider.lightClientProof(request)
);
}
/**
* Returns the next light client block as far in the future as possible from the last known hash
* to still be able to validate from that hash. This will either return the last block of the
* next epoch, or the last final known block.
*
* @see [https://github.com/near/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-block](https://github.com/near/NEPs/blob/master/specs/ChainSpec/LightClient.md#light-client-block)
*/
async nextLightClientBlock(request) {
return this.withBackoff(
(currentProvider) => currentProvider.nextLightClientBlock(request)
);
}
/**
* Gets access key changes for a given array of accountIds
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-access-key-changes-all)
* @returns {Promise<ChangeResult>}
*/
async accessKeyChanges(accountIdArray, blockQuery) {
return this.withBackoff(
(currentProvider) => currentProvider.accessKeyChanges(accountIdArray, blockQuery)
);
}
/**
* Gets single access key changes for a given array of access keys
* pass block_id OR finality as blockQuery, not both
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-access-key-changes-single)
* @returns {Promise<ChangeResult>}
*/
async singleAccessKeyChanges(accessKeyArray, blockQuery) {
return this.withBackoff(
(currentProvider) => currentProvider.singleAccessKeyChanges(
accessKeyArray,
blockQuery
)
);
}
/**
* Gets account changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-account-changes)
* @returns {Promise<ChangeResult>}
*/
async accountChanges(accountIdArray, blockQuery) {
return this.withBackoff(
(currentProvider) => currentProvider.accountChanges(accountIdArray, blockQuery)
);
}
/**
* Gets contract state changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* Note: If you pass a keyPrefix it must be base64 encoded
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-contract-state-changes)
* @returns {Promise<ChangeResult>}
*/
async contractStateChanges(accountIdArray, blockQuery, keyPrefix = "") {
return this.withBackoff(
(currentProvider) => currentProvider.contractStateChanges(
accountIdArray,
blockQuery,
keyPrefix
)
);
}
/**
* Gets contract code changes for a given array of accountIds
* pass block_id OR finality as blockQuery, not both
* Note: Change is returned in a base64 encoded WASM file
* See [docs for more info](https://docs.near.org/docs/develop/front-end/rpc#view-contract-code-changes)
* @returns {Promise<ChangeResult>}
*/
async contractCodeChanges(accountIdArray, blockQuery) {
return this.withBackoff(
(currentProvider) => currentProvider.contractCodeChanges(accountIdArray, blockQuery)
);
}
/**
* Returns gas price for a specific block_height or block_hash.
* @see [https://docs.near.org/api/rpc/gas](https://docs.near.org/api/rpc/gas)
*
* @param blockId Block hash or height, or null for latest.
*/
async gasPrice(blockId) {
return this.withBackoff((currentProvider) => currentProvider.gasPrice(blockId));
}
};
// src/nearProvider.ts
function getProvider(providers) {
const nearRpcProvidersJson = providers ? JSON.parse(providers) : { nearRpcProviders: null };
const networkId2 = "testnet";
function createDefaultProvider() {
return new JsonRpcProvider(
{
url: networkId2 === "testnet" ? "https://test.rpc.fastnear.com" : "https://free.rpc.fastnear.com"
},
{
retries: 3,
backoff: 2,
wait: 1e3
}
);
}
let provider2;
if (nearRpcProvidersJson.nearRpcProviders) {
console.log("Using custom RPC providers");
const providers2 = nearRpcProvidersJson.nearRpcProviders.map(
(config3) => new JsonRpcProvider(
config3.connectionInfo,
config3.options || {}
)
);
provider2 = new FailoverRpcProvider(providers2);
} else {
console.log("Using default RPC provider");
provider2 = createDefaultProvider();
}
console.log("near providers", provider2.providers);
return provider2;
}
// node_modules/@noble/hashes/esm/sha256.js
var SHA256_K = /* @__PURE__ */ new Uint32Array([
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
]);
var SHA256_IV = /* @__PURE__ */ new Uint32Array([
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
]);
var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
var SHA256 = class extends HashMD {
constructor() {
super(64, 32, 8, false);
this.A = SHA256_IV[0] | 0;
this.B = SHA256_IV[1] | 0;
this.C = SHA256_IV[2] | 0;
this.D = SHA256_IV[3] | 0;
this.E = SHA256_IV[4] | 0;
this.F = SHA256_IV[5] | 0;
this.G = SHA256_IV[6] | 0;
this.H = SHA256_IV[7] | 0;
}
get() {
const { A, B, C, D, E, F, G, H } = this;
return [A, B, C, D, E, F, G, H];
}
// prettier-ignore
set(A, B, C, D, E, F, G, H) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
this.E = E | 0;
this.F = F | 0;
this.G = G | 0;
this.H = H | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4)
SHA256_W[i] = view.getUint32(offset, false);
for (let i = 16; i < 64; i++) {
const W15 = SHA256_W[i - 15];
const W2 = SHA256_W[i - 2];
const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
}
let { A, B, C, D, E, F, G, H } = this;
for (let i = 0; i < 64; i++) {
const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
const T2 = sigma0 + Maj(A, B, C) | 0;
H = G;
G = F;
F = E;
E = D + T1 | 0;
D = C;
C = B;
B = A;
A = T1 + T2 | 0;
}
A = A + this.A | 0;
B = B + this.B | 0;
C = C + this.C | 0;
D = D + this.D | 0;
E = E + this.E | 0;
F = F + this.F | 0;
G = G + this.G | 0;
H = H + this.H | 0;
this.set(A, B, C, D, E, F, G, H);
}
roundClean() {
SHA256_W.fill(0);
}
destroy() {
this.set(0, 0, 0, 0, 0, 0, 0, 0);
this.buffer.fill(0);
}
};
var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
// node_modules/@near-js/signers/lib/esm/signer.js
var Nep413MessageSchema = {
struct: {
message: "string",
nonce: { array: { type: "u8", len: 32 } },
recipient: "string",
callbackUrl: { option: "string" }
}
};
var Signer = class {
};
// node_modules/@near-js/signers/lib/esm/key_pair_signer.js
var KeyPairSigner = class _KeyPairSigner extends Signer {
constructor(key) {
super();
__publicField(this, "key");
this.key = key;
}
static fromSecretKey(encodedKey) {
const key = KeyPair.fromString(encodedKey);
return new _KeyPairSigner(key);
}
async getPublicKey() {
return this.key.getPublicKey();
}
async signNep413Message(message, accountId, recipient, nonce, callbackUrl) {
if (nonce.length !== 32)
throw new Error("Nonce must be exactly 32 bytes long");
const pk = this.key.getPublicKey();
const PREFIX = 2147484061;
const serializedPrefix = serialize("u32", PREFIX);
const params = {
message,
recipient,
nonce,
callbackUrl
};
const serializedParams = serialize(Nep413MessageSchema, params);
const serializedMessage = new Uint8Array(
serializedPrefix.length + serializedParams.length
);
serializedMessage.set(serializedPrefix);
serializedMessage.set(serializedParams, serializedPrefix.length);
const hash = new Uint8Array(sha256(serializedMessage));
const { signature } = this.key.sign(hash);
return {
accountId,
publicKey: pk,
signature
};
}
async signTransaction(transaction) {
const pk = this.key.getPublicKey();
if (transaction.publicKey.toString() !== pk.toString())
throw new Error("The public key doesn't match the signer's key");
const message = encodeTransaction(transaction);
const hash = new Uint8Array(sha256(message));
const { signature } = this.key.sign(hash);
const signedTx = new SignedTransaction({
transaction,
signature: new Signature({
keyType: transaction.publicKey.ed25519Key ? KeyType.ED25519 : KeyType.SECP256K1,
data: signature
})
});
return [hash, signedTx];
}
async signDelegateAction(delegateAction) {
const pk = this.key.getPublicKey();
if (delegateAction.publicKey.toString() !== pk.toString())
throw new Error("The public key doesn't match the signer's key");
const message = encodeDelegateAction(delegateAction);
const hash = new Uint8Array(sha256(message));
const { signature } = this.key.sign(hash);
const signedDelegate2 = new SignedDelegate({
delegateAction,
signature: new Signature({
keyType: pk.keyType,
data: signature
})
});
return [hash, signedDelegate2];
}
};
// node_modules/@near-js/accounts/lib/esm/connection.js
var import_depd2 = __toESM(require_depd(), 1);
function getProvider2(config3) {
switch (config3.type) {
case void 0:
return config3;
case "JsonRpcProvider":
return new JsonRpcProvider({ ...config3.args });
case "FailoverRpcProvider": {
const providers = (config3?.args || []).map(
(arg) => new JsonRpcProvider(arg)
);
return new FailoverRpcProvider(providers);
}
default:
throw new Error(`Unknown provider type ${config3.type}`);
}
}
function getSigner(config3) {
switch (config3.type) {
case void 0:
return config3;
case "KeyPairSigner": {
return new KeyPairSigner(config3.keyPair);
}
default:
throw new Error(`Unknown signer type ${config3.type}`);
}
}
var Connection = class _Connection {
constructor(networkId2, provider2, signer2) {
__publicField(this, "networkId");
__publicField(this, "provider");
__publicField(this, "signer");
const deprecate = (0, import_depd2.default)("new Connection(networkId, provider, signer)");
deprecate("`Connection` is no longer used anywhere, please switch to constructing `Account` without it - use `new Account(accountId, provider, signer)`");
this.networkId = networkId2;
this.provider = provider2;
this.signer = signer2;
}
getConnection() {
return this;
}
/**
* @param config Contains connection info details
*/
static fromConfig(config3) {
const provider2 = getProvider2(config3.provider);
const signer2 = getSigner(config3.signer);
return new _Connection(
config3.networkId,
provider2,
signer2
);
}
};
// node_modules/@near-js/accounts/lib/esm/utils.js
function parseJsonFromRawResponse(response) {
return JSON.parse(Buffer.from(response).toString());
}
function bytesJsonStringify(input) {
return Buffer.from(JSON.stringify(input));
}
function validateArgs(args) {
const isUint8Array = args.byteLength !== void 0 && args.byteLength === args.length;
if (isUint8Array) {
return;
}
if (Array.isArray(args) || typeof args !== "object") {
throw new PositionalArgsError();
}
}
async function viewState(connection, accountId, prefix, blockQuery = { finality: "optimistic" }) {
const { values } = await connection.provider.query({
request_type: "view_state",
...blockQuery,
account_id: accountId,
prefix_base64: Buffer.from(prefix).toString("base64")
});
return values.map(({ key, value }) => ({
key: Buffer.from(key, "base64"),
value: Buffer.from(value, "base64")
}));
}
async function viewFunction(connection, {
contractId: contractId2,
methodName,
args = {},
parse = parseJsonFromRawResponse,
stringify = bytesJsonStringify,
blockQuery = { finality: "optimistic" }
}) {
validateArgs(args);
const encodedArgs = stringify(args);
const result = await connection.provider.query({
request_type: "call_function",
...blockQuery,
account_id: contractId2,
method_name: methodName,
args_base64: encodedArgs.toString("base64")
});
if (result.logs) {
printTxOutcomeLogs({ contractId: contractId2, logs: result.logs });
}
return result.result && result.result.length > 0 && parse(Buffer.from(result.result));
}
// node_modules/@near-js/tokens/lib/esm/ft/format.js
var MAX_NOMINATION_EXP = 24;
function formatAmount(units, fracDigits) {
units = cleanupUnits(units);
const wholeStr = units.substring(0, units.length - fracDigits) || "0";
const fractionStr = units.substring(units.length - fracDigits).substring(0, fracDigits).padStart(fracDigits, "0");
return trimTrailingZeroes2(`${wholeStr}.${fractionStr}`);
}
function parseAmount(amount, fracDigits) {
amount = cleanupAmount(amount);
const split2 = amount.split(".");
if (split2.length > 2) {
throw new Error(
`Cannot parse amount '${amount}' as it contains more than a single dot`
);
}
const wholePart = split2[0];
const fracPart = split2[1] || "";
if (fracPart.length > MAX_NOMINATION_EXP) {
throw new Error(
`Cannot parse amount '${amount}' as it exceeds maximum decimal precision of ${MAX_NOMINATION_EXP}`
);
}
return trimLeadingZeroes(
wholePart + fracPart.substring(0, fracDigits).padEnd(fracDigits, "0")
);
}
function cleanupAmount(amount) {
return amount.replace(/,/g, ".").trim();
}
function trimTrailingZeroes2(value) {
return value.replace(/\.?0*$/, "");
}
function trimLeadingZeroes(value) {
value = value.replace(/^0+/, "");
if (value === "") {
return "0";
}
return value;
}
function cleanupUnits(amount) {
return BigInt(amount).toString();
}
// node_modules/@near-js/tokens/lib/esm/ft/index.js
var BaseFT = class {
constructor(metadata) {
__publicField(this, "metadata");
this.metadata = metadata;
}
/**
* Converts a decimal number to indivisible units
*
* @param amount The amount in decimal format (e.g. "1.234")
* @returns The amount in indivisible units (e.g. "1234")
*/
toUnits(amount) {
const units = parseAmount(amount.toString(), this.metadata.decimals);
return BigInt(units);
}
/**
* Converts indivisible units to a decimal number (represented as a string)
*
* @param units The amount in indivisible units (e.g. "1234")
* @returns The amount as a decimal string (e.g. "1.234")
*/
toDecimal(amount) {
return formatAmount(amount, this.metadata.decimals);
}
};
var NativeToken = class extends BaseFT {
constructor(metadata) {
super(metadata);
}
async transfer({ from, receiverId, amount }) {
return from.signAndSendTransaction({
receiverId,
actions: [{ transfer: { deposit: amount.toString() } }]
});
}
async getBalance(account) {
const { balance: { available } } = await account.getState();
return available;
}
};
var NEAR = new NativeToken({
name: "NEAR",
decimals: 24,
symbol: "NEAR",
icon: "data:image/svg+xml,%3Csvg%20width%3D%2232%22%20height%3D%2232%22%20viewBox%3D%220%200%2032%2032%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Ccircle%20cx%3D%2216%22%20cy%3D%2216%22%20r%3D%2216%22%20fill%3D%22white%22%3E%3C%2Fcircle%3E%3Cg%20clip-path%3D%22url(%23clip0000000003)%22%3E%3Cpath%20d%3D%22M20.8422%208.84471L17.4978%2013.776C17.4501%2013.847%2017.43%2013.9328%2017.4411%2014.0174C17.4522%2014.102%2017.4938%2014.1798%2017.5582%2014.2363C17.6225%2014.2928%2017.7053%2014.3243%2017.7913%2014.3249C17.8772%2014.3254%2017.9604%2014.2951%2018.0256%2014.2395L21.3178%2011.4036C21.3371%2011.3865%2021.361%2011.3753%2021.3866%2011.3714C21.4122%2011.3675%2021.4383%2011.3711%2021.4619%2011.3818C21.4855%2011.3924%2021.5054%2011.4096%2021.5193%2011.4314C21.5331%2011.4531%2021.5403%2011.4783%2021.54%2011.504V20.3824C21.54%2020.4095%2021.5316%2020.4361%2021.5158%2020.4583C21.5001%2020.4806%2021.4779%2020.4975%2021.4522%2020.5068C21.4265%2020.516%2021.3985%2020.5172%2021.3721%2020.5102C21.3456%2020.5031%2021.322%2020.4882%2021.3044%2020.4673L11.3533%208.63726C11.1933%208.44956%2010.994%208.29873%2010.7693%208.19525C10.5446%208.09178%2010.2999%208.03815%2010.0522%208.03809H9.70444C9.2524%208.03809%208.81887%208.21642%208.49922%208.53386C8.17957%208.8513%208%209.28185%208%209.73078V22.2351C8%2022.684%208.17957%2023.1145%208.49922%2023.432C8.81887%2023.7494%209.2524%2023.9277%209.70444%2023.9277V23.9277C9.99591%2023.9278%2010.2825%2023.8537%2010.537%2023.7125C10.7914%2023.5713%2011.0051%2023.3677%2011.1578%2023.1211L14.5022%2018.1898C14.5499%2018.1188%2014.57%2018.033%2014.5589%2017.9484C14.5478%2017.8638%2014.5062%2017.7861%2014.4418%2017.7295C14.3775%2017.673%2014.2947%2017.6415%2014.2087%2017.641C14.1228%2017.6404%2014.0396%2017.6707%2013.9744%2017.7264L10.6822%2020.5622C10.6629%2020.5794%2010.639%2020.5906%2010.6134%2020.5944C10.5878%2020.5983%2010.5617%2020.5947%2010.5381%2020.5841C10.5145%2020.5734%2010.4946%2020.5562%2010.4807%2020.5345C10.4669%2020.5128%2010.4597%2020.4875%2010.46%2020.4618V11.5813C10.46%2011.5541%2010.4684%2011.5276%2010.4842%2011.5053C10.4999%2011.483%2010.5221%2011.4661%2010.5478%2011.4568C10.5735%2011.4476%2010.6015%2011.4464%2010.6279%2011.4534C10.6544%2011.4605%2010.678%2011.4755%2010.6956%2011.4963L20.6456%2023.3286C20.8056%2023.5163%2021.0049%2023.6671%2021.2296%2023.7706C21.4543%2023.874%2021.699%2023.9277%2021.9467%2023.9277H22.2944C22.5184%2023.9279%2022.7401%2023.8842%2022.947%2023.7992C23.154%2023.7142%2023.342%2023.5895%2023.5004%2023.4324C23.6588%2023.2752%2023.7844%2023.0885%2023.8702%2022.8831C23.9559%2022.6776%2024%2022.4574%2024%2022.2351V9.73078C24%209.28185%2023.8204%208.8513%2023.5008%208.53386C23.1811%208.21642%2022.7476%208.03809%2022.2956%208.03809C22.0041%208.03801%2021.7175%208.11211%2021.4631%208.25332C21.2086%208.39453%2020.9949%208.59814%2020.8422%208.84471V8.84471Z%22%20fill%3D%22black%22%3E%3C%2Fpath%3E%3C%2Fg%3E%3Cdefs%3E%3CclipPath%20id%3D%22clip00033%22%3E%3Crect%20width%3D%2216%22%20height%3D%2216%22%20fill%3D%22black%22%20transform%3D%22translate(8%207.9834)%22%3E%3C%2Frect%3E%3C%2FclipPath%3E%3C%2Fdefs%3E%3C%2Fsvg%3E"
});
// node_modules/@near-js/accounts/lib/esm/account.js
var {
addKey: addKey3,
createAccount: createAccount3,
deleteAccount: deleteAccount3,
deleteKey: deleteKey3,
deployContract: deployContract3,
deployGlobalContract: deployGlobalContract3,
fullAccessKey: fullAccessKey2,
functionCall: functionCall3,
functionCallAccessKey: functionCallAccessKey2,
transfer: transfer3,
useGlobalContract: useGlobalContract3
} = actionCreators;
var DEFAULT_FINALITY = process.env.DEFAULT_FINALITY || "near-final";
var DEFAULT_WAIT_STATUS = "EXECUTED_OPTIMISTIC";
var Account = class _Account {
constructor(accountId, provider2, signer2) {
__publicField(this, "accountId");
__publicField(this, "provider");
__publicField(this, "signer");
/** @hidden */
__publicField(this, "accessKeyByPublicKeyCache", {});
this.accountId = accountId;
this.provider = provider2;
this.signer = signer2;
}
/**
* Allows to set the signer used to control the account
*
* @param signer holds the private key and can sign Transactions
*/
setSigner(signer2) {
this.signer = signer2;
}
getSigner() {
return this.signer;
}
/**
* Returns an overview of the account's state, including the account's
* balance, storage usage, and code hash
*/
async getState() {
const protocolConfig = await this.provider.experimental_protocolConfig({
finality: DEFAULT_FINALITY
});
const state = await this.provider.viewAccount(this.accountId, {
finality: DEFAULT_FINALITY
});
const costPerByte = BigInt(
protocolConfig.runtime_config.storage_amount_per_byte
);
const usedOnStorage = BigInt(state.storage_usage) * costPerByte;
const locked = BigInt(state.locked);
const total = BigInt(state.amount) + locked;
const available = total - (locked > usedOnStorage ? locked : usedOnStorage);
return {
balance: {
total,
usedOnStorage,
locked,
available
},
storageUsage: state.storage_usage,
codeHash: state.code_hash
};
}
/**
* Calls {@link Provider.viewAccessKey} to retrieve information for a
* specific key in the account
*/
async getAccessKey(publicKey) {
return this.provider.viewAccessKey(this.accountId, publicKey, {
finality: DEFAULT_FINALITY
});
}
/**
* Calls {@link Provider.viewAccessKeyList} to retrieve the account's keys
*/
async getAccessKeyList() {
return this.provider.viewAccessKeyList(this.accountId, {
finality: DEFAULT_FINALITY
});
}
/**
* Calls {@link Provider.viewContractCode} to retrieve the account's
* contract code and its hash
*/
async getContractCode() {
return this.provider.viewContractCode(this.accountId, {
finality: DEFAULT_FINALITY
});
}
/**
* Calls {@link Provider.viewContractState} to retrieve the keys and values
* stored on the account's contract
*/
async getContractState(prefix) {
return this.provider.viewContractState(this.accountId, prefix, {
finality: DEFAULT_FINALITY
});
}
/**
* Create a transaction that can be later signed with a {@link Signer}
*
* @param receiverId Account against which to perform the actions
* @param actions Actions to perform
* @param publicKey The public part of the key that will be used to sign the transaction
*/
async createTransaction(receiverId, actions, publicKey) {
if (!publicKey) throw new Error("Please provide a public key");
const pk = PublicKey.from(publicKey);
const accessKey = await this.getAccessKey(pk);
const block = await this.provider.viewBlock({
finality: DEFAULT_FINALITY
});
const recentBlockHash = block.header.hash;
const nonce = BigInt(accessKey.nonce) + 1n;
return createTransaction(
this.accountId,
pk,
receiverId,
nonce + 1n,
actions,
baseDecode(recentBlockHash)
);
}
/**
* Create a signed transaction ready to be broadcast by a {@link Provider}
*/
async createSignedTransaction(receiverId, actions) {
if (!this.signer) throw new Error("Please set a signer");
const tx = await this.createTransaction(
receiverId,
actions,
await this.signer.getPublicKey()
);
const [, signedTx] = await this.signer.signTransaction(tx);
return signedTx;
}
/**
* Create a meta transaction ready to be signed by a {@link Signer}
*
* @param receiverId NEAR account receiving the transaction
* @param actions list of actions to perform as part of the meta transaction
* @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
*/
async createMetaTransaction(receiverId, actions, blockHeightTtl = 200, publicKey) {
if (!publicKey) throw new Error(`Please provide a public key`);
const pk = PublicKey.from(publicKey);
const accessKey = await this.getAccessKey(pk);
const nonce = BigInt(accessKey.nonce) + 1n;
const { header } = await this.provider.viewBlock({
finality: DEFAULT_FINALITY
});
const maxBlockHeight = BigInt(header.height) + BigInt(blockHeightTtl);
return buildDelegateAction({
receiverId,
senderId: this.accountId,
actions,
publicKey: pk,
nonce,
maxBlockHeight
});
}
/**
* Create a signed MetaTransaction that can be broadcasted to a relayer
*
* @param receiverId NEAR account receiving the transaction
* @param actions list of actions to perform as part of the meta transaction
* @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
*/
async createSignedMetaTransaction(receiverId, actions, blockHeightTtl = 200) {
if (!this.signer) throw new Error(`Please set a signer`);
const delegateAction = await this.createMetaTransaction(
receiverId,
actions,
blockHeightTtl,
await this.signer.getPublicKey()
);
return this.signer.signDelegateAction(delegateAction);
}
/**
* Creates a transaction, signs it and broadcast it to the network
*
* @param receiverId The NEAR account ID of the transaction receiver.
* @param actions The list of actions to be performed in the transaction.
* @param throwOnFailure Whether to throw an error if the transaction fails.
* @returns {Promise<FinalExecutionOutcome>} A promise that resolves to the final execution outcome of the transaction.
*
*/
async signAndSendTransaction({
receiverId,
actions,
waitUntil = DEFAULT_WAIT_STATUS,
throwOnFailure = true
}) {
const signedTx = await this.createSignedTransaction(
receiverId,
actions
);
const result = await this.provider.sendTransactionUntil(
signedTx,
waitUntil
);
if (throwOnFailure && typeof result.status === "object" && typeof result.status.Failure === "object" && result.status.Failure !== null) {
throw parseResultError(result);
}
return result;
}
async signAndSendTransactions({
transactions,
waitUntil = DEFAULT_WAIT_STATUS,
throwOnFailure = true
}) {
if (!this.signer) throw new Error("Please set a signer");
const results = await Promise.all(
transactions.map(async ({ receiverId, actions }) => {
return this.signAndSendTransaction({
receiverId,
actions,
waitUntil,
throwOnFailure
});
})
);
return results;
}
/**
* Creates a new NEAR account with a given ID and public key.
*
* This method can create two types of accounts:
*
* 1. Top-level accounts of the form `name.tla` (e.g., `bob.near`):
*
* 2. Sub-accounts of the current account (e.g., `sub.ana.near`):
* - The new account ID must end with the current account ID
* - Example: If your account is `ana.near`, you can create `sub.ana.near`
*
* @param newAccountId the new account to create (e.g. bob.near or sub.ana.near)
* @param publicKey the public part of the key that will control the account
* @param nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
*
*/
async createAccount(newAccountId, publicKey, nearToTransfer = "0") {
if (newAccountId.endsWith(this.accountId)) {
return this.createSubAccount(
newAccountId,
publicKey,
nearToTransfer
);
}
const splitted = newAccountId.split(".");
if (splitted.length != 2) {
throw new Error(
"newAccountId needs to be of the form <string>.<tla>"
);
}
const TLA = splitted[1];
return this.signAndSendTransaction({
receiverId: TLA,
actions: [
functionCall3(
"create_account",
{
new_account_id: newAccountId,
new_public_key: publicKey.toString()
},
BigInt("60000000000000"),
BigInt(nearToTransfer)
)
]
});
}
/**
* Creates a sub account of this account. For example, if the account is
* ana.near, you can create sub.ana.near.
*
* @param accountOrPrefix a prefix (e.g. `sub`) or the full sub-account (`sub.ana.near`)
* @param publicKey the public part of the key that will control the account
* @param nearToTransfer how much NEAR to transfer to the account (default: 0)
*
*/
async createSubAccount(accountOrPrefix, publicKey, nearToTransfer = "0") {
if (!this.signer) throw new Error("Please set a signer");
const newAccountId = accountOrPrefix.includes(".") ? accountOrPrefix : `${accountOrPrefix}.${this.accountId}`;
if (newAccountId.length > 64) {
throw new Error(`Accounts cannot exceed 64 characters`);
}
if (!newAccountId.endsWith(this.accountId)) {
throw new Error(`New account must end up with ${this.accountId}`);
}
const actions = [
createAccount3(),
transfer3(BigInt(nearToTransfer)),
addKey3(PublicKey.from(publicKey), fullAccessKey2())
];
return this.signAndSendTransaction({
receiverId: newAccountId,
actions
});
}
/**
* Deletes the account, transferring all remaining NEAR to a beneficiary
* account
*
* Important: Deleting an account does not transfer FTs or NFTs
*
* @param beneficiaryId Will receive the account's remaining balance
*/
async deleteAccount(beneficiaryId) {
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [deleteAccount3(beneficiaryId)]
});
}
/**
* Deploy a smart contract in the account
*
* @param code The compiled contract code bytes
*/
async deployContract(code) {
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [deployContract3(code)]
});
}
/**
* Deploy a global contract that can be reused by multiple accounts
*
* @param code The compiled contract code bytes
* @param deployMode Deploy mode - "codeHash" for immutable contracts, "accountId" for updateable contracts
*/
async deployGlobalContract(code, deployMode) {
const mode = deployMode === "codeHash" ? new GlobalContractDeployMode({ CodeHash: null }) : new GlobalContractDeployMode({ AccountId: null });
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [deployGlobalContract3(code, mode)]
});
}
/**
* Use a previously deployed global contract on this account
*
* @param contractIdentifier The global contract identifier - either { accountId: string } or { codeHash: string | Uint8Array }
*/
async useGlobalContract(contractIdentifier) {
const identifier = "accountId" in contractIdentifier ? new GlobalContractIdentifier({ AccountId: contractIdentifier.accountId }) : new GlobalContractIdentifier({
CodeHash: typeof contractIdentifier.codeHash === "string" ? Buffer.from(contractIdentifier.codeHash, "hex") : contractIdentifier.codeHash
});
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [useGlobalContract3(identifier)]
});
}
/**
*
* @param options
* @param options.publicKey The key to add to the account
* @param options.contractId The contract that this key can call
* @param options.methodNames The methods this key is allowed to call
* @param options.allowance The amount of NEAR this key can expend in gas
* @returns
*/
async addFunctionCallAccessKey({
publicKey,
contractId: contractId2,
methodNames = [],
allowance = NEAR.toUnits("0.25")
}) {
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [
addKey3(
PublicKey.from(publicKey),
functionCallAccessKey2(
contractId2,
methodNames,
BigInt(allowance)
)
)
]
});
}
/**
* Add a full access key to the account
*
* @param publicKey The public key to be added
* @returns {Promise<FinalExecutionOutcome>}
*/
async addFullAccessKey(publicKey) {
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [addKey3(PublicKey.from(publicKey), fullAccessKey2())]
});
}
/**
* @param publicKey The public key to be deleted
* @returns {Promise<FinalExecutionOutcome>}
*/
async deleteKey(publicKey) {
return this.signAndSendTransaction({
receiverId: this.accountId,
actions: [deleteKey3(PublicKey.from(publicKey))]
});
}
/**
* Call a function on a smart contract and return parsed transaction result
*
* @param options
* @param options.contractId The contract in which to call the function
* @param options.methodName The method that will be called
* @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
* @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
* @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
* @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
* @returns
*/
async callFunction(params) {
const result = await this.callFunctionRaw(params);
return getTransactionLastResult(result);
}
/**
* Call a function on a smart contract and return raw transaction outcome
*
* @param options
* @param options.contractId The contract in which to call the function
* @param options.methodName The method that will be called
* @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
* @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
* @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
* @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
* @returns {FinalExecutionOutcome}
*/
async callFunctionRaw({
contractId: contractId2,
methodName,
args = {},
deposit = "0",
gas = DEFAULT_FUNCTION_CALL_GAS,
waitUntil = DEFAULT_WAIT_STATUS
}) {
return await this.signAndSendTransaction({
receiverId: contractId2,
actions: [
functionCall3(methodName, args, BigInt(gas), BigInt(deposit))
],
waitUntil
});
}
/**
* This function simply calls the `signNep413Message` method of the Signer
*
* @param options
* @param options.message The message to be signed (e.g. "authenticating")
* @param options.recipient Who will receive the message (e.g. auth.app.com)
* @param options.nonce A challenge sent by the recipient
* @param options.callbackUrl (optional) Deprecated parameter used only by browser wallets
* @returns
*/
async signNep413Message({
message,
recipient,
nonce,
callbackUrl
}) {
if (!this.signer) throw new Error("Please set a signer");
return this.signer.signNep413Message(
message,
this.accountId,
recipient,
nonce,
callbackUrl
);
}
/**
*
* @param token The token to check the balance of. Defaults to Native NEAR.
* @returns The available balance of the account in units (e.g. yoctoNEAR).
*/
async getBalance(token = NEAR) {
return token.getBalance(this);
}
/**
* Transfers a token to the specified receiver.
*
* Supports sending either the native NEAR token or any supported Fungible Token (FT).
*
* @param amount - The amount of tokens to transfer in units (e.g. yoctoNEAR).
* @param receiverId - The NEAR account ID of the receiver.
* @param token - The token to transfer. Defaults to Native NEAR.
*
*/
async transfer({
receiverId,
amount,
token = NEAR
}) {
return token.transfer({ from: this, receiverId, amount });
}
// DEPRECATED FUNCTIONS BELLOW - Please remove in next release
/**
* @deprecated please use {@link Account.createSignedMetaTransaction} instead
*
* Compose and sign a SignedDelegate action to be executed in a transaction on behalf of this Account instance
*
* @param options Options for the transaction.
* @param options.actions Actions to be included in the meta transaction
* @param options.blockHeightTtl Number of blocks past the current block height for which the SignedDelegate action may be included in a meta transaction
* @param options.receiverId Receiver account of the meta transaction
*/
async signedDelegate({
actions,
blockHeightTtl,
receiverId
}) {
const { header } = await this.provider.viewBlock({
finality: DEFAULT_FINALITY
});
if (!this.signer) throw new Error(`Please set a signer`);
const pk = await this.signer.getPublicKey();
const accessKey = await this.getAccessKey(pk);
const delegateAction = buildDelegateAction({
actions,
maxBlockHeight: BigInt(header.height) + BigInt(blockHeightTtl),
nonce: BigInt(accessKey.nonce) + 1n,
publicKey: pk,
receiverId,
senderId: this.accountId
});
const [, signedDelegate2] = await this.signer.signDelegateAction(
delegateAction
);
return signedDelegate2;
}
/**
* @deprecated, accounts no longer use Connections since it's deprecated too
*/
getConnection() {
return new Connection("", this.provider, this.signer);
}
/** @hidden */
validateArgs(args) {
const isUint8Array = args.byteLength !== void 0 && args.byteLength === args.length;
if (isUint8Array) {
return;
}
if (Array.isArray(args) || typeof args !== "object") {
throw new PositionalArgsError();
}
}
/**
* @deprecated please use {@link callFunction} instead
*
* Execute a function call.
* @param options The options for the function call.
* @param options.contractId The NEAR account ID of the smart contract.
* @param options.methodName The name of the method to be called on the smart contract.
* @param options.args The arguments to be passed to the method.
* @param options.gas The maximum amount of gas to be used for the function call.
* @param options.attachedDeposit The amount of NEAR tokens to be attached to the function call.
* @param options.walletMeta Metadata for wallet integration.
* @param options.walletCallbackUrl The callback URL for wallet integration.
* @param options.stringify A function to convert input arguments into bytes array
* @returns {Promise<FinalExecutionOutcome>} A promise that resolves to the final execution outcome of the function call.
*/
async functionCall({
contractId: contractId2,
methodName,
args = {},
gas = DEFAULT_FUNCTION_CALL_GAS,
attachedDeposit,
walletMeta,
walletCallbackUrl,
stringify
}) {
this.validateArgs(args);
const stringifyArg = stringify === void 0 ? stringifyJsonOrBytes : stringify;
const functionCallArgs = [
methodName,
args,
gas,
attachedDeposit,
stringifyArg,
false
];
return this.signAndSendTransactionLegacy({
receiverId: contractId2,
// eslint-disable-next-line prefer-spread
actions: [functionCall3.apply(void 0, functionCallArgs)],
walletMeta,
walletCallbackUrl
});
}
/**
* @deprecated use instead {@link Provider.viewTransactionStatus}
*/
async getTransactionStatus(txHash) {
return this.provider.viewTransactionStatus(
txHash,
this.accountId,
// accountId is used to determine on which shard to look for a tx
"EXECUTED_OPTIMISTIC"
);
}
/**
* @deprecated use ${@link createSignedTransaction}
* Create a signed transaction which can be broadcast to the network
* @param receiverId NEAR account receiving the transaction
* @param actions list of actions to perform as part of the transaction
* @see {@link "@near-js/providers".json-rpc-provider.JsonRpcProvider.sendTransaction | JsonRpcProvider.sendTransaction}
*/
async signTransaction(receiverId, actions, opts) {
const signer2 = opts?.signer || this.signer;
if (!signer2) throw new Error(`Please set a signer`);
const pk = await signer2.getPublicKey();
const accessKey = await this.getAccessKey(pk);
const block = await this.provider.viewBlock({
finality: DEFAULT_FINALITY
});
const recentBlockHash = block.header.hash;
const nonce = BigInt(accessKey.nonce) + 1n;
const tx = createTransaction(
this.accountId,
pk,
receiverId,
nonce + 1n,
actions,
baseDecode(recentBlockHash)
);
return signer2.signTransaction(tx);
}
/**
* @deprecated instead please create a transaction with
* the actions bellow and broadcast it to the network
* 1. createAccount
* 2. transfer some tokens
* 3. deployContract
* 4. (optional) addKey
* 5. (optional) functionCall to an initialization function
*
* Create a new account and deploy a contract to it
* @param contractId NEAR account where the contract is deployed
* @param publicKey The public key to add to the created contract account
* @param data The compiled contract code
* @param amount of NEAR to transfer to the created contract account. Transfer enough to pay for storage https://docs.near.org/docs/concepts/storage-staking
*/
async createAndDeployContract(contractId2, publicKey, data, amount) {
const accessKey = fullAccessKey2();
await this.signAndSendTransactionLegacy({
receiverId: contractId2,
actions: [
createAccount3(),
transfer3(amount),
addKey3(PublicKey.from(publicKey), accessKey),
deployContract3(data)
]
});
return new _Account(contractId2, this.provider);
}
/**
* @deprecated please instead use {@link transfer}
*
* @param receiverId NEAR account receiving Ⓝ
* @param amount Amount to send in yoctoⓃ
*/
async sendMoney(receiverId, amount) {
return this.signAndSendTransactionLegacy({
receiverId,
actions: [transfer3(amount)]
});
}
/**
* @deprecated please instead use {@link signAndSendTransaction}
*
* Sign a transaction to perform a list of actions and broadcast it using the RPC API.
* @see {@link "@near-js/providers".json-rpc-provider.JsonRpcProvider | JsonRpcProvider }
*
* @param options The options for signing and sending the transaction.
* @param options.receiverId The NEAR account ID of the transaction receiver.
* @param options.actions The list of actions to be performed in the transaction.
* @param options.returnError Whether to return an error if the transaction fails.
* @returns {Promise<FinalExecutionOutcome>} A promise that resolves to the final execution outcome of the transaction.
*
*/
async signAndSendTransactionLegacy({ receiverId, actions, returnError }, opts) {
let txHash, signedTx;
const TX_NONCE_RETRY_NUMBER = 12;
const TX_NONCE_RETRY_WAIT = 500;
const TX_NONCE_RETRY_WAIT_BACKOFF = 1.5;
const result = await exponentialBackoff(
TX_NONCE_RETRY_WAIT,
TX_NONCE_RETRY_NUMBER,
TX_NONCE_RETRY_WAIT_BACKOFF,
async () => {
[txHash, signedTx] = await this.signTransaction(
receiverId,
actions,
opts
);
try {
return await this.provider.sendTransaction(signedTx);
} catch (error) {
if (error.type === "InvalidNonce") {
Logger.warn(
`Retrying transaction ${receiverId}:${baseEncode(
txHash
)} with new nonce.`
);
return null;
}
if (error.type === "Expired") {
Logger.warn(
`Retrying transaction ${receiverId}:${baseEncode(
txHash
)} due to expired block hash`
);
return null;
}
error.context = new ErrorContext(baseEncode(txHash));
throw error;
}
}
);
if (!result) {
throw new TypedError(
"nonce retries exceeded for transaction. This usually means there are too many parallel requests with the same access key.",
"RetriesExceeded"
);
}
printTxOutcomeLogsAndFailures({
contractId: signedTx.transaction.receiverId,
outcome: result
});
if (!returnError && typeof result.status === "object" && typeof result.status.Failure === "object" && result.status.Failure !== null) {
if (result.status.Failure.error_message && result.status.Failure.error_type) {
throw new TypedError(
`Transaction ${result.transaction_outcome.id} failed. ${result.status.Failure.error_message}`,
result.status.Failure.error_type
);
} else {
throw parseResultError(result);
}
}
return result;
}
/**
* @deprecated, accounts will no longer handle keystores
*
* Finds the {@link AccessKeyView} associated with the accounts {@link PublicKey} stored in the {@link "@near-js/keystores".keystore.KeyStore | Keystore}.
*
* @param receiverId currently unused
* @param actions currently unused
* @returns `{ publicKey PublicKey; accessKey: AccessKeyView }`
*/
// eslint-disable-next-line @typescript-eslint/no-unused-vars
async findAccessKey(receiverId, actions) {
if (!this.signer) throw new Error(`Please set a signer`);
const publicKey = await this.signer.getPublicKey();
if (!publicKey) {
throw new TypedError(
`no matching key pair found in ${this.signer.constructor.name}`,
"PublicKeyNotFound"
);
}
const cachedAccessKey = this.accessKeyByPublicKeyCache[publicKey.toString()];
if (cachedAccessKey !== void 0) {
return { publicKey, accessKey: cachedAccessKey };
}
try {
const rawAccessKey = await this.provider.query({
request_type: "view_access_key",
account_id: this.accountId,
public_key: publicKey.toString(),
finality: DEFAULT_FINALITY
});
const accessKey = {
...rawAccessKey,
nonce: BigInt(rawAccessKey.nonce || 0)
};
if (this.accessKeyByPublicKeyCache[publicKey.toString()]) {
return {
publicKey,
accessKey: this.accessKeyByPublicKeyCache[publicKey.toString()]
};
}
this.accessKeyByPublicKeyCache[publicKey.toString()] = accessKey;
return { publicKey, accessKey };
} catch (e) {
if (e.type == "AccessKeyDoesNotExist") {
return null;
}
throw e;
}
}
/**
* @deprecated please use {@link addFullAccessKey} or {@link addFunctionAccessKey}
*
* @see [https://docs.near.org/concepts/basics/accounts/access-keys](https://docs.near.org/concepts/basics/accounts/access-keys)
* @todo expand this API to support more options.
* @param publicKey A public key to be associated with the contract
* @param contractId NEAR account where the contract is deployed
* @param methodNames The method names on the contract that should be allowed to be called. Pass null for no method names and '' or [] for any method names.
* @param amount Payment in yoctoⓃ that is sent to the contract during this function call
*/
async addKey(publicKey, contractId2, methodNames, amount) {
if (!methodNames) {
methodNames = [];
}
if (!Array.isArray(methodNames)) {
methodNames = [methodNames];
}
let accessKey;
if (!contractId2) {
accessKey = fullAccessKey2();
} else {
accessKey = functionCallAccessKey2(contractId2, methodNames, amount);
}
return this.signAndSendTransactionLegacy({
receiverId: this.accountId,
actions: [addKey3(PublicKey.from(publicKey), accessKey)]
});
}
/**
* @deprecated please use {@link Provider.callFunction} instead
*
* Invoke a contract view function using the RPC API.
* @see [https://docs.near.org/api/rpc/contracts#call-a-contract-function](https://docs.near.org/api/rpc/contracts#call-a-contract-function)
*
* @param options Function call options.
* @param options.contractId NEAR account where the contract is deployed
* @param options.methodName The view-only method (no state mutations) name on the contract as it is written in the contract code
* @param options.args Any arguments to the view contract method, wrapped in JSON
* @param options.parse Parse the result of the call. Receives a Buffer (bytes array) and converts it to any object. By default result will be treated as json.
* @param options.stringify Convert input arguments into a bytes array. By default the input is treated as a JSON.
* @param options.blockQuery specifies which block to query state at. By default returns last DEFAULT_FINALITY block (i.e. not necessarily finalized).
* @returns {Promise<any>}
*/
async viewFunction(options) {
return await viewFunction(this.getConnection(), options);
}
/**
* @deprecated please use {@link getContractState} instead
*
* Returns the state (key value pairs) of this account's contract based on the key prefix.
* Pass an empty string for prefix if you would like to return the entire state.
* @see [https://docs.near.org/api/rpc/contracts#view-contract-state](https://docs.near.org/api/rpc/contracts#view-contract-state)
*
* @param prefix allows to filter which keys should be returned. Empty prefix means all keys. String prefix is utf-8 encoded.
* @param blockQuery specifies which block to query state at. By default returns last DEFAULT_FINALITY block (i.e. not necessarily finalized).
*/
async viewState(prefix, blockQuery = { finality: DEFAULT_FINALITY }) {
return await viewState(
this.getConnection(),
this.accountId,
prefix,
blockQuery
);
}
/**
* @deprecated please use {@link getAccessKeyList} instead
*
* Get all access keys for the account
* @see [https://docs.near.org/api/rpc/access-keys#view-access-key-list](https://docs.near.org/api/rpc/access-keys#view-access-key-list)
*
*/
async getAccessKeys() {
const response = await this.provider.query({
request_type: "view_access_key_list",
account_id: this.accountId,
finality: DEFAULT_FINALITY
});
return response?.keys?.map((key) => ({
...key,
access_key: {
...key.access_key,
nonce: BigInt(key.access_key.nonce)
}
}));
}
/**
* @deprecated
*
* Returns a list of authorized apps
* @todo update the response value to return all the different keys, not just app keys.
*
*/
async getAccountDetails() {
const accessKeys = await this.getAccessKeys();
const authorizedApps = accessKeys.filter((item) => item.access_key.permission !== "FullAccess").map((item) => {
const perm = item.access_key.permission;
return {
contractId: perm.FunctionCall.receiver_id,
amount: perm.FunctionCall.allowance,
publicKey: item.public_key
};
});
return { authorizedApps };
}
/**
* @deprecated please use {@link getState} instead
*
* Returns basic NEAR account information via the `view_account` RPC query method
* @see [https://docs.near.org/api/rpc/contracts#view-account](https://docs.near.org/api/rpc/contracts#view-account)
*/
async state() {
return this.provider.query({
request_type: "view_account",
account_id: this.accountId,
finality: "optimistic"
});
}
/**
* @deprecated please use {@link getState} instead
*
*/
async getAccountBalance() {
const protocolConfig = await this.provider.experimental_protocolConfig({
finality: DEFAULT_FINALITY
});
const state = await this.state();
const costPerByte = BigInt(
protocolConfig.runtime_config.storage_amount_per_byte
);
const stateStaked = BigInt(state.storage_usage) * costPerByte;
const staked = BigInt(state.locked);
const totalBalance = BigInt(state.amount) + staked;
const availableBalance = totalBalance - (staked > stateStaked ? staked : stateStaked);
return {
total: totalBalance.toString(),
stateStaked: stateStaked.toString(),
staked: staked.toString(),
available: availableBalance.toString()
};
}
/**
* Returns the NEAR tokens balance and validators of a given account that is delegated to the staking pools that are part of the validators set in the current epoch.
*
* @deprecated
*
* NOTE: If the tokens are delegated to a staking pool that is currently on pause or does not have enough tokens to participate in validation, they won't be accounted for.
* @returns {Promise<ActiveDelegatedStakeBalance>}
*/
async getActiveDelegatedStakeBalance() {
const block = await this.provider.block({
finality: DEFAULT_FINALITY
});
const blockHash = block.header.hash;
const epochId = block.header.epoch_id;
const { current_validators, next_validators, current_proposals } = await this.provider.validators(epochId);
const pools = /* @__PURE__ */ new Set();
[
...current_validators,
...next_validators,
...current_proposals
].forEach((validator) => pools.add(validator.account_id));
const uniquePools = [...pools];
const promises = uniquePools.map(
(validator) => this.viewFunction({
contractId: validator,
methodName: "get_account_total_balance",
args: { account_id: this.accountId },
blockQuery: { blockId: blockHash }
})
);
const results = await Promise.allSettled(promises);
const hasTimeoutError = results.some((result) => {
if (result.status === "rejected" && result.reason.type === "TimeoutError") {
return true;
}
return false;
});
if (hasTimeoutError) {
throw new Error("Failed to get delegated stake balance");
}
const summary = results.reduce(
(result, state, index) => {
const validatorId = uniquePools[index];
if (state.status === "fulfilled") {
const currentBN = BigInt(state.value);
if (currentBN !== 0n) {
return {
...result,
stakedValidators: [
...result.stakedValidators,
{ validatorId, amount: currentBN.toString() }
],
total: result.total + currentBN
};
}
}
if (state.status === "rejected") {
return {
...result,
failedValidators: [
...result.failedValidators,
{ validatorId, error: state.reason }
]
};
}
return result;
},
{ stakedValidators: [], failedValidators: [], total: 0n }
);
return {
...summary,
total: summary.total.toString()
};
}
};
// src/near.ts
if (process.env.NODE_ENV !== "production") {
dotenv.config({ path: "./.env.development.local" });
} else {
console.log("loading prod env vars");
dotenv.config();
}
var GAS = BigInt("300000000000000");
var _contractId = process.env.NEXT_PUBLIC_contractId?.replaceAll('"', "");
var contractId = _contractId;
var networkId = /testnet/gi.test(contractId) ? "testnet" : "mainnet";
var _accountId;
var signer;
var { NEAR_ACCOUNT_ID, NEAR_SEED_PHRASE } = process.env;
if (NEAR_ACCOUNT_ID && NEAR_SEED_PHRASE) {
_accountId = NEAR_ACCOUNT_ID.replaceAll('"', "");
const { secretKey } = (0, import_near_seed_phrase.parseSeedPhrase)(NEAR_SEED_PHRASE.replaceAll('"', ""));
const keyPair = KeyPair.fromString(secretKey);
signer = new KeyPairSigner(keyPair);
}
var provider = getProvider(process.env.NEAR_RPC_JSON?.replaceAll("'", ""));
var setKey = (accountId, secretKey) => {
if (!accountId || !secretKey) {
return console.log("ERROR: setKey missing args");
}
if (secretKey.indexOf(" ") > -1) {
secretKey = (0, import_near_seed_phrase.parseSeedPhrase)(secretKey).secretKey;
}
_accountId = accountId;
const keyPair = KeyPair.fromString(secretKey);
signer = new KeyPairSigner(keyPair);
};
var getImplicit = (pubKeyStr) => Buffer.from(PublicKey.from(pubKeyStr).data).toString("hex").toLowerCase();
var getAccount = (id = _accountId) => new Account(id, provider, signer);
var getCurrentAccountId = () => _accountId;
var contractCall = async ({
accountId = _accountId,
contractId: contractId2 = _contractId,
methodName,
args,
gas = GAS,
deposit = BigInt("0")
}) => {
const account = getAccount(accountId);
let res;
try {
res = await account.callFunction({
contractId: contractId2,
methodName,
args,
gas,
deposit,
waitUntil: "EXECUTED"
});
} catch (e) {
console.log(e);
if (/deserialize/gi.test(JSON.stringify(e))) {
return console.log(`Bad arguments to ${methodName} method`);
}
throw e;
}
return res;
};
// src/agentHelpers.ts
if (process.env.NODE_ENV !== "production") {
dotenv2.config({ path: "./.env.development.local" });
} else {
dotenv2.config();
}
var endpoint = process.env.DSTACK_SIMULATOR_ENDPOINT;
var randomArray = new Uint8Array(32);
crypto.getRandomValues(randomArray);
async function deriveAgentAccount(hash) {
if (!hash) {
try {
const client = new TappdClient(endpoint);
const randomString = Buffer.from(randomArray).toString("hex");
const keyFromTee = await client.deriveKey(
randomString,
randomString
);
hash = Buffer.from(
await crypto.subtle.digest(
"SHA-256",
Buffer.concat([randomArray, keyFromTee.asUint8Array(32)])
)
);
} catch (e) {
console.log("NOT RUNNING IN TEE");
hash = Buffer.from(
await crypto.subtle.digest("SHA-256", randomArray)
);
}
}
const data = (0, import_near_seed_phrase2.generateSeedPhrase)(hash);
const accountId = getImplicit(data.publicKey);
setKey(accountId, data.secretKey);
return accountId;
}
async function registerAgent(codehash) {
let resContract;
if (!codehash) {
const client = new TappdClient(endpoint);
let tcb_info = (await client.getInfo()).tcb_info;
if (typeof tcb_info !== "string") {
tcb_info = JSON.stringify(tcb_info);
}
const accountId = getCurrentAccountId();
const ra = await client.tdxQuote(accountId, "raw");
const quote_hex = ra.quote.replace(/^0x/, "");
const formData = new FormData();
formData.append("hex", quote_hex);
let collateral, checksum;
const resHelper = await (await fetch("https://proof.t16z.com/api/upload", {
method: "POST",
body: formData
})).json();
checksum = resHelper.checksum;
collateral = JSON.stringify(resHelper.quote_collateral);
resContract = await contractCall({
methodName: "register_agent",
args: {
quote_hex,
collateral,
checksum,
tcb_info
}
});
} else {
resContract = await contractCall({
methodName: "register_agent",
args: {
codehash
}
});
}
return resContract;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
deriveAgentAccount,
registerAgent
});
/*! Bundled license information:
safe-buffer/index.js:
(*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
mustache/mustache.js:
(*!
* mustache.js - Logic-less {{mustache}} templates with JavaScript
* http://github.com/janl/mustache.js
*)
depd/index.js:
(*!
* depd
* Copyright(c) 2014-2018 Douglas Christopher Wilson
* MIT Licensed
*)
@scure/base/lib/esm/index.js:
(*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
@noble/hashes/esm/utils.js:
(*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
@noble/curves/esm/abstract/utils.js:
@noble/curves/esm/abstract/modular.js:
@noble/curves/esm/abstract/curve.js:
@noble/curves/esm/abstract/edwards.js:
@noble/curves/esm/ed25519.js:
(*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/