@getpara/web-sdk 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/LocalStorage.js

@@ -0,0 +1,36 @@
+"use client";
+import "./chunk-WLGKV3EF.js";
+class LocalStorage {
+  constructor() {
+    this.get = (key) => {
+      if (typeof window !== "undefined") {
+        return localStorage.getItem(key) || null;
+      }
+      return null;
+    };
+    this.set = (key, value) => {
+      if (typeof window !== "undefined") {
+        localStorage.setItem(key, value);
+      }
+    };
+    this.removeItem = (key) => {
+      if (typeof window !== "undefined") {
+        localStorage.removeItem(key);
+      }
+    };
+    this.clear = (prefix) => {
+      if (typeof window !== "undefined") {
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key && key.startsWith(prefix)) {
+            localStorage.removeItem(key);
+            i--;
+          }
+        }
+      }
+    };
+  }
+}
+export {
+  LocalStorage
+};

package/dist/ParaWeb.d.ts

@@ -1,6 +1,15 @@
 import ParaCore, { ConstructorOpts, Environment } from '@getpara/core-sdk';
 import { WebUtils } from './WebUtils.js';
 export declare class Para extends ParaCore {
+    #private;
+    farcasterSdk: any;
+    isReady: boolean;
+    isFarcasterMiniApp: boolean;
     constructor(env: Environment, apiKey?: string, opts?: ConstructorOpts);
+    protected ready(): Promise<void>;
+    protected get toStringAdditions(): {
+        isFarcasterMiniApp: boolean;
+    };
     protected getPlatformUtils(): WebUtils;
+    isPasskeySupported(): Promise<boolean>;
 }

package/dist/ParaWeb.js

@@ -0,0 +1,71 @@
+"use client";
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-WLGKV3EF.js";
+var _isPasskeySupported;
+import * as Sentry from "@sentry/browser";
+import ParaCore, { Environment } from "@getpara/core-sdk";
+import { WebUtils } from "./WebUtils.js";
+import { isPasskeySupported } from "./utils/isPasskeySupported.js";
+class Para extends ParaCore {
+  constructor(env, apiKey, opts) {
+    super(env, apiKey, opts);
+    this.farcasterSdk = void 0;
+    this.isReady = false;
+    this.isFarcasterMiniApp = false;
+    __privateAdd(this, _isPasskeySupported);
+    if (env !== Environment.PROD && env !== Environment.DEV) {
+      Sentry.init({
+        environment: env.toLowerCase(),
+        dsn: "https://38f27d4836da617ab9e95cf66b9611d9@o4504568036720640.ingest.us.sentry.io/4508850812944384"
+      });
+    }
+  }
+  ready() {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      if (!this.isReady) {
+        try {
+          this.farcasterSdk = (_b = (_a = yield import("@farcaster/miniapp-sdk")) == null ? void 0 : _a.sdk) != null ? _b : void 0;
+          if (!((_c = this.farcasterSdk) == null ? void 0 : _c.isInMiniApp)) {
+            throw new Error("Farcaster SDK not detected or failed to load");
+          }
+          this.devLog("Farcaster SDK detected and loaded successfully.", this.farcasterSdk);
+        } catch (e) {
+          this.devLog(e);
+        }
+        if (!!((_d = this.farcasterSdk) == null ? void 0 : _d.isInMiniApp)) {
+          this.devLog("Initializing Farcaster SDK...");
+          this.isFarcasterMiniApp = yield this.farcasterSdk.isInMiniApp();
+          if (this.isFarcasterMiniApp) {
+            this.externalWalletConnectionOnly = true;
+          }
+        }
+        this.isReady = true;
+      }
+    });
+  }
+  get toStringAdditions() {
+    return {
+      isFarcasterMiniApp: this.isFarcasterMiniApp
+    };
+  }
+  getPlatformUtils() {
+    return new WebUtils();
+  }
+  isPasskeySupported() {
+    return __async(this, null, function* () {
+      if (__privateGet(this, _isPasskeySupported) === void 0) {
+        __privateSet(this, _isPasskeySupported, yield isPasskeySupported());
+      }
+      return __privateGet(this, _isPasskeySupported);
+    });
+  }
+}
+_isPasskeySupported = new WeakMap();
+export {
+  Para
+};

package/dist/SessionStorage.js

@@ -0,0 +1,36 @@
+"use client";
+import "./chunk-WLGKV3EF.js";
+class SessionStorage {
+  constructor() {
+    this.get = (key) => {
+      if (typeof window !== "undefined") {
+        return sessionStorage.getItem(key) || null;
+      }
+      return null;
+    };
+    this.set = (key, value) => {
+      if (typeof window !== "undefined") {
+        sessionStorage.setItem(key, value);
+      }
+    };
+    this.removeItem = (key) => {
+      if (typeof window !== "undefined") {
+        sessionStorage.removeItem(key);
+      }
+    };
+    this.clear = (prefix) => {
+      if (typeof window !== "undefined") {
+        for (let i = 0; i < sessionStorage.length; i++) {
+          const key = sessionStorage.key(i);
+          if (key && key.startsWith(prefix)) {
+            sessionStorage.removeItem(key);
+            i--;
+          }
+        }
+      }
+    };
+  }
+}
+export {
+  SessionStorage
+};

package/dist/WebUtils.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="node" />
 import { Ctx, PlatformUtils, SignatureRes, PopupType } from '@getpara/core-sdk';
 import { LocalStorage } from './LocalStorage.js';
 import { SessionStorage } from './SessionStorage.js';
-import { BackupKitEmailProps, WalletType } from '@getpara/user-management-client';
+import { BackupKitEmailProps, TWalletType, SDKType } from '@getpara/user-management-client';
 import { TPregenIdentifierType } from '@getpara/core-sdk';
 export declare class WebUtils implements PlatformUtils {
+    sdkType: SDKType;
     getPrivateKey(ctx: Ctx, userId: string, walletId: string, share: string, sessionCookie: string): Promise<string>;
-    keygen(ctx: Ctx, userId: string, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    keygen(ctx: Ctx, userId: string, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
     sessionCookie: string, emailProps?: BackupKitEmailProps): Promise<{
         signer: string;
         walletId: string;
@@ -14,7 +14,7 @@ export declare class WebUtils implements PlatformUtils {
     refresh(ctx: Ctx, sessionCookie: string, userId: string, walletId: string, share: string, oldPartnerId?: string, newPartnerId?: string, keyShareProtocolId?: string): Promise<{
         signer: string;
     }>;
-    preKeygen(ctx: Ctx, partnerId: string | undefined, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<WalletType, WalletType.SOLANA>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
+    preKeygen(ctx: Ctx, partnerId: string | undefined, pregenIdentifier: string, pregenIdentifierType: TPregenIdentifierType, type: Exclude<TWalletType, 'SOLANA'>, secretKey: string | null, // should be acceptable as null in RN as we don't pre-gen them
     sessionCookie: string): Promise<{
         signer: string;
         walletId: string;

package/dist/WebUtils.js

@@ -0,0 +1,110 @@
+"use client";
+import "./chunk-WLGKV3EF.js";
+import { PopupType } from "@getpara/core-sdk";
+import { LocalStorage } from "./LocalStorage.js";
+import { SessionStorage } from "./SessionStorage.js";
+import { keygen, preKeygen, ed25519Keygen, ed25519PreKeygen, refresh } from "./wallet/keygen.js";
+import { signMessage, sendTransaction, signTransaction, ed25519Sign } from "./wallet/signing.js";
+import { getPrivateKey } from "./wallet/privateKey.js";
+class WebUtils {
+  constructor() {
+    this.sdkType = "WEB";
+    this.localStorage = new LocalStorage();
+    this.sessionStorage = new SessionStorage();
+    this.secureStorage = null;
+    this.isSyncStorage = true;
+    this.disableProviderModal = false;
+  }
+  getPrivateKey(ctx, userId, walletId, share, sessionCookie) {
+    return getPrivateKey(ctx, userId, walletId, share, sessionCookie);
+  }
+  keygen(ctx, userId, type, secretKey, sessionCookie, emailProps = {}) {
+    return keygen(ctx, userId, type, secretKey, true, sessionCookie, emailProps);
+  }
+  refresh(ctx, sessionCookie, userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId) {
+    return refresh(ctx, sessionCookie, userId, walletId, share, oldPartnerId, newPartnerId, keyShareProtocolId);
+  }
+  preKeygen(ctx, partnerId, pregenIdentifier, pregenIdentifierType, type, secretKey, sessionCookie) {
+    return preKeygen(ctx, pregenIdentifier, pregenIdentifierType, type, secretKey, false, partnerId, sessionCookie);
+  }
+  signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS, cosmosSignDoc) {
+    return signMessage(ctx, userId, walletId, share, message, sessionCookie, isDKLS, cosmosSignDoc);
+  }
+  signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+    return signTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS);
+  }
+  sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS) {
+    return sendTransaction(ctx, userId, walletId, share, tx, chainId, sessionCookie, isDKLS);
+  }
+  signHash(_address, _hash) {
+    throw new Error("not implemented");
+  }
+  ed25519Keygen(ctx, userId, sessionCookie, emailProps) {
+    return ed25519Keygen(ctx, userId, sessionCookie, emailProps);
+  }
+  ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie) {
+    return ed25519PreKeygen(ctx, pregenIdentifier, pregenIdentifierType, sessionCookie);
+  }
+  ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie) {
+    return ed25519Sign(ctx, userId, walletId, share, base64Bytes, sessionCookie);
+  }
+  openPopup(popupUrl, opts) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (opts) {
+      const { type } = opts;
+      const popUpWidth = 550;
+      let popUpHeight;
+      switch (type) {
+        case PopupType.LOGIN_PASSKEY: {
+          popUpHeight = 798;
+          break;
+        }
+        case PopupType.CREATE_PASSKEY: {
+          popUpHeight = 464;
+          break;
+        }
+        case PopupType.SIGN_MESSAGE_REVIEW: {
+          popUpHeight = 585;
+          break;
+        }
+        case PopupType.SIGN_TRANSACTION_REVIEW: {
+          popUpHeight = 750;
+          break;
+        }
+        case PopupType.OAUTH:
+        default: {
+          popUpHeight = 768;
+          break;
+        }
+      }
+      const dualScreenLeft = window.screenLeft !== void 0 ? window.screenLeft : window.screenX;
+      const dualScreenTop = window.screenTop !== void 0 ? window.screenTop : window.screenY;
+      const width = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width;
+      const height = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height;
+      const left = (width - popUpWidth) / 2 + dualScreenLeft;
+      const top = (height - popUpHeight) / 2 + dualScreenTop;
+      const windowFeatures = `toolbar=no, menubar=no, width=${popUpWidth}, 
+    height=${popUpHeight}, top=${top}, left=${left}`;
+      let popupWindow = window.open(popupUrl, type.toString(), windowFeatures);
+      if (!popupWindow) {
+        setTimeout(() => {
+          popupWindow = window.open(popupUrl, "_blank");
+        }, 0);
+      }
+      return popupWindow;
+    } else {
+      const popupWindow = window.open(popupUrl, "popup", "popup=true,width=400,height=500");
+      if (!popupWindow) {
+        setTimeout(() => {
+          window.open(popupUrl, "_blank");
+        }, 0);
+      }
+      return popupWindow;
+    }
+  }
+}
+export {
+  WebUtils
+};

package/dist/chunk-WLGKV3EF.js

@@ -0,0 +1,35 @@
+"use client";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __async
+};

package/dist/cryptography/webAuth.js

@@ -0,0 +1,162 @@
+"use client";
+import {
+  __async
+} from "../chunk-WLGKV3EF.js";
+import base64url from "base64url";
+import * as cbor from "cbor-web";
+import forge from "node-forge";
+import { getPortalDomain } from "@getpara/core-sdk";
+const ES256_ALGORITHM = -7;
+const RS256_ALGORITHM = -257;
+function publicKeyCredentialToJSON(pubKeyCred) {
+  if (pubKeyCred instanceof ArrayBuffer || ArrayBuffer.isView(pubKeyCred)) {
+    return base64url.encode(pubKeyCred);
+  } else if (pubKeyCred instanceof Array) {
+    return pubKeyCred.map(publicKeyCredentialToJSON);
+  } else if (pubKeyCred instanceof Object) {
+    const obj = {};
+    for (const key in pubKeyCred) {
+      obj[key] = publicKeyCredentialToJSON(pubKeyCred[key]);
+    }
+    return obj;
+  } else return pubKeyCred;
+}
+function parseMakeCredAuthData(buffer) {
+  const rpIdHash = buffer.slice(0, 32);
+  buffer = buffer.slice(32);
+  const flagsBuf = buffer.slice(0, 1);
+  buffer = buffer.slice(1);
+  const flags = flagsBuf[0];
+  const counterBuf = buffer.slice(0, 4);
+  buffer = buffer.slice(4);
+  const counter = counterBuf.readUInt32BE(0);
+  const aaguid = buffer.slice(0, 16);
+  buffer = buffer.slice(16);
+  const credIDLenBuf = buffer.slice(0, 2);
+  buffer = buffer.slice(2);
+  const credIDLen = credIDLenBuf.readUInt16BE(0);
+  const credID = buffer.slice(0, credIDLen);
+  buffer = buffer.slice(credIDLen);
+  const COSEPublicKey = buffer;
+  return {
+    rpIdHash,
+    flagsBuf,
+    flags,
+    counter,
+    counterBuf,
+    aaguid,
+    credID,
+    COSEPublicKey
+  };
+}
+function parseAttestationObject(attestationObject) {
+  const attestationObjectBuffer = base64url.toBuffer(attestationObject);
+  return cbor.decodeAllSync(attestationObjectBuffer)[0];
+}
+function COSEECDSAtoPKCS(COSEPublicKey) {
+  const coseStruct = cbor.decodeAllSync(COSEPublicKey)[0];
+  const tag = Buffer.from([4]);
+  const x = coseStruct.get(-2);
+  const y = coseStruct.get(-3);
+  return Buffer.concat([tag, x, y]);
+}
+function COSERSAtoPKCS(COSEPublicKey) {
+  const coseStruct = cbor.decodeAllSync(COSEPublicKey)[0];
+  const n = coseStruct.get(-1);
+  const e = coseStruct.get(-2);
+  const nForge = forge.util.createBuffer(n.toString("binary"));
+  const eForge = forge.util.createBuffer(e.toString("binary"));
+  const publicKey = forge.pki.setRsaPublicKey(
+    new forge.jsbn.BigInteger(nForge.toHex(), 16),
+    new forge.jsbn.BigInteger(eForge.toHex(), 16)
+  );
+  return Buffer.from(forge.pki.publicKeyToPem(publicKey), "utf-8");
+}
+function parseCredentialCreationRes(creds, algorithm) {
+  const parsedAttestation = parseAttestationObject(creds.response.attestationObject);
+  const { COSEPublicKey, aaguid } = parseMakeCredAuthData(parsedAttestation.authData);
+  if (algorithm === RS256_ALGORITHM) {
+    return {
+      cosePublicKey: base64url.encode(COSERSAtoPKCS(COSEPublicKey)),
+      clientDataJSON: creds.response.clientDataJSON,
+      aaguid: aaguid.toString("hex")
+    };
+  }
+  return {
+    cosePublicKey: base64url.encode(COSEECDSAtoPKCS(COSEPublicKey)),
+    clientDataJSON: creds.response.clientDataJSON,
+    aaguid: aaguid.toString("hex")
+  };
+}
+function generateUserHandle() {
+  const userHandle = new Uint8Array(32);
+  window.crypto.getRandomValues(userHandle);
+  return userHandle;
+}
+function createCredential(env, userId, identifier, isE2E) {
+  return __async(this, null, function* () {
+    if (typeof navigator === "undefined") {
+      return;
+    }
+    const userHandle = generateUserHandle();
+    const createCredentialDefaultArgs = {
+      publicKey: {
+        authenticatorSelection: {
+          authenticatorAttachment: "platform",
+          requireResidentKey: true,
+          residentKey: "required",
+          userVerification: "required"
+        },
+        rp: {
+          id: getPortalDomain(env, isE2E),
+          name: "Para"
+        },
+        user: {
+          id: userHandle,
+          name: identifier,
+          displayName: identifier
+        },
+        pubKeyCredParams: [
+          { type: "public-key", alg: ES256_ALGORITHM },
+          // RS256_ALGORITHM should only be needed for windows hello
+          { type: "public-key", alg: RS256_ALGORITHM }
+        ],
+        attestation: "direct",
+        timeout: 6e4,
+        // TODO: don't think we really get value from verifying this, but should revisit
+        challenge: Buffer.from(userId, "utf-8")
+      }
+    };
+    const credential = yield navigator.credentials.create(createCredentialDefaultArgs);
+    const algorithm = credential.response.getPublicKeyAlgorithm ? credential.response.getPublicKeyAlgorithm() : ES256_ALGORITHM;
+    const userHandleEncoded = base64url.encode(Buffer.from(userHandle));
+    return {
+      creds: publicKeyCredentialToJSON(credential),
+      userHandle: userHandleEncoded,
+      algorithm
+    };
+  });
+}
+function generateSignature(env, challenge, allowedPublicKeys, isE2E) {
+  return __async(this, null, function* () {
+    const getCredentialDefaultArgs = {
+      publicKey: {
+        timeout: 6e4,
+        challenge: Buffer.from(challenge, "base64"),
+        allowCredentials: allowedPublicKeys.map((key) => ({
+          id: base64url.toBuffer(key),
+          type: "public-key"
+        })),
+        userVerification: "required",
+        rpId: getPortalDomain(env, isE2E)
+      }
+    };
+    const assertation = yield navigator.credentials.get(getCredentialDefaultArgs);
+    return publicKeyCredentialToJSON(assertation);
+  });
+}
+export {
+  createCredential,
+  generateSignature,
+  parseCredentialCreationRes
+};

package/dist/errors.js

@@ -0,0 +1,12 @@
+"use client";
+import "./chunk-WLGKV3EF.js";
+class TransactionReviewError extends Error {
+  constructor(transactionReviewUrl) {
+    super("transaction review error");
+    this.name = "TransactionReviewError";
+    this.transactionReviewUrl = transactionReviewUrl;
+  }
+}
+export {
+  TransactionReviewError
+};