@bubolabs/wallet-wasm 0.1.0

package/index.js

@@ -0,0 +1,748 @@
+import * as coreWasm from "./pkg/bubo_wallet_wasm.js";
+import * as cardanoWasm from "./pkg-cardano/bubo_wallet_wasm.js";
+
+let initialized = false;
+
+export class WalletWasmError extends Error {
+  constructor(payload) {
+    super(payload.message);
+    this.name = "WalletWasmError";
+    this.code = payload.code;
+    this.details = payload.details ?? null;
+  }
+}
+
+export async function init() {
+  callWasm(() => coreWasm.init());
+  callWasm(() => cardanoWasm.init());
+  initialized = true;
+}
+
+export function listSupportedChains() {
+  ensureInitialized();
+  return mergeByChainId([
+    ...parseJsonResult(callWasm(() => coreWasm.listSupportedChains())),
+    ...parseJsonResult(callWasm(() => cardanoWasm.listSupportedChains())),
+  ]);
+}
+
+export function listChainExtensions() {
+  ensureInitialized();
+  return mergeByChainId([
+    ...parseJsonResult(callWasm(() => coreWasm.listChainExtensions())),
+    ...parseJsonResult(callWasm(() => cardanoWasm.listChainExtensions())),
+  ]);
+}
+
+export function invokeChainExtension(chainId, method, payload = {}) {
+  ensureInitialized();
+  const module = wasmForChain(chainId);
+  return callWasm(() => module.invokeChainExtension(chainId, method, toJson(payload)));
+}
+
+export function deriveAddress(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.deriveAddress(toJson(request)));
+}
+
+export function deriveWallet(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return parseJsonResult(callWasm(() => module.deriveWallet(toJson(request))));
+}
+
+export function deriveAddressFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.deriveAddressFromPrivateKey(toJson(request)));
+}
+
+export function deriveWalletFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return parseJsonResult(callWasm(() => module.deriveWalletFromPrivateKey(toJson(request))));
+}
+
+export function buildAndSign(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.buildAndSign(toJson(request)));
+}
+
+export function buildAndSignFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.buildAndSignFromPrivateKey(toJson(request)));
+}
+
+export function signMessage(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signMessage(toJson(request)));
+}
+
+export function signMessageFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signMessageFromPrivateKey(toJson(request)));
+}
+
+export function signBytes(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signBytes(toJson(request)));
+}
+
+export function signBytesFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signBytesFromPrivateKey(toJson(request)));
+}
+
+export function signTypedData(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signTypedData(toJson(request)));
+}
+
+export function signTypedDataFromPrivateKey(request) {
+  ensureInitialized();
+  const module = wasmForRequest(request);
+  return callWasm(() => module.signTypedDataFromPrivateKey(toJson(request)));
+}
+
+export const eth = {
+  ...deriveMethods("eth"),
+  ...buildAndSignMethods("eth"),
+  ...signMessageMethods("eth"),
+  ...signTypedDataMethods("eth"),
+  buildTx(payload) {
+    return invokeChainExtension("eth", "eth.buildTx", payload);
+  },
+  signTx(payload) {
+    return invokeChainExtension("eth", "eth.signTx", payload);
+  },
+  decodeSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("eth", "eth.decodeSignedTx", payload));
+  },
+  ecrecover(payload) {
+    return parseJsonResult(invokeChainExtension("eth", "eth.ecrecover", payload));
+  },
+  recoverTypedDataSigner(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.recoverTypedDataSigner", payload)
+    );
+  },
+  verifyMessageSignature(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.verifyMessageSignature", payload)
+    );
+  },
+  verifyTypedDataSignature(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.verifyTypedDataSignature", payload)
+    );
+  },
+  buildEip1271IsValidSignatureCall(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.buildEip1271IsValidSignatureCall", payload)
+    );
+  },
+  verifyEip1271IsValidSignatureResult(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.verifyEip1271IsValidSignatureResult", payload)
+    );
+  },
+  computeUserOperationHash(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.computeUserOperationHash", payload)
+    );
+  },
+  signUserOperation(payload) {
+    return parseJsonResult(invokeChainExtension("eth", "eth.signUserOperation", payload));
+  },
+  recoverUserOperationSigner(payload) {
+    return parseJsonResult(
+      invokeChainExtension("eth", "eth.recoverUserOperationSigner", payload)
+    );
+  },
+};
+
+export const btc = {
+  ...deriveMethods("btc"),
+  ...buildAndSignMethods("btc"),
+  ...signMessageMethods("btc"),
+  ...signBytesMethods("btc"),
+  deriveAccountXpub(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.deriveAccountXpub", payload));
+  },
+  deriveAddressFromXpub(payload) {
+    return invokeChainExtension("btc", "btc.deriveAddressFromXpub", payload);
+  },
+  buildTx(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.buildTx", payload));
+  },
+  signTx(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.signTx", payload));
+  },
+  buildPsbt(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.buildPsbt", payload));
+  },
+  signPsbt(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.signPsbt", payload));
+  },
+  signPsbtWithSigners(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.signPsbtWithSigners", payload));
+  },
+  partialSignPsbt(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.partialSignPsbt", payload));
+  },
+  verifyPsbtFinalized(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.verifyPsbtFinalized", payload));
+  },
+  inspectPsbt(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.inspectPsbt", payload));
+  },
+  decodeSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.decodeSignedTx", payload));
+  },
+  verifyMessage(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.verifyMessage", payload));
+  },
+  frostTrustedDealerKeygen(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostTrustedDealerKeygen", payload)
+    );
+  },
+  frostDkgRound1(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostDkgRound1", payload));
+  },
+  frostDkgRound2(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostDkgRound2", payload));
+  },
+  frostDkgFinalize(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostDkgFinalize", payload));
+  },
+  frostRound1Commit(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostRound1Commit", payload));
+  },
+  frostBuildSigningPackage(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostBuildSigningPackage", payload)
+    );
+  },
+  frostRound2SignShare(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostRound2SignShare", payload));
+  },
+  frostAggregateSignature(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostAggregateSignature", payload)
+    );
+  },
+  frostTaprootComputeTweak(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostTaprootComputeTweak", payload)
+    );
+  },
+  frostVerifySignatureShare(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostVerifySignatureShare", payload)
+    );
+  },
+  frostBuildTaprootPsbtSigningInputs(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostBuildTaprootPsbtSigningInputs", payload)
+    );
+  },
+  frostFinalizeTaprootPsbt(payload) {
+    return parseJsonResult(
+      invokeChainExtension("btc", "btc.frostFinalizeTaprootPsbt", payload)
+    );
+  },
+  frostNonceSessionScope(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostNonceSessionScope", payload));
+  },
+  frostResetNonceGuard(payload) {
+    return parseJsonResult(invokeChainExtension("btc", "btc.frostResetNonceGuard", payload));
+  },
+};
+
+export const solana = {
+  ...deriveMethods("solana"),
+  ...buildAndSignMethods("solana"),
+  ...signMessageMethods("solana"),
+  ...signBytesMethods("solana"),
+  buildTx(payload) {
+    return invokeChainExtension("solana", "solana.buildTx", payload);
+  },
+  signTx(payload) {
+    return invokeChainExtension("solana", "solana.signTx", payload);
+  },
+  inspectSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("solana", "solana.inspectSignedTx", payload));
+  },
+  decodeSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("solana", "solana.decodeSignedTx", payload));
+  },
+  verifyMessageSignature(payload) {
+    return parseJsonResult(
+      invokeChainExtension("solana", "solana.verifyMessageSignature", payload)
+    );
+  },
+  verifyBytesSignature(payload) {
+    return parseJsonResult(
+      invokeChainExtension("solana", "solana.verifyBytesSignature", payload)
+    );
+  },
+};
+
+export const ton = {
+  deriveAddress(request) {
+    return invokeChainExtension("ton", "ton.deriveAddress", inferTonMnemonicType(request));
+  },
+  deriveWallet(request) {
+    return parseJsonResult(
+      invokeChainExtension("ton", "ton.deriveWallet", inferTonMnemonicType(request))
+    );
+  },
+  deriveAddressFromPrivateKey(request) {
+    return invokeChainExtension(
+      "ton",
+      "ton.deriveAddressFromPrivateKey",
+      withTonKeyEncoding(request)
+    );
+  },
+  deriveWalletFromPrivateKey(request) {
+    return parseJsonResult(
+      invokeChainExtension(
+        "ton",
+        "ton.deriveWalletFromPrivateKey",
+        withTonKeyEncoding(request)
+      )
+    );
+  },
+  buildAndSign(request) {
+    const payload = parsePayloadObject(request.txPayload);
+    const built = this.buildTx(payload);
+    const signed = this.signTx({
+      ...pickTonSignerFields(request),
+      unsignedTx: built.unsignedTx,
+      unsignedTxEncoding: built.unsignedTxEncoding,
+    });
+    return base64ToBytes(signed.signedTx);
+  },
+  buildAndSignFromPrivateKey(request) {
+    const payload = parsePayloadObject(request.txPayload);
+    const built = this.buildTx(payload);
+    const signed = this.signTx({
+      privateKey: request.privateKey,
+      keyEncoding: request.privateKeyEncoding,
+      unsignedTx: built.unsignedTx,
+      unsignedTxEncoding: built.unsignedTxEncoding,
+    });
+    return base64ToBytes(signed.signedTx);
+  },
+  buildWalletStateInit(payload) {
+    return parseJsonResult(
+      invokeChainExtension("ton", "ton.buildWalletStateInit", inferTonMnemonicType(payload))
+    );
+  },
+  buildWalletStateInitFromPrivateKey(payload) {
+    return parseJsonResult(
+      invokeChainExtension(
+        "ton",
+        "ton.buildWalletStateInitFromPrivateKey",
+        withTonKeyEncoding(payload)
+      )
+    );
+  },
+  buildTx(payload) {
+    return parseJsonResult(invokeChainExtension("ton", "ton.buildTx", payload));
+  },
+  signTx(payload) {
+    return parseJsonResult(
+      invokeChainExtension("ton", "ton.signTx", inferTonMnemonicType(withTonKeyEncoding(payload)))
+    );
+  },
+  inspectSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("ton", "ton.inspectSignedTx", payload));
+  },
+  decodeSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("ton", "ton.decodeSignedTx", payload));
+  },
+};
+
+export const tron = {
+  ...deriveMethods("tron"),
+  ...buildAndSignMethods("tron"),
+  ...signMessageMethods("tron"),
+  ...signBytesMethods("tron"),
+  buildTx(payload) {
+    return parseJsonResult(invokeChainExtension("tron", "tron.buildTx", payload));
+  },
+  signTx(payload) {
+    return parseJsonResult(invokeChainExtension("tron", "tron.signTx", payload));
+  },
+  inspectSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("tron", "tron.inspectSignedTx", payload));
+  },
+  decodeSignedTx(payload) {
+    return parseJsonResult(invokeChainExtension("tron", "tron.decodeSignedTx", payload));
+  },
+};
+
+export const near = {
+  ...deriveMethods("near"),
+  ...buildAndSignMethods("near"),
+  ...signMessageMethods("near"),
+  ...signBytesMethods("near"),
+  ...jsonTxMethods("near"),
+};
+
+export const cosmos = {
+  ...deriveMethods("cosmos"),
+  ...buildAndSignMethods("cosmos"),
+  ...signMessageMethods("cosmos"),
+  ...signBytesMethods("cosmos"),
+  ...jsonTxMethods("cosmos"),
+};
+
+export const cardano = {
+  ...deriveMethods("cardano"),
+  ...buildAndSignMethods("cardano"),
+  ...signMessageMethods("cardano"),
+  ...signBytesMethods("cardano"),
+  ...jsonTxMethods("cardano"),
+};
+
+export const aptos = {
+  ...deriveMethods("aptos"),
+  ...buildAndSignMethods("aptos"),
+  ...signMessageMethods("aptos"),
+  ...signBytesMethods("aptos"),
+  ...jsonTxMethods("aptos"),
+};
+
+export const polkadot = {
+  ...deriveMethods("polkadot"),
+  ...buildAndSignMethods("polkadot"),
+  ...signMessageMethods("polkadot"),
+  ...signBytesMethods("polkadot"),
+  ...jsonTxMethods("polkadot"),
+};
+
+export const dogecoin = {
+  deriveAddress(request) {
+    return invokeChainExtension("dogecoin", "dogecoin.deriveAddress", request);
+  },
+  deriveWallet(request) {
+    return parseJsonResult(invokeChainExtension("dogecoin", "dogecoin.deriveWallet", request));
+  },
+  deriveAddressFromPrivateKey(request) {
+    return invokeChainExtension(
+      "dogecoin",
+      "dogecoin.deriveAddressFromPrivateKey",
+      withKeyEncodingAlias(request)
+    );
+  },
+  deriveWalletFromPrivateKey(request) {
+    return parseJsonResult(
+      invokeChainExtension(
+        "dogecoin",
+        "dogecoin.deriveWalletFromPrivateKey",
+        withKeyEncodingAlias(request)
+      )
+    );
+  },
+  ...buildAndSignMethods("dogecoin"),
+  ...signMessageMethods("dogecoin"),
+  ...signBytesMethods("dogecoin"),
+  ...jsonTxMethods("dogecoin"),
+};
+
+export const starknet = {
+  ...deriveMethods("starknet"),
+  ...buildAndSignMethods("starknet"),
+  ...signMessageMethods("starknet"),
+  ...signBytesMethods("starknet"),
+  ...jsonTxMethods("starknet"),
+  computeAccountAddress(payload) {
+    return parseJsonResult(
+      invokeChainExtension("starknet", "starknet.computeAccountAddress", payload)
+    );
+  },
+};
+
+export const stellar = {
+  ...deriveMethods("stellar"),
+  ...buildAndSignMethods("stellar"),
+  ...signMessageMethods("stellar"),
+  ...signBytesMethods("stellar"),
+  ...jsonTxMethods("stellar"),
+};
+
+export const sui = {
+  ...deriveMethods("sui"),
+  ...buildAndSignMethods("sui"),
+  ...signMessageMethods("sui"),
+  ...signBytesMethods("sui"),
+  ...jsonTxMethods("sui"),
+};
+
+export const xrpl = {
+  ...deriveMethods("xrpl"),
+  ...buildAndSignMethods("xrpl"),
+  ...jsonTxMethods("xrpl"),
+};
+
+function inferTonMnemonicType(request = {}) {
+  if (
+    request &&
+    typeof request === "object" &&
+    typeof request.mnemonic === "string" &&
+    request.mnemonicType == null &&
+    request.mnemonic_type == null
+  ) {
+    const wordCount = request.mnemonic.trim().split(/\s+/).filter(Boolean).length;
+    if ([12, 15, 18, 21].includes(wordCount)) {
+      return {
+        ...request,
+        mnemonicType: "bip39",
+      };
+    }
+  }
+  return request;
+}
+
+function withTonKeyEncoding(request = {}) {
+  if (
+    request &&
+    typeof request === "object" &&
+    request.privateKeyEncoding != null &&
+    request.keyEncoding == null
+  ) {
+    const { privateKeyEncoding, ...rest } = request;
+    return {
+      ...rest,
+      keyEncoding: privateKeyEncoding,
+    };
+  }
+  return request;
+}
+
+function withKeyEncodingAlias(request = {}) {
+  if (
+    request &&
+    typeof request === "object" &&
+    request.privateKeyEncoding != null &&
+    request.keyEncoding == null
+  ) {
+    const { privateKeyEncoding, ...rest } = request;
+    return {
+      ...rest,
+      keyEncoding: privateKeyEncoding,
+    };
+  }
+  return request;
+}
+
+function pickTonSignerFields(request = {}) {
+  return inferTonMnemonicType({
+    mnemonic: request.mnemonic,
+    mnemonicType: request.mnemonicType,
+    derivationPath: request.derivationPath,
+    account: request.account,
+    index: request.index,
+    passphrase: request.passphrase,
+  });
+}
+
+function parsePayloadObject(value) {
+  if (typeof value !== "string") {
+    return value ?? {};
+  }
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new WalletWasmError({
+      code: "SERIALIZATION_FAILED",
+      message: "failed to parse TON txPayload JSON",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+function base64ToBytes(value) {
+  const binary =
+    typeof atob === "function"
+      ? atob(value)
+      : Buffer.from(value, "base64").toString("binary");
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+function deriveMethods(chainId) {
+  return {
+    deriveAddress(request) {
+      return deriveAddress(withChain(chainId, request));
+    },
+    deriveWallet(request) {
+      return deriveWallet(withChain(chainId, request));
+    },
+    deriveAddressFromPrivateKey(request) {
+      return deriveAddressFromPrivateKey(withChain(chainId, request));
+    },
+    deriveWalletFromPrivateKey(request) {
+      return deriveWalletFromPrivateKey(withChain(chainId, request));
+    },
+  };
+}
+
+function buildAndSignMethods(chainId) {
+  return {
+    buildAndSign(request) {
+      return buildAndSign(withChain(chainId, request));
+    },
+    buildAndSignFromPrivateKey(request) {
+      return buildAndSignFromPrivateKey(withChain(chainId, request));
+    },
+  };
+}
+
+function signMessageMethods(chainId) {
+  return {
+    signMessage(request) {
+      return signMessage(withChain(chainId, request));
+    },
+    signMessageFromPrivateKey(request) {
+      return signMessageFromPrivateKey(withChain(chainId, request));
+    },
+  };
+}
+
+function signBytesMethods(chainId) {
+  return {
+    signBytes(request) {
+      return signBytes(withChain(chainId, request));
+    },
+    signBytesFromPrivateKey(request) {
+      return signBytesFromPrivateKey(withChain(chainId, request));
+    },
+  };
+}
+
+function signTypedDataMethods(chainId) {
+  return {
+    signTypedData(request) {
+      return signTypedData(withChain(chainId, request));
+    },
+    signTypedDataFromPrivateKey(request) {
+      return signTypedDataFromPrivateKey(withChain(chainId, request));
+    },
+  };
+}
+
+function jsonTxMethods(chainId) {
+  return {
+    buildTx(payload) {
+      return parseJsonResult(invokeChainExtension(chainId, `${chainId}.buildTx`, payload));
+    },
+    signTx(payload) {
+      return parseJsonResult(invokeChainExtension(chainId, `${chainId}.signTx`, payload));
+    },
+    inspectSignedTx(payload) {
+      return parseJsonResult(
+        invokeChainExtension(chainId, `${chainId}.inspectSignedTx`, payload)
+      );
+    },
+    decodeSignedTx(payload) {
+      return parseJsonResult(
+        invokeChainExtension(chainId, `${chainId}.decodeSignedTx`, payload)
+      );
+    },
+  };
+}
+
+function wasmForRequest(request = {}) {
+  return wasmForChain(request.chainId);
+}
+
+function wasmForChain(chainId) {
+  return chainId === "cardano" ? cardanoWasm : coreWasm;
+}
+
+function mergeByChainId(items) {
+  return Array.from(new Map(items.map((item) => [item.chainId, item])).values()).sort((a, b) =>
+    a.chainId.localeCompare(b.chainId)
+  );
+}
+
+function ensureInitialized() {
+  if (!initialized) {
+    throw new WalletWasmError({
+      code: "NOT_INITIALIZED",
+      message: "wallet WASM module is not initialized; call init() first",
+      details: null,
+    });
+  }
+}
+
+function callWasm(fn) {
+  try {
+    return fn();
+  } catch (error) {
+    throw normalizeError(error);
+  }
+}
+
+function normalizeError(error) {
+  if (error instanceof WalletWasmError) {
+    return error;
+  }
+  const raw =
+    typeof error === "string"
+      ? error
+      : typeof error?.message === "string"
+        ? error.message
+        : String(error);
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.code === "string" && typeof parsed.message === "string") {
+      return new WalletWasmError(parsed);
+    }
+  } catch {
+    // Fall through to a stable wrapper for non-JSON wasm-bindgen errors.
+  }
+  return new WalletWasmError({
+    code: "INTERNAL",
+    message: raw,
+    details: null,
+  });
+}
+
+function parseJsonResult(value) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new WalletWasmError({
+      code: "SERIALIZATION_FAILED",
+      message: "failed to parse WASM SDK JSON result",
+      details: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+function toJson(value) {
+  return typeof value === "string" ? value : JSON.stringify(value ?? {});
+}
+
+function withChain(chainId, request = {}) {
+  return {
+    ...request,
+    chainId,
+  };
+}