@seams/wallet 0.7.3 → 0.8.0

package/dist/workers/evm-crypto.worker.js

@@ -67,30 +67,6 @@ function encode_eip1559_signed_tx_from_signature65(tx, signature65) {
 function init_evm_crypto() {
   wasm.init_evm_crypto();
 }
-function secp256k1_private_key_32_to_public_key_33(private_key32) {
-  const ptr0 = passArray8ToWasm0(private_key32, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ret = wasm.secp256k1_private_key_32_to_public_key_33(ptr0, len0);
-  if (ret[3]) {
-    throw takeFromExternrefTable0(ret[2]);
-  }
-  var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-  return v2;
-}
-function sign_secp256k1_recoverable(digest32, private_key32) {
-  const ptr0 = passArray8ToWasm0(digest32, wasm.__wbindgen_malloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ptr1 = passArray8ToWasm0(private_key32, wasm.__wbindgen_malloc);
-  const len1 = WASM_VECTOR_LEN;
-  const ret = wasm.sign_secp256k1_recoverable(ptr0, len0, ptr1, len1);
-  if (ret[3]) {
-    throw takeFromExternrefTable0(ret[2]);
-  }
-  var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-  return v3;
-}
 function validate_secp256k1_public_key_33(public_key33) {
   const ptr0 = passArray8ToWasm0(public_key33, wasm.__wbindgen_malloc);
   const len0 = WASM_VECTOR_LEN;
@@ -679,140 +655,6 @@ var WorkerControlMessage = {
   WORKER_READY: "WORKER_READY"
 };
 
-// ../../node_modules/base-x/src/esm/index.js
-function base(ALPHABET) {
-  if (ALPHABET.length >= 255) {
-    throw new TypeError("Alphabet too long");
-  }
-  const BASE_MAP = new Uint8Array(256);
-  for (let j = 0;j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (let i = 0;i < ALPHABET.length; i++) {
-    const x = ALPHABET.charAt(i);
-    const xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) {
-      throw new TypeError(x + " is ambiguous");
-    }
-    BASE_MAP[xc] = i;
-  }
-  const BASE = ALPHABET.length;
-  const LEADER = ALPHABET.charAt(0);
-  const FACTOR = Math.log(BASE) / Math.log(256);
-  const iFACTOR = Math.log(256) / Math.log(BASE);
-  function encode(source) {
-    if (source instanceof Uint8Array) {} else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) {
-      throw new TypeError("Expected Uint8Array");
-    }
-    if (source.length === 0) {
-      return "";
-    }
-    let zeroes = 0;
-    let length = 0;
-    let pbegin = 0;
-    const pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-    const b58 = new Uint8Array(size);
-    while (pbegin !== pend) {
-      let carry = source[pbegin];
-      let i = 0;
-      for (let it1 = size - 1;(carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
-        carry += 256 * b58[it1] >>> 0;
-        b58[it1] = carry % BASE >>> 0;
-        carry = carry / BASE >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length = i;
-      pbegin++;
-    }
-    let it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-    let 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 new Uint8Array;
-    }
-    let psz = 0;
-    let zeroes = 0;
-    let length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-    const size = (source.length - psz) * FACTOR + 1 >>> 0;
-    const b256 = new Uint8Array(size);
-    while (psz < source.length) {
-      const charCode = source.charCodeAt(psz);
-      if (charCode > 255) {
-        return;
-      }
-      let carry = BASE_MAP[charCode];
-      if (carry === 255) {
-        return;
-      }
-      let i = 0;
-      for (let it3 = size - 1;(carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
-        carry += BASE * b256[it3] >>> 0;
-        b256[it3] = carry % 256 >>> 0;
-        carry = carry / 256 >>> 0;
-      }
-      if (carry !== 0) {
-        throw new Error("Non-zero carry");
-      }
-      length = i;
-      psz++;
-    }
-    let it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    const vch = new Uint8Array(zeroes + (size - it4));
-    let j = zeroes;
-    while (it4 !== size) {
-      vch[j++] = b256[it4++];
-    }
-    return vch;
-  }
-  function decode(string) {
-    const buffer = decodeUnsafe(string);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error("Non-base" + BASE + " character");
-  }
-  return {
-    encode,
-    decodeUnsafe,
-    decode
-  };
-}
-var esm_default = base;
-
-// ../../node_modules/bs58/src/esm/index.js
-var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-var esm_default2 = esm_default(ALPHABET);
-
 // ../shared-ts/src/utils/errors.ts
 function errorMessage(err) {
   try {
@@ -904,12 +746,8 @@ function evmCryptoOperationLabel(type) {
       return "EIP-1559 transaction hash";
     case "encodeEip1559SignedTxFromSignature65":
       return "signed EIP-1559 transaction";
-    case "signSecp256k1Recoverable":
-      return "recoverable secp256k1 signature";
     case "verifySecp256k1RecoverableSignatureAgainstPublicKey33":
       return "recoverable secp256k1 signature verification";
-    case "secp256k1PrivateKey32ToPublicKey33":
-      return "secp256k1 public key";
     case "validateSecp256k1PublicKey33":
       return "secp256k1 public key validation";
     case "addSecp256k1PublicKeys33":
@@ -977,20 +815,6 @@ self.addEventListener("message", async (event) => {
         postOperationSucceeded(msg, ab, [ab]);
         return;
       }
-      case "signSecp256k1Recoverable": {
-        const digest32 = toU8(msg.payload.digest32);
-        const privateKey32 = toU8(msg.payload.privateKey32);
-        try {
-          const out = sign_secp256k1_recoverable(digest32, privateKey32);
-          const ab = out.slice().buffer;
-          zeroizeBytes(out);
-          postOperationSucceeded(msg, ab, [ab]);
-          return;
-        } finally {
-          zeroizeBytes(digest32);
-          zeroizeBytes(privateKey32);
-        }
-      }
       case "verifySecp256k1RecoverableSignatureAgainstPublicKey33": {
         const digest32 = toU8(msg.payload.digest32);
         const signature65 = toU8(msg.payload.signature65);
@@ -1008,18 +832,6 @@ self.addEventListener("message", async (event) => {
           zeroizeBytes(signature65);
         }
       }
-      case "secp256k1PrivateKey32ToPublicKey33": {
-        const privateKey32 = toU8(msg.payload.privateKey32);
-        try {
-          const out = secp256k1_private_key_32_to_public_key_33(privateKey32);
-          const ab = out.slice().buffer;
-          zeroizeBytes(out);
-          postOperationSucceeded(msg, ab, [ab]);
-          return;
-        } finally {
-          zeroizeBytes(privateKey32);
-        }
-      }
       case "validateSecp256k1PublicKey33": {
         const publicKey33 = toU8(msg.payload.publicKey33);
         const out = validate_secp256k1_public_key_33(publicKey33);