@miden-sdk/para 0.0.0-bootstrap → 0.16.0-rc.6

package/dist/cjs/utils.js

@@ -0,0 +1,141 @@
+"use strict";
+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 __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 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __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 || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  accountSeedFromStr: () => accountSeedFromStr,
+  evmPkToCommitment: () => evmPkToCommitment,
+  fromHexSig: () => fromHexSig,
+  getUncompressedPublicKeyFromWallet: () => getUncompressedPublicKeyFromWallet,
+  hexToBytes: () => import_utils.hexToBytes,
+  txSummaryToJson: () => txSummaryToJson
+});
+module.exports = __toCommonJS(utils_exports);
+var import_utils = require("@noble/hashes/utils.js");
+const fromHexSig = (hexString) => {
+  if (hexString.length % 2 !== 0) {
+    throw new Error("Invalid string len");
+  }
+  const sigBytes = (0, import_utils.hexToBytes)(hexString);
+  const serialized = new Uint8Array(sigBytes.length + 2);
+  serialized[0] = 1;
+  serialized.set(sigBytes, 1);
+  return serialized;
+};
+const accountSeedFromStr = (str) => {
+  if (!str) return;
+  const buffer = new Uint8Array(32);
+  const bytes = (0, import_utils.utf8ToBytes)(str);
+  buffer.set(bytes.slice(0, 32));
+  return buffer;
+};
+const evmPkToCommitment = async (uncompressedPublicKey) => {
+  const { Felt, Poseidon2, FeltArray } = await import("@miden-sdk/miden-sdk");
+  const withoutPrefix = uncompressedPublicKey.slice(4);
+  const x = withoutPrefix.slice(0, 64);
+  const y = withoutPrefix.slice(64);
+  const felts = [...coordToLimbs(x), ...coordToLimbs(y)].map(
+    (limb) => new Felt(BigInt(limb))
+  );
+  return Poseidon2.hashElements(new FeltArray(felts));
+};
+const coordToLimbs = (hex) => {
+  const bytes = (0, import_utils.hexToBytes)(hex);
+  if (bytes.length !== 32) {
+    throw new Error(`Expected a 32-byte coordinate, got ${bytes.length}`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const limbs = [];
+  for (let i = 7; i >= 0; i--) {
+    limbs.push(view.getUint32(i * 4, false));
+  }
+  return limbs;
+};
+const getUncompressedPublicKeyFromWallet = async (para, wallet) => {
+  if (wallet.publicKey) {
+    return wallet.publicKey;
+  }
+  const { token } = await para.issueJwt();
+  const payload = JSON.parse(window.atob(token.split(".")[1]));
+  const wallets = payload.data?.connectedWallets;
+  if (!wallets) {
+    throw new Error("Got invalid jwt token");
+  }
+  const w = wallets.find((connected) => connected.id === wallet.id);
+  if (!w) {
+    throw new Error("Wallet Not Found in jwt data");
+  }
+  if (!w.publicKey) {
+    throw new Error("Wallet in jwt data has no public key");
+  }
+  return w.publicKey;
+};
+const txSummaryToJson = (txSummary) => {
+  const inputNotes = txSummary.inputNotes().notes().map((inputNote) => ({
+    id: inputNote.id().toString(),
+    assets: inputNote.note().assets().fungibleAssets().map((asset) => {
+      return {
+        assetId: asset.faucetId().toString(),
+        amount: asset.amount().toString()
+      };
+    }),
+    sender: inputNote.note().metadata().sender().toString()
+  }));
+  const outputNotes = txSummary.outputNotes().notes().map((outputNote) => {
+    const assets = outputNote.assets();
+    if (!assets) {
+      throw new Error(
+        `Output note ${outputNote.id().toString()} carries no asset data; refusing to summarize a transaction whose assets are unknown`
+      );
+    }
+    return {
+      id: outputNote.id().toString(),
+      assets: assets.fungibleAssets().map((asset) => {
+        return {
+          assetId: asset.faucetId().toString(),
+          amount: asset.amount().toString()
+        };
+      }),
+      noteType: noteTypeToString(outputNote.metadata().noteType())
+    };
+  });
+  return {
+    inputNotes,
+    outputNotes
+  };
+};
+function noteTypeToString(noteType) {
+  switch (noteType) {
+    case 1:
+      return "public";
+    case 0:
+      return "private";
+    default:
+      return "UNKNOWN";
+  }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./midenClient.js";
+export { evmPkToCommitment, getUncompressedPublicKeyFromWallet, } from "./utils.js";
+export type { MidenAccountOpts, Opts, MidenAccountStorageMode, TxSummaryJson, } from "./types.js";
+export type { CustomSignConfirmStep } from "./midenClient.js";

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+export * from "./midenClient.js";
+import {
+  evmPkToCommitment,
+  getUncompressedPublicKeyFromWallet
+} from "./utils.js";
+export {
+  evmPkToCommitment,
+  getUncompressedPublicKeyFromWallet
+};

package/dist/esm/midenClient.d.ts

@@ -0,0 +1,19 @@
+import { ParaWeb, Wallet } from "@getpara/web-sdk";
+import type { Opts, TxSummaryJson } from "./types.js";
+import type { MidenClient } from "@miden-sdk/miden-sdk";
+export type CustomSignConfirmStep = (txSummaryJson: TxSummaryJson) => Promise<unknown>;
+/**
+ * Creates a signing callback that routes Miden signing requests through Para.
+ * Prompts the user with a modal before delegating the keccak-hashed message to Para's signer,
+ * and optionally runs a custom confirmation step in between.
+ */
+export declare const signCb: (para: ParaWeb, wallet: Wallet, showSigningModal: boolean, customSignConfirmStep?: CustomSignConfirmStep) => (_: Uint8Array, signingInputs: Uint8Array) => Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * Builds a MidenClient wired to Para wallets and ensures an account exists for the user.
+ * Filters to EVM wallets, prompts for selection, creates the client, and
+ * hydrates or creates the corresponding Miden account before returning the client + account id.
+ */
+export declare function createParaMidenClient(para: ParaWeb, wallets: Wallet[], opts: Opts, showSigningModal?: boolean, customSignConfirmStep?: CustomSignConfirmStep): Promise<{
+    client: MidenClient;
+    accountId: string;
+}>;

package/dist/esm/midenClient.js

@@ -0,0 +1,109 @@
+import {
+  hexStringToBase64
+} from "@getpara/web-sdk";
+import { keccak_256 as keccak256 } from "@noble/hashes/sha3.js";
+import {
+  accountSeedFromStr,
+  evmPkToCommitment,
+  fromHexSig,
+  getUncompressedPublicKeyFromWallet,
+  txSummaryToJson
+} from "./utils.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { accountSelectionModal, signingModal } from "./modalClient.js";
+const signCb = (para, wallet, showSigningModal, customSignConfirmStep) => {
+  return async (_, signingInputs) => {
+    const { SigningInputs } = await import("@miden-sdk/miden-sdk");
+    const inputs = SigningInputs.deserialize(signingInputs);
+    let commitment = inputs.toCommitment().toHex().slice(2);
+    const hashed = bytesToHex(keccak256(hexToBytes(commitment)));
+    const txSummaryJson = txSummaryToJson(inputs.transactionSummaryPayload());
+    if (showSigningModal) {
+      const confirmed = await signingModal(txSummaryJson);
+      if (!confirmed) {
+        throw new Error("User cancelled signing");
+      }
+    }
+    if (customSignConfirmStep) {
+      await customSignConfirmStep(txSummaryJson);
+    }
+    console.time("Para Signing Time");
+    const res = await para.signMessage({
+      walletId: wallet.id,
+      messageBase64: hexStringToBase64(hashed)
+    });
+    console.timeEnd("Para Signing Time");
+    const signature = res.signature;
+    const sig = fromHexSig(signature);
+    return sig;
+  };
+};
+async function createAccount(client, publicKey, opts) {
+  const { AccountBuilder, AccountComponent, AccountStorageMode } = await import("@miden-sdk/miden-sdk");
+  await client.sync();
+  let pkc = await evmPkToCommitment(publicKey);
+  const accountBuilder = new AccountBuilder(
+    accountSeedFromStr(opts.accountSeed) ?? new Uint8Array(32).fill(0)
+  );
+  const accountStorageMode = opts.storageMode === "private" ? AccountStorageMode.private() : AccountStorageMode.public();
+  const account = accountBuilder.withAuthComponent(
+    AccountComponent.createAuthComponentFromCommitment(pkc, 1)
+  ).storageMode(accountStorageMode).withBasicWalletComponent().build().account;
+  if (opts.storageMode !== "private") {
+    try {
+      await client.accounts.import(account);
+    } catch {
+    }
+  }
+  const existing = await client.accounts.get(account.id());
+  if (!existing) {
+    await client.accounts.insert({ account });
+  }
+  await client.sync();
+  return account.id().toString();
+}
+async function createParaMidenClient(para, wallets, opts, showSigningModal = true, customSignConfirmStep) {
+  const evmWallets = wallets.filter((wallet2) => wallet2.type === "EVM");
+  if (!evmWallets?.length) {
+    throw new Error("No EVM wallets provided");
+  }
+  const accountKeys = await Promise.all(
+    evmWallets.map((w) => getUncompressedPublicKeyFromWallet(para, w))
+  );
+  const selectedIndex = await accountSelectionModal(accountKeys);
+  const wallet = evmWallets[selectedIndex] ?? evmWallets[0];
+  const publicKey = accountKeys[selectedIndex] ?? accountKeys[0];
+  const { MidenClient } = await import("@miden-sdk/miden-sdk");
+  if (opts.storageMode === "private" && !opts.accountSeed) {
+    throw new Error("accountSeed is required when using private storage mode");
+  }
+  const signCallback = signCb(
+    para,
+    wallet,
+    showSigningModal,
+    customSignConfirmStep
+  );
+  const noteTransportUrl = opts.noteTransportUrl || opts.nodeTransportUrl || "https://transport.miden.io";
+  const client = await MidenClient.create({
+    rpcUrl: opts.endpoint,
+    noteTransportUrl,
+    seed: accountSeedFromStr(opts.seed),
+    keystore: {
+      getKey: async () => void 0,
+      insertKey: async () => {
+      },
+      sign: signCallback
+    },
+    autoSync: true
+  });
+  const accountId = await createAccount(
+    client,
+    publicKey,
+    opts
+  );
+  return { client, accountId };
+}
+export {
+  createParaMidenClient,
+  signCb
+};

package/dist/esm/modalClient.d.ts

@@ -0,0 +1,11 @@
+import { TxSummaryJson } from "./types.js";
+/**
+ * Shows a lightweight confirmation modal for signing a hashed transaction.
+ * Resolves to true when the user confirms, false when cancelled; no-op on the server.
+ */
+export declare const signingModal: (txSummaryJson: TxSummaryJson) => Promise<boolean>;
+/**
+ * Shows a selectable list of account commitments and resolves with the chosen index.
+ * Returns 0 immediately when only one account is provided or when running server-side.
+ */
+export declare const accountSelectionModal: (accounts: string[]) => Promise<number>;

package/dist/esm/modalClient.js

@@ -0,0 +1,233 @@
+const createModalShell = (titleText) => {
+  const existing = document.getElementById("para-signing-modal");
+  if (existing) existing.remove();
+  const overlay = document.createElement("div");
+  overlay.id = "para-signing-modal";
+  Object.assign(overlay.style, {
+    position: "fixed",
+    inset: "0",
+    background: "rgba(0, 0, 0, 0.6)",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: "9999",
+    padding: "16px",
+    boxSizing: "border-box",
+    color: "#0f172a",
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif'
+  });
+  const modal = document.createElement("div");
+  Object.assign(modal.style, {
+    background: "#f8fafc",
+    borderRadius: "12px",
+    padding: "20px",
+    maxWidth: "420px",
+    width: "100%",
+    boxShadow: "0 12px 40px rgba(15, 23, 42, 0.25)"
+  });
+  const title = document.createElement("div");
+  title.textContent = titleText;
+  Object.assign(title.style, {
+    fontSize: "16px",
+    fontWeight: "600",
+    marginBottom: "12px"
+  });
+  modal.append(title);
+  overlay.append(modal);
+  return { overlay, modal };
+};
+const createActionsRow = () => {
+  const actions = document.createElement("div");
+  Object.assign(actions.style, {
+    display: "flex",
+    gap: "10px",
+    justifyContent: "flex-end"
+  });
+  return actions;
+};
+const createPrimaryButton = (label) => {
+  const button = document.createElement("button");
+  button.textContent = label;
+  Object.assign(button.style, {
+    padding: "10px 16px",
+    borderRadius: "8px",
+    border: "none",
+    background: "#0ea5e9",
+    color: "#fff",
+    cursor: "pointer",
+    fontWeight: "600"
+  });
+  return button;
+};
+const createSecondaryButton = (label) => {
+  const button = document.createElement("button");
+  button.textContent = label;
+  Object.assign(button.style, {
+    padding: "10px 16px",
+    borderRadius: "8px",
+    border: "1px solid #cbd5e1",
+    background: "#fff",
+    color: "#0f172a",
+    cursor: "pointer",
+    fontWeight: "600"
+  });
+  return button;
+};
+const signingModal = (txSummaryJson) => {
+  if (typeof document === "undefined") return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const { overlay, modal } = createModalShell(
+      "Do you want to sign this transaction?"
+    );
+    const txDetails = document.createElement("div");
+    Object.assign(txDetails.style, {
+      fontSize: "13px",
+      fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+      background: "#e2e8f0",
+      padding: "10px",
+      borderRadius: "8px",
+      marginBottom: "16px",
+      color: "#0f172a",
+      maxHeight: "300px",
+      overflowY: "auto"
+    });
+    const inputSection = document.createElement("div");
+    inputSection.style.marginBottom = "12px";
+    const inputTitle = document.createElement("div");
+    inputTitle.textContent = "Input Notes:";
+    inputTitle.style.fontWeight = "600";
+    inputTitle.style.marginBottom = "4px";
+    inputSection.append(inputTitle);
+    if (txSummaryJson.inputNotes.length === 0) {
+      const noInputs = document.createElement("div");
+      noInputs.textContent = "None";
+      noInputs.style.color = "#64748b";
+      inputSection.append(noInputs);
+    } else {
+      txSummaryJson.inputNotes.forEach((note, idx) => {
+        const noteDiv = document.createElement("div");
+        noteDiv.style.marginBottom = "8px";
+        noteDiv.style.paddingLeft = "8px";
+        noteDiv.innerHTML = `
+          <div><strong>Note ${idx + 1}:</strong> ${note.id}</div>
+          <div style="padding-left: 8px; color: #475569;">
+            Sender: ${note.sender}<br/>
+            Assets: ${note.assets.map((a) => `${a.amount} of ${a.assetId}`).join(", ") || "None"}
+          </div>
+        `;
+        inputSection.append(noteDiv);
+      });
+    }
+    const outputSection = document.createElement("div");
+    const outputTitle = document.createElement("div");
+    outputTitle.textContent = "Output Notes:";
+    outputTitle.style.fontWeight = "600";
+    outputTitle.style.marginBottom = "4px";
+    outputSection.append(outputTitle);
+    if (txSummaryJson.outputNotes.length === 0) {
+      const noOutputs = document.createElement("div");
+      noOutputs.textContent = "None";
+      noOutputs.style.color = "#64748b";
+      outputSection.append(noOutputs);
+    } else {
+      txSummaryJson.outputNotes.forEach((note, idx) => {
+        const noteDiv = document.createElement("div");
+        noteDiv.style.marginBottom = "8px";
+        noteDiv.style.paddingLeft = "8px";
+        noteDiv.innerHTML = `
+          <div><strong>Note ${idx + 1}:</strong> ${note.id}</div>
+          <div style="padding-left: 8px; color: #475569;">
+            Type: ${note.noteType}<br/>
+            Assets: ${note.assets.map((a) => `${a.amount} of ${a.assetId}`).join(", ") || "None"}
+          </div>
+        `;
+        outputSection.append(noteDiv);
+      });
+    }
+    txDetails.append(inputSection, outputSection);
+    const actions = createActionsRow();
+    const yesBtn = createPrimaryButton("Yes");
+    const noBtn = createSecondaryButton("No");
+    const cleanup = () => {
+      overlay.remove();
+    };
+    yesBtn.onclick = () => {
+      cleanup();
+      resolve(true);
+    };
+    noBtn.onclick = () => {
+      cleanup();
+      resolve(false);
+    };
+    actions.append(noBtn, yesBtn);
+    modal.append(txDetails, actions);
+    document.body.append(overlay);
+  });
+};
+const accountSelectionModal = (accounts) => {
+  if (accounts.length === 1 || typeof document === "undefined") {
+    return Promise.resolve(0);
+  }
+  return new Promise((resolve) => {
+    const { overlay, modal } = createModalShell("Choose an account to use");
+    const list = document.createElement("div");
+    Object.assign(list.style, {
+      display: "flex",
+      flexDirection: "column",
+      gap: "8px",
+      marginBottom: "16px"
+    });
+    let selectedIndex = 0;
+    const items = [];
+    const highlightSelection = () => {
+      items.forEach((item, idx) => {
+        item.style.borderColor = idx === selectedIndex ? "#0ea5e9" : "#cbd5e1";
+        item.style.background = idx === selectedIndex ? "#e0f2fe" : "#e2e8f0";
+      });
+    };
+    const okBtn = createPrimaryButton("Ok");
+    okBtn.disabled = !accounts.length;
+    accounts.forEach((account, index) => {
+      const item = document.createElement("button");
+      item.type = "button";
+      item.textContent = account;
+      Object.assign(item.style, {
+        padding: "10px",
+        borderRadius: "8px",
+        border: "1px solid #cbd5e1",
+        background: "#e2e8f0",
+        fontSize: "13px",
+        fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+        color: "#0f172a",
+        wordBreak: "break-all",
+        textAlign: "left",
+        cursor: "pointer"
+      });
+      item.onclick = () => {
+        selectedIndex = index;
+        highlightSelection();
+        okBtn.disabled = false;
+      };
+      items.push(item);
+      list.append(item);
+    });
+    if (items.length) {
+      highlightSelection();
+    }
+    const actions = createActionsRow();
+    const cleanup = () => {
+      overlay.remove();
+    };
+    okBtn.onclick = () => {
+      cleanup();
+      resolve(selectedIndex);
+    };
+    actions.append(okBtn);
+    modal.append(list, actions);
+    document.body.append(overlay);
+  });
+};
+export {
+  accountSelectionModal,
+  signingModal
+};

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": false
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,34 @@
+/** @public */
+export interface MidenClientOpts {
+    endpoint?: string;
+    noteTransportUrl?: string;
+    /**
+     * @deprecated Use noteTransportUrl instead
+     */
+    nodeTransportUrl?: string;
+    seed?: string;
+}
+export type MidenAccountStorageMode = "public" | "private";
+export interface MidenAccountOpts {
+    accountSeed?: string;
+    storageMode: MidenAccountStorageMode;
+}
+export type Opts = MidenClientOpts & MidenAccountOpts;
+interface NoteIdAndAsset {
+    id: string;
+    assets: {
+        assetId: string;
+        amount: string;
+    }[];
+}
+interface InputNoteSender {
+    sender: string;
+}
+interface OutputNoteType {
+    noteType: string;
+}
+export interface TxSummaryJson {
+    inputNotes: (NoteIdAndAsset & InputNoteSender)[];
+    outputNotes: (NoteIdAndAsset & OutputNoteType)[];
+}
+export {};

package/dist/esm/utils.d.ts

@@ -0,0 +1,33 @@
+import ParaWeb, { Wallet } from "@getpara/web-sdk";
+import type { TransactionSummary } from "@miden-sdk/miden-sdk";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { TxSummaryJson } from "./types.js";
+/** @public */
+export { hexToBytes };
+/**
+ * Converts a Para hex signature into the serialized format expected by Miden.
+ * Prefixes the auth scheme byte and appends the extra padding byte required by current crypto libs.
+ */
+export declare const fromHexSig: (hexString: string) => Uint8Array<ArrayBuffer>;
+/**
+ * Derives a 32-byte seed buffer from a UTF-8 string, truncating when longer than 32 bytes.
+ */
+export declare const accountSeedFromStr: (str?: string) => Uint8Array<ArrayBuffer> | undefined;
+/**
+ * Converts an uncompressed EVM public key into a Miden commitment.
+ * Assumes input format `0x04${x}${y}` where x and y are 64-char hex strings.
+ *
+ * The protocol commits to the affine point as Poseidon2 over 16 field elements:
+ * the x coordinate then the y coordinate, each as eight 32-bit limbs in
+ * little-endian limb order. 0.15 hashed a different preimage — nine felts
+ * packed from the 33-byte compressed SEC1 encoding — so a commitment computed
+ * by an older release will not match one computed here.
+ */
+export declare const evmPkToCommitment: (uncompressedPublicKey: string) => Promise<import("@miden-sdk/miden-sdk").Word>;
+/**
+ * Retrieves the uncompressed public key for a Para wallet, falling back to JWT data when absent.
+ * Throws rather than returning undefined: callers derive the account commitment from this value,
+ * so an absent key is an error, not a state to propagate.
+ */
+export declare const getUncompressedPublicKeyFromWallet: (para: ParaWeb, wallet: Wallet) => Promise<string>;
+export declare const txSummaryToJson: (txSummary: TransactionSummary) => TxSummaryJson;