@prosopo/account 0.3.1

package/dist/cjs/common/dist/node/UrlConverter.cjs

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("../index.cjs");
+const error = require("../error.cjs");
+class UrlConverter {
+  constructor() {
+    this.symbols = [
+      "",
+      "0",
+      "1",
+      "2",
+      "3",
+      "4",
+      "5",
+      "6",
+      "7",
+      "8",
+      "9",
+      "a",
+      "b",
+      "c",
+      "d",
+      "e",
+      "f",
+      "g",
+      "h",
+      "i",
+      "j",
+      "k",
+      "l",
+      "m",
+      "n",
+      "o",
+      "p",
+      "q",
+      "r",
+      "s",
+      "t",
+      "u",
+      "v",
+      "w",
+      "x",
+      "y",
+      "z",
+      "/",
+      ".",
+      "-",
+      "_",
+      "%",
+      ":",
+      "http://",
+      "https://",
+      "www.",
+      ".com",
+      ".net",
+      ".org",
+      ".co.uk",
+      ".io"
+    ];
+    this.symbolNBits = 6;
+    this.byteNBits = 8;
+    this.symbolToNumMap = this.symbols.reduce((obj, symb, i, arr) => {
+      obj[symb] = i;
+      return obj;
+    }, {});
+    this.numToSymbolMap = this.symbols.reduce((obj, symb, i, arr) => {
+      obj[i] = symb;
+      return obj;
+    }, {});
+    this.longestSymbolLength = this.symbols.reduce((longest, symb) => {
+      return Math.max(longest, symb.length);
+    }, 0);
+    const maxSymbols = Math.pow(2, this.symbolNBits);
+    if (this.symbols.length > maxSymbols) {
+      throw new error.ProsopoError("DEVELOPER.GENERAL", {
+        context: {
+          error: `Cannot encode more than ${maxSymbols} symbols`,
+          context: "only built to encode 64 symbols. Need to adjust the encoding and decoding scheme for more symbols"
+        }
+      });
+    }
+    const symbols = this.getSymbols();
+    if (symbols.length !== new Set(symbols).size) {
+      throw new error.ProsopoError("DEVELOPER.GENERAL", { context: { error: "Symbols must be unique" } });
+    }
+  }
+  symbolToNum(symb) {
+    const num = this.symbolToNumNull(symb);
+    if (num === void 0) {
+      throw new error.ProsopoError("DEVELOPER.GENERAL", {
+        context: { error: `Could not find number for symbol '${symb}'` }
+      });
+    }
+    return num;
+  }
+  symbolToNumNull(symb) {
+    symb = symb.toLowerCase();
+    const num = this.symbolToNumMap[symb];
+    return num;
+  }
+  numToSymbol(num) {
+    const symb = this.numToSymbolNull(num);
+    if (symb === void 0) {
+      throw new error.ProsopoError("DEVELOPER.GENERAL", {
+        context: { error: `Could not find symbol for number ${num}` }
+      });
+    }
+    return symb;
+  }
+  numToSymbolNull(num) {
+    const symb = this.numToSymbolMap[num];
+    return symb;
+  }
+  encode(url) {
+    url = url.toLowerCase();
+    const nums = [];
+    const origUrl = url;
+    while (url.length > 0) {
+      let len = Math.min(url.length, this.longestSymbolLength);
+      let num = void 0;
+      while (num === void 0 && len > 0) {
+        const str = url.slice(0, len);
+        num = this.symbolToNumNull(str);
+        if (num === void 0) {
+          len--;
+        }
+      }
+      if (num === void 0) {
+        throw new error.ProsopoError("DEVELOPER.GENERAL", {
+          context: { error: `Could not find symbol at '${url}' of '${origUrl}'` }
+        });
+      }
+      nums.push(num);
+      url = url.slice(len);
+    }
+    const nBits = nums.length * this.symbolNBits;
+    const nBytes = Math.ceil(nBits / this.byteNBits);
+    const bytes = new Uint8Array(nBytes);
+    for (let bitCount = 0; bitCount < nBits; ) {
+      const numIndex = bitCount / this.symbolNBits | 0;
+      const num = nums[numIndex];
+      if (num === void 0) {
+        throw new error.ProsopoError("DEVELOPER.GENERAL", {
+          context: { error: `Could not find number at index ${numIndex} of '${nums}'` }
+        });
+      }
+      const byteIndex = bitCount / this.byteNBits | 0;
+      const usedBitsInByte = bitCount % this.byteNBits;
+      const unusedBitsInByte = this.byteNBits - usedBitsInByte;
+      const shift = this.symbolNBits - unusedBitsInByte;
+      if (shift < 0) {
+        const usedBitsInSymbol = bitCount % this.symbolNBits;
+        const unusedBitsInSymbol = this.symbolNBits - usedBitsInSymbol;
+        const max = Math.pow(2, unusedBitsInSymbol);
+        const remNum = num % max;
+        const shift2 = this.byteNBits - unusedBitsInSymbol;
+        const shiftedNum = remNum << shift2;
+        bytes[byteIndex] |= shiftedNum;
+        bitCount += unusedBitsInSymbol;
+      } else {
+        bytes[byteIndex] |= num >> shift;
+        bitCount += unusedBitsInByte;
+      }
+    }
+    return bytes;
+  }
+  decode(bytes) {
+    const arr = [];
+    const nBits = bytes.length * this.byteNBits;
+    let num = 0;
+    let nBitsNum = 0;
+    for (let bitCount = 0; bitCount < nBits; ) {
+      const byteIndex = bitCount / this.byteNBits | 0;
+      const byte = bytes[byteIndex];
+      if (byte === void 0) {
+        throw new error.ProsopoError("DEVELOPER.GENERAL", {
+          context: { error: `Could not find byte at index ${byteIndex} of '${bytes}'` }
+        });
+      }
+      const usedBitsInByte = bitCount % this.byteNBits;
+      const unusedBitsInByte = this.byteNBits - usedBitsInByte;
+      const unusedBitsInSymbol = this.symbolNBits - nBitsNum;
+      const consumeNBits = Math.min(unusedBitsInByte, unusedBitsInSymbol);
+      const slice = this.bitSlice(byte, usedBitsInByte, consumeNBits);
+      num = num << consumeNBits | slice;
+      nBitsNum += consumeNBits;
+      if (nBitsNum >= this.symbolNBits) {
+        const symbol = this.numToSymbol(num);
+        arr.push(symbol);
+        num = 0;
+        nBitsNum = 0;
+      }
+      bitCount += consumeNBits;
+    }
+    return arr.join("");
+  }
+  bitSlice(num, startBit, lenBit) {
+    const truncedLeft = this.bitTruncLeft(num, startBit);
+    const truncedLen = this.bitTruncRight(truncedLeft, Math.max(0, this.byteNBits - lenBit - startBit));
+    return truncedLen;
+  }
+  bitTruncRight(num, nBits) {
+    return num >> nBits;
+  }
+  bitTruncLeft(num, nBits) {
+    const threshNBits = this.byteNBits - nBits;
+    const thresh = Math.pow(2, threshNBits);
+    return thresh <= 0 ? 0 : num % thresh;
+  }
+  getSymbols() {
+    return this.symbols;
+  }
+}
+exports.UrlConverter = UrlConverter;
+exports.default = UrlConverter;

package/dist/cjs/common/dist/node/i18nMiddleware.cjs

@@ -0,0 +1,8 @@
+"use strict";
+const i18nextHttpMiddleware = require("i18next-http-middleware");
+require("../i18n.cjs");
+const i18n = require("i18next");
+function i18nMiddleware(options) {
+  return i18nextHttpMiddleware.handle(i18n, { ...options });
+}
+module.exports = i18nMiddleware;

package/dist/cjs/common/dist/node/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const i18nMiddleware = require("./i18nMiddleware.cjs");
+exports.i18nMiddleware = i18nMiddleware;

package/dist/cjs/common/dist/react/index.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useTranslation = require("./useTranslation.cjs");
+exports.useTranslation = useTranslation;

package/dist/cjs/common/dist/react/useTranslation.cjs

@@ -0,0 +1,8 @@
+"use strict";
+const reactI18next = require("react-i18next");
+require("../i18n.cjs");
+const i18n = require("i18next");
+function useTranslation(options) {
+  return reactI18next.useTranslation("translation", { i18n, ...options });
+}
+module.exports = useTranslation;

package/dist/cjs/common/dist/string.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function capitaliseFirstLetter(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+exports.capitaliseFirstLetter = capitaliseFirstLetter;

package/dist/cjs/common/dist/utils.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const error = require("./error.cjs");
+const hex = require("@polkadot/util/hex");
+const en = require("./locales/en.json.cjs");
+function isClientSide() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+}
+function getLeafFieldPath(obj) {
+  if (typeof obj === "string") {
+    return [obj];
+  }
+  return Object.keys(obj).reduce((arr, key) => {
+    const value = obj[key];
+    if (value === void 0) {
+      throw new error.ProsopoError("DEVELOPER.KEY_ERROR", { context: { error: `Undefined value for key ${key}` } });
+    }
+    const children = getLeafFieldPath(value);
+    return arr.concat(children.map((child) => {
+      return `${key}.${child}`;
+    }));
+  }, []);
+}
+const translationKeys = getLeafFieldPath(en.default);
+const trimProviderUrl = (url) => {
+  return hex.hexToString(url).replace(/\0/g, "");
+};
+function snakeToCamelCase(str) {
+  return str.replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace("-", "").replace("_", ""));
+}
+function reverseHexString(str) {
+  return `0x${str.match(/.{1,2}/g)?.reverse().join("") || ""}`;
+}
+exports.isClientSide = isClientSide;
+exports.reverseHexString = reverseHexString;
+exports.snakeToCamelCase = snakeToCamelCase;
+exports.translationKeys = translationKeys;
+exports.trimProviderUrl = trimProviderUrl;

package/dist/cjs/extension/Extension.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class Extension {
+}
+exports.Extension = Extension;

package/dist/cjs/extension/ExtensionWeb2.cjs

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Api = require("@polkadot/api/promise/Api");
+const Extension = require("./Extension.cjs");
+const keyring = require("@polkadot/keyring");
+require("../common/dist/index.cjs");
+const ws = require("@polkadot/rpc-provider/ws");
+const address = require("@polkadot/util-crypto/address");
+const bip39 = require("@polkadot/util-crypto/mnemonic/bip39");
+const fingerprintjs = require("@fingerprintjs/fingerprintjs");
+require("../util/dist/index.cjs");
+const string = require("@polkadot/util/string");
+const u8a = require("@polkadot/util/u8a");
+const Signer = require("@polkadot/extension-base/page/Signer");
+const error = require("../common/dist/error.cjs");
+const canvas = require("../util/dist/canvas.cjs");
+const hash = require("../common/dist/hash.cjs");
+class ExtensionWeb2 extends Extension.Extension {
+  constructor() {
+    super(...arguments);
+    this.getNetwork = (config) => {
+      const network = config.networks[config.defaultNetwork];
+      if (!network) {
+        throw new error.ProsopoEnvError("DEVELOPER.NETWORK_NOT_FOUND", {
+          context: { error: `No network found for environment ${config.defaultEnvironment}` }
+        });
+      }
+      return network;
+    };
+  }
+  async getAccount(config) {
+    const network = this.getNetwork(config);
+    const wsProvider = new ws.WsProvider(network.endpoint);
+    const account = await this.createAccount(wsProvider);
+    const extension = await this.createExtension(account);
+    return {
+      account,
+      extension
+    };
+  }
+  async createExtension(account) {
+    const signer = new Signer(async () => {
+      return;
+    });
+    signer.signRaw = async (payload) => {
+      const signature = account.keypair.sign(payload.data);
+      return {
+        id: 1,
+        // the id of the request to sign. This should be incremented each time and adjust the signature, but we're hacking around this. Hence the signature will always be the same given the same payload.
+        signature: u8a.u8aToHex(signature)
+      };
+    };
+    return {
+      accounts: {
+        get: async () => {
+          return [account];
+        },
+        subscribe: () => {
+          return () => {
+            return;
+          };
+        }
+      },
+      name: "procaptcha-web2",
+      version: "0.1.11",
+      signer
+    };
+  }
+  async createAccount(wsProvider) {
+    const params = {
+      area: { width: 300, height: 300 },
+      offsetParameter: 2001000001,
+      multiplier: 15e3,
+      fontSizeFactor: 1.5,
+      maxShadowBlur: 50,
+      numberOfRounds: 5,
+      seed: 42
+    };
+    const browserEntropy = await this.getFingerprint();
+    const canvasEntropy = canvas.picassoCanvas(params.numberOfRounds, params.seed, params);
+    const entropy = hash.hexHash([canvasEntropy, browserEntropy].join(""), 128).slice(2);
+    const u8Entropy = string.stringToU8a(entropy);
+    const mnemonic = bip39.entropyToMnemonic(u8Entropy);
+    const api = await Api.ApiPromise.create({ provider: wsProvider, initWasm: false });
+    const type = "ed25519";
+    const keyring$1 = new keyring.Keyring({ type, ss58Format: api.registry.chainSS58 });
+    const keypair = keyring$1.addFromMnemonic(mnemonic);
+    const address$1 = keypair.address.length === 42 ? keypair.address : address.encodeAddress(address.decodeAddress(keypair.address), api.registry.chainSS58);
+    return {
+      address: address$1,
+      type,
+      name: address$1,
+      keypair
+    };
+  }
+  async getFingerprint() {
+    const fpPromise = fingerprintjs.load();
+    const fp = await fpPromise;
+    const result = await fp.get();
+    const { screenFrame, ...componentsReduced } = result.components;
+    return fingerprintjs.hashComponents(componentsReduced);
+  }
+}
+exports.ExtensionWeb2 = ExtensionWeb2;

package/dist/cjs/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Extension = require("./extension/Extension.cjs");
+const ExtensionWeb2 = require("./extension/ExtensionWeb2.cjs");
+exports.Extension = Extension.Extension;
+exports.ExtensionWeb2 = ExtensionWeb2.ExtensionWeb2;