@getpara/core-sdk 1.7.1 → 1.9.0

package/dist/esm/shares/KeyContainer.js

@@ -0,0 +1,57 @@
+import "../chunk-UICEQADR.js";
+import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
+import * as eutil from "@ethereumjs/util";
+import * as forge from "node-forge";
+class KeyContainer {
+  constructor(walletId, keyshare, address) {
+    this.walletId = walletId;
+    this.keyshare = keyshare;
+    this.address = address;
+    this.backupDecryptionKey = Buffer.from(forge.random.getBytesSync(32), "binary").toString("hex");
+  }
+  static buildFrom(serializedContainer) {
+    try {
+      const parsedObject = JSON.parse(serializedContainer);
+      return Object.assign(new KeyContainer("", "", ""), parsedObject);
+    } catch (e) {
+      const container = new KeyContainer("", "", "");
+      container.backupDecryptionKey = serializedContainer.split("|")[0];
+      return container;
+    }
+  }
+  getPublicEncryptionKey() {
+    return Buffer.from(eutil.privateToPublic(Buffer.from(this.backupDecryptionKey, "hex")));
+  }
+  getPublicEncryptionKeyHex() {
+    return this.getPublicEncryptionKey().toString("hex");
+  }
+  encryptForSelf(backup) {
+    try {
+      const pubkey = this.getPublicEncryptionKey();
+      const data = ECIESEncrypt(pubkey, Buffer.from(backup, "ucs2")).toString("base64");
+      return data;
+    } catch (error) {
+      throw Error("Error encrypting backup");
+    }
+  }
+  static encryptWithPublicKey(publicKey, backup) {
+    try {
+      const data = ECIESEncrypt(publicKey, Buffer.from(backup, "ucs2")).toString("base64");
+      return data;
+    } catch (error) {
+      throw Error("Error encrypting backup");
+    }
+  }
+  decrypt(encryptedBackup) {
+    try {
+      const buf = Buffer.from(encryptedBackup, "base64");
+      const data = ECIESDecrypt(Buffer.from(this.backupDecryptionKey, "hex"), buf);
+      return Buffer.from(data.buffer).toString("ucs2");
+    } catch (error) {
+      throw Error("Error decrypting backup");
+    }
+  }
+}
+export {
+  KeyContainer
+};

package/dist/esm/shares/recovery.js

@@ -0,0 +1,74 @@
+import {
+  __async,
+  __spreadValues
+} from "../chunk-UICEQADR.js";
+import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
+import { KeyContainer } from "./KeyContainer.js";
+function sendRecoveryForShare(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    userId,
+    walletId,
+    otherEncryptedShares = [],
+    userSigner,
+    ignoreRedistributingBackupEncryptedShare = false,
+    emailProps = {},
+    forceRefresh = false
+  }) {
+    if (ignoreRedistributingBackupEncryptedShare) {
+      yield ctx.client.uploadUserKeyShares(
+        userId,
+        otherEncryptedShares.map((share) => __spreadValues({
+          walletId
+        }, share))
+      );
+      return "";
+    }
+    let userBackupKeyShareOptsArr;
+    let recoveryPrivateKeyContainer;
+    const { recoveryPublicKeys } = yield ctx.client.getRecoveryPublicKeys(userId);
+    if (forceRefresh || !(recoveryPublicKeys == null ? void 0 : recoveryPublicKeys.length)) {
+      recoveryPrivateKeyContainer = new KeyContainer(walletId, "", "");
+      const { recoveryPublicKeys: recoveryPublicKeys2 } = yield ctx.client.persistRecoveryPublicKeys(userId, [
+        recoveryPrivateKeyContainer.getPublicEncryptionKeyHex()
+      ]);
+      const encryptedUserBackup = recoveryPrivateKeyContainer.encryptForSelf(userSigner);
+      userBackupKeyShareOptsArr = [
+        {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId: recoveryPublicKeys2[0].id
+        }
+      ];
+    } else {
+      userBackupKeyShareOptsArr = recoveryPublicKeys.map((recoveryPublicKey) => {
+        const { id: recoveryPublicKeyId, publicKey } = recoveryPublicKey;
+        const encryptedUserBackup = KeyContainer.encryptWithPublicKey(Buffer.from(publicKey, "hex"), userSigner);
+        return {
+          walletId,
+          encryptedShare: encryptedUserBackup,
+          type: KeyShareType.USER,
+          encryptor: EncryptorType.RECOVERY,
+          recoveryPublicKeyId
+        };
+      });
+    }
+    yield ctx.client.uploadUserKeyShares(userId, [
+      ...otherEncryptedShares.map((share) => __spreadValues({
+        walletId
+      }, share)),
+      ...ignoreRedistributingBackupEncryptedShare ? [] : userBackupKeyShareOptsArr
+    ]);
+    yield ctx.client.distributeParaShare(__spreadValues({
+      userId,
+      walletId,
+      useDKLS: ctx.useDKLS
+    }, emailProps));
+    return recoveryPrivateKeyContainer ? JSON.stringify(recoveryPrivateKeyContainer) : "";
+  });
+}
+export {
+  sendRecoveryForShare
+};

package/dist/esm/shares/shareDistribution.js

@@ -0,0 +1,64 @@
+import {
+  __async
+} from "../chunk-UICEQADR.js";
+import { EncryptorType, KeyShareType } from "@getpara/user-management-client";
+import { encryptWithDerivedPublicKey } from "../cryptography/utils.js";
+import { sendRecoveryForShare } from "./recovery.js";
+function distributeNewShare(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    userId,
+    walletId,
+    userShare,
+    ignoreRedistributingBackupEncryptedShare = false,
+    emailProps = {},
+    partnerId,
+    protocolId
+  }) {
+    const publicKeysRes = yield ctx.client.getSessionPublicKeys(userId);
+    const biometricEncryptedShares = publicKeysRes.data.keys.map((key) => {
+      if (!key.publicKey) {
+        return;
+      }
+      const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(key.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: KeyShareType.USER,
+        encryptor: EncryptorType.BIOMETRICS,
+        biometricPublicKey: key.sigDerivedPublicKey,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const passwords = yield ctx.client.getPasswords({ userId });
+    const passwordEncryptedShares = passwords.map((password) => {
+      if (password.status === "PENDING") {
+        return;
+      }
+      const { encryptedMessageHex, encryptedKeyHex } = encryptWithDerivedPublicKey(password.sigDerivedPublicKey, userShare);
+      return {
+        encryptedShare: encryptedMessageHex,
+        encryptedKey: encryptedKeyHex,
+        type: KeyShareType.USER,
+        encryptor: EncryptorType.PASSWORD,
+        passwordId: password.id,
+        partnerId,
+        protocolId
+      };
+    }).filter(Boolean);
+    const allEncryptedShares = [...biometricEncryptedShares, ...passwordEncryptedShares];
+    return yield sendRecoveryForShare({
+      ctx,
+      userId,
+      walletId,
+      otherEncryptedShares: allEncryptedShares,
+      userSigner: userShare,
+      ignoreRedistributingBackupEncryptedShare,
+      emailProps
+    });
+  });
+}
+export {
+  distributeNewShare
+};

package/dist/esm/transmission/transmissionUtils.js

@@ -0,0 +1,42 @@
+import {
+  __async
+} from "../chunk-UICEQADR.js";
+import { Encrypt as ECIESEncrypt, Decrypt as ECIESDecrypt } from "@celo/utils/lib/ecies.js";
+import { Buffer } from "buffer";
+import * as eutil from "@ethereumjs/util";
+import { randomBytes } from "crypto";
+function upload(message, userManagementClient) {
+  return __async(this, null, function* () {
+    let secret;
+    let publicKeyUint8Array;
+    while (true) {
+      try {
+        secret = randomBytes(32).toString("hex");
+        publicKeyUint8Array = eutil.privateToPublic(Buffer.from(secret, "hex"));
+        break;
+      } catch (e) {
+        continue;
+      }
+    }
+    const pubkey = Buffer.from(publicKeyUint8Array);
+    const data = ECIESEncrypt(pubkey, Buffer.from(message, "ucs2")).toString("base64");
+    const {
+      data: { id }
+    } = yield userManagementClient.tempTrasmissionInit(data);
+    return encodeURIComponent(id + "|" + secret);
+  });
+}
+function retrieve(uriEncodedMessage, userManagementClient) {
+  return __async(this, null, function* () {
+    const [id, secret] = decodeURIComponent(uriEncodedMessage).split("|");
+    const response = yield userManagementClient.tempTrasmission(id);
+    const data = response.data.message;
+    const buf = Buffer.from(data, "base64");
+    const res = Buffer.from(ECIESDecrypt(Buffer.from(secret, "hex"), buf).buffer).toString("ucs2");
+    return res;
+  });
+}
+export {
+  retrieve,
+  upload
+};

package/dist/esm/types/config.js

@@ -0,0 +1,20 @@
+import "../chunk-UICEQADR.js";
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["DEV"] = "DEV";
+  Environment2["SANDBOX"] = "SANDBOX";
+  Environment2["BETA"] = "BETA";
+  Environment2["PROD"] = "PROD";
+  Environment2["DEVELOPMENT"] = "BETA";
+  Environment2["PRODUCTION"] = "PROD";
+  return Environment2;
+})(Environment || {});
+var EnabledFlow = /* @__PURE__ */ ((EnabledFlow2) => {
+  EnabledFlow2["BUY"] = "BUY";
+  EnabledFlow2["RECEIVE"] = "RECEIVE";
+  EnabledFlow2["WITHDRAW"] = "WITHDRAW";
+  return EnabledFlow2;
+})(EnabledFlow || {});
+export {
+  EnabledFlow,
+  Environment
+};

package/dist/esm/types/events.js

@@ -0,0 +1,18 @@
+import "../chunk-UICEQADR.js";
+const EVENT_PREFIX = "para";
+var ParaEvent = ((ParaEvent2) => {
+  ParaEvent2["LOGIN_EVENT"] = `${EVENT_PREFIX}Login`;
+  ParaEvent2["ACCOUNT_CREATION_EVENT"] = `${EVENT_PREFIX}AccountCreation`;
+  ParaEvent2["ACCOUNT_SETUP_EVENT"] = `${EVENT_PREFIX}AccountSetup`;
+  ParaEvent2["LOGOUT_EVENT"] = `${EVENT_PREFIX}Logout`;
+  ParaEvent2["SIGN_MESSAGE_EVENT"] = `${EVENT_PREFIX}SignMessage`;
+  ParaEvent2["SIGN_TRANSACTION_EVENT"] = `${EVENT_PREFIX}SignTransaction`;
+  ParaEvent2["EXTERNAL_WALLET_CHANGE_EVENT"] = `${EVENT_PREFIX}ExternalWalletChange`;
+  ParaEvent2["WALLETS_CHANGE_EVENT"] = `${EVENT_PREFIX}WalletsChange`;
+  ParaEvent2["WALLET_CREATED"] = `${EVENT_PREFIX}WalletCreated`;
+  ParaEvent2["PREGEN_WALLET_CLAIMED"] = `${EVENT_PREFIX}PregenWalletClaimed`;
+  return ParaEvent2;
+})(ParaEvent || {});
+export {
+  ParaEvent
+};

package/dist/esm/types/index.js

@@ -0,0 +1,21 @@
+import "../chunk-UICEQADR.js";
+export * from "./config.js";
+export * from "./wallet.js";
+export * from "./params.js";
+export * from "./theme.js";
+export * from "./onRamps.js";
+export * from "./popup.js";
+export * from "./recovery.js";
+export * from "./events.js";
+import {
+  Network,
+  OnRampAsset,
+  OnRampProvider,
+  OnRampPurchaseStatus
+} from "@getpara/user-management-client";
+export {
+  Network,
+  OnRampAsset,
+  OnRampProvider,
+  OnRampPurchaseStatus
+};

package/dist/esm/types/onRamps.js

@@ -0,0 +1,11 @@
+import "../chunk-UICEQADR.js";
+var OnRampMethod = /* @__PURE__ */ ((OnRampMethod2) => {
+  OnRampMethod2["ACH"] = "ACH";
+  OnRampMethod2["DEBIT"] = "Debit";
+  OnRampMethod2["CREDIT"] = "Credit";
+  OnRampMethod2["APPLE_PAY"] = "Apple Pay";
+  return OnRampMethod2;
+})(OnRampMethod || {});
+export {
+  OnRampMethod
+};

package/dist/esm/types/popup.js

@@ -0,0 +1,13 @@
+import "../chunk-UICEQADR.js";
+var PopupType = /* @__PURE__ */ ((PopupType2) => {
+  PopupType2["SIGN_TRANSACTION_REVIEW"] = "SIGN_TRANSACTION_REVIEW";
+  PopupType2["SIGN_MESSAGE_REVIEW"] = "SIGN_MESSAGE_REVIEW";
+  PopupType2["LOGIN_PASSKEY"] = "LOGIN_PASSKEY";
+  PopupType2["CREATE_PASSKEY"] = "CREATE_PASSKEY";
+  PopupType2["OAUTH"] = "OAUTH";
+  PopupType2["ON_RAMP_TRANSACTION"] = "ON_RAMP_TRANSACTION";
+  return PopupType2;
+})(PopupType || {});
+export {
+  PopupType
+};

package/dist/esm/types/recovery.js

@@ -0,0 +1,12 @@
+import "../chunk-UICEQADR.js";
+var RecoveryStatus = /* @__PURE__ */ ((RecoveryStatus2) => {
+  RecoveryStatus2["INITIATED"] = "INITIATED";
+  RecoveryStatus2["READY"] = "READY";
+  RecoveryStatus2["EXPIRED"] = "EXPIRED";
+  RecoveryStatus2["FINISHED"] = "FINISHED";
+  RecoveryStatus2["CANCELLED"] = "CANCELLED";
+  return RecoveryStatus2;
+})(RecoveryStatus || {});
+export {
+  RecoveryStatus
+};

package/dist/esm/types/wallet.js

@@ -0,0 +1,9 @@
+import "../chunk-UICEQADR.js";
+var PregenIdentifierType = /* @__PURE__ */ ((PregenIdentifierType2) => {
+  PregenIdentifierType2["EMAIL"] = "EMAIL";
+  PregenIdentifierType2["PHONE"] = "PHONE";
+  return PregenIdentifierType2;
+})(PregenIdentifierType || {});
+export {
+  PregenIdentifierType
+};

package/dist/esm/utils/events.js

@@ -0,0 +1,11 @@
+import {
+  __spreadValues
+} from "../chunk-UICEQADR.js";
+function dispatchEvent(type, data, error) {
+  typeof window !== "undefined" && !!window.dispatchEvent && window.dispatchEvent(
+    new CustomEvent(type, { detail: __spreadValues({ data }, error && { error: new Error(error) }) })
+  );
+}
+export {
+  dispatchEvent
+};

package/dist/esm/utils/formatting.js

@@ -0,0 +1,80 @@
+import "../chunk-UICEQADR.js";
+import { toBech32 } from "@cosmjs/encoding";
+import { sha256 } from "@noble/hashes/sha256";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+import elliptic from "elliptic";
+import parsePhoneNumberFromString from "libphonenumber-js";
+const secp256k1 = new elliptic.ec("secp256k1");
+function hexStringToBase64(hexString) {
+  if (hexString.substring(0, 2) === "0x") {
+    hexString = hexString.substring(2);
+  }
+  return Buffer.from(hexString, "hex").toString("base64");
+}
+function hexToSignature(hexSig) {
+  return {
+    r: `0x${hexSig.slice(2, 66)}`,
+    s: `0x${hexSig.slice(66, 130)}`,
+    v: BigInt(hexSig.slice(130, 132))
+  };
+}
+function hexToUint8Array(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+function hexToDecimal(hex) {
+  if (hex.startsWith("0x")) {
+    hex = hex.slice(2);
+  }
+  return `${parseInt(hex, 16)}`;
+}
+function decimalToHex(decimal) {
+  return `0x${parseInt(decimal).toString(16)}`;
+}
+function compressPubkey(pubkey) {
+  switch (pubkey.length) {
+    case 33:
+      return pubkey;
+    case 65:
+      return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(true, "array"));
+    default:
+      throw new Error("Invalid pubkey length");
+  }
+}
+function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
+  if (pubkeyData.length !== 33) {
+    throw new Error(`Invalid Secp256k1 pubkey length (compressed): ${pubkeyData.length}`);
+  }
+  return ripemd160(sha256(pubkeyData));
+}
+function getCosmosAddress(publicKey, prefix) {
+  const uncompressedPublicKey = new Uint8Array(
+    Buffer.from(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey, "hex")
+  );
+  const compressedPublicKey = compressPubkey(uncompressedPublicKey);
+  return toBech32(prefix, rawSecp256k1PubkeyToRawAddress(compressedPublicKey));
+}
+function truncateAddress(str, addressType, { prefix = addressType === "COSMOS" ? "cosmos" : void 0 } = {}) {
+  const headLength = (addressType === "COSMOS" ? prefix.length : addressType === "SOLANA" ? 0 : 2) + 4;
+  return `${str.slice(0, headLength)}...${str.slice(-4)}`;
+}
+function stringToPhoneNumber(str) {
+  var _a;
+  return (_a = parsePhoneNumberFromString(str)) == null ? void 0 : _a.formatInternational().replace(/[^\d+]/g, "");
+}
+function normalizePhoneNumber(countryCode, number) {
+  return stringToPhoneNumber(`${countryCode[0] !== "+" ? "+" : ""}${countryCode}${number}`);
+}
+export {
+  decimalToHex,
+  getCosmosAddress,
+  hexStringToBase64,
+  hexToDecimal,
+  hexToSignature,
+  hexToUint8Array,
+  normalizePhoneNumber,
+  stringToPhoneNumber,
+  truncateAddress
+};

package/dist/esm/utils/index.js

@@ -0,0 +1,6 @@
+export * from "./events.js";
+export * from "./formatting.js";
+export * from "./onRamps.js";
+export * from "./polling.js";
+export * from "./url.js";
+export * from "./wallet.js";

package/dist/esm/utils/listeners.js

@@ -0,0 +1,47 @@
+import "../chunk-UICEQADR.js";
+import * as constants from "../constants.js";
+function storageListener(e) {
+  if (!e.url.includes(window.location.origin)) {
+    return;
+  }
+  if (e.key === constants.LOCAL_STORAGE_EXTERNAL_WALLETS) {
+    this.updateExternalWalletsFromStorage();
+  }
+  if (e.key === constants.SESSION_STORAGE_LOGIN_ENCRYPTION_KEY_PAIR) {
+    this.updateLoginEncryptionKeyPairFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_SESSION_COOKIE) {
+    this.updateSessionCookieFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_CURRENT_WALLET_IDS) {
+    this.updateWalletIdsFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_WALLETS || e.key === constants.LOCAL_STORAGE_ED25519_WALLETS) {
+    this.updateWalletsFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_EMAIL) {
+    this.updateEmailFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_COUNTRY_CODE) {
+    this.updateCountryCodeFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_PHONE) {
+    this.updatePhoneFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_USER_ID) {
+    this.updateUserIdFromStorage();
+  }
+  if (e.key === constants.LOCAL_STORAGE_TELEGRAM_USER_ID) {
+    this.updateTelegramUserIdFromStorage();
+  }
+}
+function setupListeners() {
+  if (typeof window !== "undefined" && window.addEventListener && window.location) {
+    window.removeEventListener("storage", storageListener.bind(this));
+    window.addEventListener("storage", storageListener.bind(this));
+  }
+}
+export {
+  setupListeners,
+  storageListener
+};

package/dist/esm/utils/onRamps.js

@@ -0,0 +1,40 @@
+import "../chunk-UICEQADR.js";
+function toAssetInfoArray(data) {
+  const result = [];
+  Object.keys(data).forEach((walletType) => {
+    const networks = data[walletType];
+    Object.keys(networks).forEach((network) => {
+      const assets = networks[network];
+      Object.keys(assets).forEach((asset) => {
+        const providerInfo = assets[asset];
+        result.push([walletType, network, asset, providerInfo]);
+      });
+    });
+  });
+  return result;
+}
+function getOnRampNetworks(data, { walletType, allowed } = {}) {
+  return [
+    ...new Set(
+      toAssetInfoArray(data).filter(([type, network]) => (!walletType || type === walletType) && (!allowed || allowed.includes(network))).map(([_, network]) => network)
+    )
+  ];
+}
+function getOnRampAssets(data, {
+  walletType,
+  network,
+  allowed
+} = {}) {
+  return [
+    ...new Set(
+      toAssetInfoArray(data).filter(
+        ([t, n, a]) => (!walletType || t === walletType) && (!network || n === network) && (!Array.isArray(allowed) || allowed.includes(a))
+      ).map(([, , asset]) => asset)
+    )
+  ];
+}
+export {
+  getOnRampAssets,
+  getOnRampNetworks,
+  toAssetInfoArray
+};

package/dist/esm/utils/polling.js

@@ -0,0 +1,18 @@
+import {
+  __async
+} from "../chunk-UICEQADR.js";
+function waitUntilTrue(condition, timeoutMs, intervalMs) {
+  return __async(this, null, function* () {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      if (yield condition()) {
+        return true;
+      }
+      yield new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return false;
+  });
+}
+export {
+  waitUntilTrue
+};

package/dist/esm/utils/url.js

@@ -0,0 +1,77 @@
+import "../chunk-UICEQADR.js";
+import { Environment } from "../types/index.js";
+function getPortalDomain(env, isE2E) {
+  if (isE2E) {
+    return `localhost`;
+  }
+  switch (env) {
+    case Environment.DEV:
+      return "localhost";
+    case Environment.SANDBOX:
+      return "app.sandbox.usecapsule.com";
+    case Environment.BETA:
+      return "app.beta.usecapsule.com";
+    case Environment.PROD:
+      return "app.usecapsule.com";
+    default:
+      throw new Error(`env: ${env} not supported`);
+  }
+}
+function getPortalBaseURL({ env, isE2E }, useLocalIp, isForWasm) {
+  if (isE2E) {
+    if (isForWasm) {
+      return `https://app.sandbox.usecapsule.com`;
+    }
+    return `http://localhost:3003`;
+  }
+  const domain = getPortalDomain(env);
+  if (env === Environment.DEV) {
+    if (useLocalIp) {
+      return `http://127.0.0.1:3003`;
+    }
+    return `http://${domain}:3003`;
+  }
+  return `https://${domain}`;
+}
+function getParaConnectDomain(env) {
+  switch (env) {
+    case Environment.DEV:
+      return "localhost";
+    case Environment.SANDBOX:
+      return "connect.sandbox.getpara.com";
+    case Environment.BETA:
+      return "connect.beta.getpara.com";
+    case Environment.PROD:
+      return "connect.getpara.com";
+    default:
+      throw new Error(`env: ${env} not supported`);
+  }
+}
+function getParaConnectBaseUrl({ env }, useLocalIp) {
+  const domain = getParaConnectDomain(env);
+  if (env === Environment.DEV) {
+    if (useLocalIp) {
+      return `http://127.0.0.1:3008`;
+    }
+    return `http://${domain}:3008`;
+  }
+  return `https://${domain}`;
+}
+function constructUrl({
+  base,
+  path,
+  params = {}
+}) {
+  const url = new URL(path, base);
+  Object.entries(params).forEach(([key, value]) => {
+    if (!!value && value !== "undefined" && value !== "null") url.searchParams.set(key, value.toString());
+  });
+  return url.toString();
+}
+export {
+  constructUrl,
+  getParaConnectBaseUrl,
+  getParaConnectDomain,
+  getPortalBaseURL,
+  getPortalDomain
+};