@multiversx/sdk-dapp-liquidity 2.0.0-alpha.4 → 2.1.0-alpha.0

package/helpers/assertRateConfirmationMatchesIntent.d.ts

@@ -0,0 +1,8 @@
+import { ServerTransaction } from '../types/transaction';
+
+interface ConfirmIntent {
+    fromChainId: string;
+    sender: string;
+}
+export declare function assertRateConfirmationMatchesIntent(intent: ConfirmIntent, transactions: ServerTransaction[]): void;
+export {};

package/helpers/assertRateConfirmationMatchesIntent.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types_errors = require("../types/errors.js");
+function assertRateConfirmationMatchesIntent(intent, transactions) {
+  for (const tx of transactions) {
+    if (tx.chainID !== void 0 && String(tx.chainID) !== String(intent.fromChainId)) {
+      throw new types_errors.RateConfirmationMismatchError(
+        `Transaction chainID ${tx.chainID} does not match approved fromChainId ${intent.fromChainId}`
+      );
+    }
+    if (tx.account !== void 0 && tx.account !== "" && intent.sender !== "" && tx.account.toLowerCase() !== intent.sender.toLowerCase()) {
+      throw new types_errors.RateConfirmationMismatchError(
+        `Transaction account ${tx.account} does not match approved sender ${intent.sender}`
+      );
+    }
+    if (tx.sender !== void 0 && tx.sender !== "" && intent.sender !== "" && tx.sender.toLowerCase() !== intent.sender.toLowerCase()) {
+      throw new types_errors.RateConfirmationMismatchError(
+        `Transaction sender ${tx.sender} does not match approved sender ${intent.sender}`
+      );
+    }
+  }
+}
+exports.assertRateConfirmationMatchesIntent = assertRateConfirmationMatchesIntent;

package/helpers/assertRateConfirmationMatchesIntent.mjs

@@ -0,0 +1,23 @@
+import { RateConfirmationMismatchError } from "../types/errors.mjs";
+function assertRateConfirmationMatchesIntent(intent, transactions) {
+  for (const tx of transactions) {
+    if (tx.chainID !== void 0 && String(tx.chainID) !== String(intent.fromChainId)) {
+      throw new RateConfirmationMismatchError(
+        `Transaction chainID ${tx.chainID} does not match approved fromChainId ${intent.fromChainId}`
+      );
+    }
+    if (tx.account !== void 0 && tx.account !== "" && intent.sender !== "" && tx.account.toLowerCase() !== intent.sender.toLowerCase()) {
+      throw new RateConfirmationMismatchError(
+        `Transaction account ${tx.account} does not match approved sender ${intent.sender}`
+      );
+    }
+    if (tx.sender !== void 0 && tx.sender !== "" && intent.sender !== "" && tx.sender.toLowerCase() !== intent.sender.toLowerCase()) {
+      throw new RateConfirmationMismatchError(
+        `Transaction sender ${tx.sender} does not match approved sender ${intent.sender}`
+      );
+    }
+  }
+}
+export {
+  assertRateConfirmationMatchesIntent
+};

package/helpers/index.d.ts

@@ -3,7 +3,9 @@ export * from './decodeLoginToken';
 export * from './decodeToken';
 export * from './getApiURL';
 export * from './getBridgeURL';
+export * from './getDisplayName';
 export * from './getMvxApiURL';
 export * from './getMvxChainId';
 export * from './getMvxExplorerAddress';
+export * from './safeImageUrl';
 export * from './serializeTransaction';

package/helpers/index.js

@@ -6,9 +6,11 @@ const helpers_decodeLoginToken = require("./decodeLoginToken.js");
 const helpers_decodeToken = require("./decodeToken.js");
 const helpers_getApiURL = require("./getApiURL.js");
 const helpers_getBridgeURL = require("./getBridgeURL.js");
+const helpers_getDisplayName = require("./getDisplayName.js");
 const helpers_getMvxApiURL = require("./getMvxApiURL.js");
 const helpers_getMvxChainId = require("./getMvxChainId.js");
 const helpers_getMvxExplorerAddress = require("./getMvxExplorerAddress.js");
+const helpers_safeImageUrl = require("./safeImageUrl.js");
 const helpers_serializeTransaction = require("./serializeTransaction.js");
 exports.decodeBase64 = helpers_base64Utils.decodeBase64;
 exports.encodeToBase64 = helpers_base64Utils.encodeToBase64;
@@ -17,7 +19,9 @@ exports.decodeLoginToken = helpers_decodeLoginToken.decodeLoginToken;
 exports.decodeToken = helpers_decodeToken.decodeToken;
 exports.getApiURL = helpers_getApiURL.getApiURL;
 exports.getBridgeURL = helpers_getBridgeURL.getBridgeURL;
+exports.getDisplayName = helpers_getDisplayName.getDisplayName;
 exports.getMvxApiURL = helpers_getMvxApiURL.getMvxApiURL;
 exports.getMvxChainId = helpers_getMvxChainId.getMvxChainId;
 exports.getMvxExplorerAddress = helpers_getMvxExplorerAddress.getMvxExplorerAddress;
+exports.safeImageUrl = helpers_safeImageUrl.safeImageUrl;
 exports.serializeTransaction = helpers_serializeTransaction.serializeTransaction;

package/helpers/index.mjs

@@ -3,9 +3,11 @@ import { decodeLoginToken } from "./decodeLoginToken.mjs";
 import { decodeToken } from "./decodeToken.mjs";
 import { getApiURL } from "./getApiURL.mjs";
 import { getBridgeURL } from "./getBridgeURL.mjs";
+import { getDisplayName } from "./getDisplayName.mjs";
 import { getMvxApiURL } from "./getMvxApiURL.mjs";
 import { getMvxChainId } from "./getMvxChainId.mjs";
 import { getMvxExplorerAddress } from "./getMvxExplorerAddress.mjs";
+import { safeImageUrl } from "./safeImageUrl.mjs";
 import { serializeTransaction } from "./serializeTransaction.mjs";
 export {
   decodeBase64,
@@ -14,9 +16,11 @@ export {
   encodeToBase64,
   getApiURL,
   getBridgeURL,
+  getDisplayName,
   getMvxApiURL,
   getMvxChainId,
   getMvxExplorerAddress,
   isStringBase64,
+  safeImageUrl,
   serializeTransaction
 };

package/helpers/safeImageUrl.d.ts

@@ -0,0 +1 @@
+export declare function safeImageUrl(url: string | undefined, fallback?: string): string;

package/helpers/safeImageUrl.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BLOCKED_PREFIXES = ["data:", "javascript:", "file:", "blob:"];
+const MAX_URL_LENGTH = 2048;
+function safeImageUrl(url, fallback = "") {
+  if (!url || typeof url !== "string" || url.length === 0) {
+    return fallback;
+  }
+  if (url.length > MAX_URL_LENGTH) {
+    return fallback;
+  }
+  const lower = url.toLowerCase();
+  for (const prefix of BLOCKED_PREFIXES) {
+    if (lower.startsWith(prefix)) {
+      return fallback;
+    }
+  }
+  if (!lower.startsWith("https://")) {
+    return fallback;
+  }
+  return url;
+}
+exports.safeImageUrl = safeImageUrl;

package/helpers/safeImageUrl.mjs

@@ -0,0 +1,23 @@
+const BLOCKED_PREFIXES = ["data:", "javascript:", "file:", "blob:"];
+const MAX_URL_LENGTH = 2048;
+function safeImageUrl(url, fallback = "") {
+  if (!url || typeof url !== "string" || url.length === 0) {
+    return fallback;
+  }
+  if (url.length > MAX_URL_LENGTH) {
+    return fallback;
+  }
+  const lower = url.toLowerCase();
+  for (const prefix of BLOCKED_PREFIXES) {
+    if (lower.startsWith(prefix)) {
+      return fallback;
+    }
+  }
+  if (!lower.startsWith("https://")) {
+    return fallback;
+  }
+  return url;
+}
+export {
+  safeImageUrl
+};

package/helpers/serializeTransaction.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function serializeTransaction(transaction) {
   return JSON.stringify(transaction, (_key, value) => {
-    return typeof value === "bigint" ? Number(value).toString() : value;
+    return typeof value === "bigint" ? value.toString() : value;
   });
 }
 exports.serializeTransaction = serializeTransaction;

package/helpers/serializeTransaction.mjs

@@ -1,6 +1,6 @@
 function serializeTransaction(transaction) {
   return JSON.stringify(transaction, (_key, value) => {
-    return typeof value === "bigint" ? Number(value).toString() : value;
+    return typeof value === "bigint" ? value.toString() : value;
   });
 }
 export {

package/helpers/tests/assertRateConfirmationMatchesIntent.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/helpers/tests/assertRateConfirmationMatchesIntent.spec.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+"use strict";
+const types_errors = require("../../types/errors.js");
+const helpers_assertRateConfirmationMatchesIntent = require("../assertRateConfirmationMatchesIntent.js");
+const makeTransaction = (overrides = {}) => ({
+  to: "0xdeadbeef",
+  data: "0x",
+  gasLimit: BigInt(21e3),
+  value: BigInt(0),
+  account: "0xSender",
+  txHash: "",
+  ...overrides
+});
+describe("assertRateConfirmationMatchesIntent", () => {
+  const intent = { fromChainId: "1", sender: "0xSender" };
+  it("does not throw for an empty transactions array", () => {
+    expect(() => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [])).not.toThrow();
+  });
+  it("does not throw when chainID and account match", () => {
+    const tx = makeTransaction({ chainID: "1", account: "0xSender" });
+    expect(
+      () => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [tx])
+    ).not.toThrow();
+  });
+  it("does not throw when chainID is undefined (field absent)", () => {
+    const tx = makeTransaction({ account: "0xSender" });
+    expect(
+      () => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [tx])
+    ).not.toThrow();
+  });
+  it("throws RateConfirmationMismatchError when chainID does not match fromChainId", () => {
+    const tx = makeTransaction({ chainID: "999", account: "0xSender" });
+    expect(() => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [tx])).toThrow(
+      types_errors.RateConfirmationMismatchError
+    );
+  });
+  it("throws RateConfirmationMismatchError when account does not match sender (case-insensitive)", () => {
+    const tx = makeTransaction({ account: "0xAttacker" });
+    expect(() => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [tx])).toThrow(
+      types_errors.RateConfirmationMismatchError
+    );
+  });
+  it("does not throw when account matches sender case-insensitively", () => {
+    const tx = makeTransaction({ account: "0xsender" });
+    const intentLower = { fromChainId: "1", sender: "0xSENDER" };
+    expect(
+      () => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intentLower, [tx])
+    ).not.toThrow();
+  });
+  it("throws RateConfirmationMismatchError when MvX sender field does not match", () => {
+    const tx = makeTransaction({ account: "0xSender", sender: "erd1attacker" });
+    const mvxIntent = { fromChainId: "1", sender: "erd1legit" };
+    expect(() => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(mvxIntent, [tx])).toThrow(
+      types_errors.RateConfirmationMismatchError
+    );
+  });
+  it("throws on the bad transaction when mixed valid and invalid transactions are present", () => {
+    const goodTx = makeTransaction({ chainID: "1", account: "0xSender" });
+    const badTx = makeTransaction({ chainID: "999", account: "0xSender" });
+    expect(
+      () => helpers_assertRateConfirmationMatchesIntent.assertRateConfirmationMatchesIntent(intent, [goodTx, badTx])
+    ).toThrow(types_errors.RateConfirmationMismatchError);
+  });
+});

package/helpers/tests/assertRateConfirmationMatchesIntent.spec.mjs

@@ -0,0 +1,62 @@
+import { RateConfirmationMismatchError } from "../../types/errors.mjs";
+import { assertRateConfirmationMatchesIntent } from "../assertRateConfirmationMatchesIntent.mjs";
+const makeTransaction = (overrides = {}) => ({
+  to: "0xdeadbeef",
+  data: "0x",
+  gasLimit: BigInt(21e3),
+  value: BigInt(0),
+  account: "0xSender",
+  txHash: "",
+  ...overrides
+});
+describe("assertRateConfirmationMatchesIntent", () => {
+  const intent = { fromChainId: "1", sender: "0xSender" };
+  it("does not throw for an empty transactions array", () => {
+    expect(() => assertRateConfirmationMatchesIntent(intent, [])).not.toThrow();
+  });
+  it("does not throw when chainID and account match", () => {
+    const tx = makeTransaction({ chainID: "1", account: "0xSender" });
+    expect(
+      () => assertRateConfirmationMatchesIntent(intent, [tx])
+    ).not.toThrow();
+  });
+  it("does not throw when chainID is undefined (field absent)", () => {
+    const tx = makeTransaction({ account: "0xSender" });
+    expect(
+      () => assertRateConfirmationMatchesIntent(intent, [tx])
+    ).not.toThrow();
+  });
+  it("throws RateConfirmationMismatchError when chainID does not match fromChainId", () => {
+    const tx = makeTransaction({ chainID: "999", account: "0xSender" });
+    expect(() => assertRateConfirmationMatchesIntent(intent, [tx])).toThrow(
+      RateConfirmationMismatchError
+    );
+  });
+  it("throws RateConfirmationMismatchError when account does not match sender (case-insensitive)", () => {
+    const tx = makeTransaction({ account: "0xAttacker" });
+    expect(() => assertRateConfirmationMatchesIntent(intent, [tx])).toThrow(
+      RateConfirmationMismatchError
+    );
+  });
+  it("does not throw when account matches sender case-insensitively", () => {
+    const tx = makeTransaction({ account: "0xsender" });
+    const intentLower = { fromChainId: "1", sender: "0xSENDER" };
+    expect(
+      () => assertRateConfirmationMatchesIntent(intentLower, [tx])
+    ).not.toThrow();
+  });
+  it("throws RateConfirmationMismatchError when MvX sender field does not match", () => {
+    const tx = makeTransaction({ account: "0xSender", sender: "erd1attacker" });
+    const mvxIntent = { fromChainId: "1", sender: "erd1legit" };
+    expect(() => assertRateConfirmationMatchesIntent(mvxIntent, [tx])).toThrow(
+      RateConfirmationMismatchError
+    );
+  });
+  it("throws on the bad transaction when mixed valid and invalid transactions are present", () => {
+    const goodTx = makeTransaction({ chainID: "1", account: "0xSender" });
+    const badTx = makeTransaction({ chainID: "999", account: "0xSender" });
+    expect(
+      () => assertRateConfirmationMatchesIntent(intent, [goodTx, badTx])
+    ).toThrow(RateConfirmationMismatchError);
+  });
+});

package/helpers/tests/safeImageUrl.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/helpers/tests/safeImageUrl.spec.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+"use strict";
+const helpers_safeImageUrl = require("../safeImageUrl.js");
+describe("safeImageUrl", () => {
+  it("passes through a valid https:// URL unchanged", () => {
+    const url = "https://example.com/icon.png";
+    expect(helpers_safeImageUrl.safeImageUrl(url)).toBe(url);
+  });
+  it("rejects an http:// URL and returns the default fallback", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("http://example.com/icon.png")).toBe("");
+  });
+  it("rejects a data: URL", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("data:image/png;base64,abc123")).toBe("");
+  });
+  it("rejects a javascript: URL", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("javascript:alert(1)")).toBe("");
+  });
+  it("rejects a file: URL", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("file:///etc/passwd")).toBe("");
+  });
+  it("rejects a blob: URL", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("blob:https://example.com/some-uuid")).toBe("");
+  });
+  it("rejects an empty string", () => {
+    expect(helpers_safeImageUrl.safeImageUrl("")).toBe("");
+  });
+  it("rejects undefined", () => {
+    expect(helpers_safeImageUrl.safeImageUrl(void 0)).toBe("");
+  });
+  it("rejects a URL longer than 2048 characters", () => {
+    const url = "https://example.com/" + "a".repeat(2030);
+    expect(url.length).toBeGreaterThan(2048);
+    expect(helpers_safeImageUrl.safeImageUrl(url)).toBe("");
+  });
+  it("allows a URL of exactly 2048 characters", () => {
+    const prefix = "https://example.com/";
+    const url = prefix + "a".repeat(2048 - prefix.length);
+    expect(url.length).toBe(2048);
+    expect(helpers_safeImageUrl.safeImageUrl(url)).toBe(url);
+  });
+  it("returns the custom fallback when URL is invalid", () => {
+    const fallback = "https://cdn.example.com/default.svg";
+    expect(helpers_safeImageUrl.safeImageUrl("http://bad.example.com/icon.png", fallback)).toBe(
+      fallback
+    );
+    expect(helpers_safeImageUrl.safeImageUrl(void 0, fallback)).toBe(fallback);
+    expect(helpers_safeImageUrl.safeImageUrl("javascript:void(0)", fallback)).toBe(fallback);
+  });
+});

package/helpers/tests/safeImageUrl.spec.mjs

@@ -0,0 +1,47 @@
+import { safeImageUrl } from "../safeImageUrl.mjs";
+describe("safeImageUrl", () => {
+  it("passes through a valid https:// URL unchanged", () => {
+    const url = "https://example.com/icon.png";
+    expect(safeImageUrl(url)).toBe(url);
+  });
+  it("rejects an http:// URL and returns the default fallback", () => {
+    expect(safeImageUrl("http://example.com/icon.png")).toBe("");
+  });
+  it("rejects a data: URL", () => {
+    expect(safeImageUrl("data:image/png;base64,abc123")).toBe("");
+  });
+  it("rejects a javascript: URL", () => {
+    expect(safeImageUrl("javascript:alert(1)")).toBe("");
+  });
+  it("rejects a file: URL", () => {
+    expect(safeImageUrl("file:///etc/passwd")).toBe("");
+  });
+  it("rejects a blob: URL", () => {
+    expect(safeImageUrl("blob:https://example.com/some-uuid")).toBe("");
+  });
+  it("rejects an empty string", () => {
+    expect(safeImageUrl("")).toBe("");
+  });
+  it("rejects undefined", () => {
+    expect(safeImageUrl(void 0)).toBe("");
+  });
+  it("rejects a URL longer than 2048 characters", () => {
+    const url = "https://example.com/" + "a".repeat(2030);
+    expect(url.length).toBeGreaterThan(2048);
+    expect(safeImageUrl(url)).toBe("");
+  });
+  it("allows a URL of exactly 2048 characters", () => {
+    const prefix = "https://example.com/";
+    const url = prefix + "a".repeat(2048 - prefix.length);
+    expect(url.length).toBe(2048);
+    expect(safeImageUrl(url)).toBe(url);
+  });
+  it("returns the custom fallback when URL is invalid", () => {
+    const fallback = "https://cdn.example.com/default.svg";
+    expect(safeImageUrl("http://bad.example.com/icon.png", fallback)).toBe(
+      fallback
+    );
+    expect(safeImageUrl(void 0, fallback)).toBe(fallback);
+    expect(safeImageUrl("javascript:void(0)", fallback)).toBe(fallback);
+  });
+});

package/helpers/tests/serializeTransaction.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/helpers/tests/serializeTransaction.spec.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+const helpers_serializeTransaction = require("../serializeTransaction.js");
+const baseTransaction = {
+  to: "0x1234567890abcdef1234567890abcdef12345678",
+  data: "0x",
+  gasLimit: 21000n,
+  value: 0n,
+  account: "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+  txHash: ""
+};
+describe("serializeTransaction", () => {
+  it("serialises a normal small BigInt correctly", () => {
+    const tx = { ...baseTransaction, value: 100n };
+    const result = JSON.parse(helpers_serializeTransaction.serializeTransaction(tx));
+    expect(result.value).toBe("100");
+  });
+  it("serialises a BigInt at exactly Number.MAX_SAFE_INTEGER correctly", () => {
+    const maxSafe = 9007199254740991n;
+    const tx = { ...baseTransaction, value: maxSafe };
+    const result = JSON.parse(helpers_serializeTransaction.serializeTransaction(tx));
+    expect(result.value).toBe("9007199254740991");
+  });
+  it("serialises 10 ETH in wei (above Number.MAX_SAFE_INTEGER) to the exact string without rounding", () => {
+    const tenEthInWei = 10000000000000000000n;
+    const tx = { ...baseTransaction, value: tenEthInWei };
+    const result = JSON.parse(helpers_serializeTransaction.serializeTransaction(tx));
+    expect(result.value).toBe("10000000000000000000");
+  });
+  it("serialises a value that would be corrupted by Number() to the exact string", () => {
+    const precisionLoss = 9007199254740993n;
+    const tx = { ...baseTransaction, value: precisionLoss };
+    const result = JSON.parse(helpers_serializeTransaction.serializeTransaction(tx));
+    expect(result.value).toBe("9007199254740993");
+    expect(result.value).not.toBe("9007199254740992");
+  });
+});

package/helpers/tests/serializeTransaction.spec.mjs

@@ -0,0 +1,35 @@
+import { serializeTransaction } from "../serializeTransaction.mjs";
+const baseTransaction = {
+  to: "0x1234567890abcdef1234567890abcdef12345678",
+  data: "0x",
+  gasLimit: 21000n,
+  value: 0n,
+  account: "0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+  txHash: ""
+};
+describe("serializeTransaction", () => {
+  it("serialises a normal small BigInt correctly", () => {
+    const tx = { ...baseTransaction, value: 100n };
+    const result = JSON.parse(serializeTransaction(tx));
+    expect(result.value).toBe("100");
+  });
+  it("serialises a BigInt at exactly Number.MAX_SAFE_INTEGER correctly", () => {
+    const maxSafe = 9007199254740991n;
+    const tx = { ...baseTransaction, value: maxSafe };
+    const result = JSON.parse(serializeTransaction(tx));
+    expect(result.value).toBe("9007199254740991");
+  });
+  it("serialises 10 ETH in wei (above Number.MAX_SAFE_INTEGER) to the exact string without rounding", () => {
+    const tenEthInWei = 10000000000000000000n;
+    const tx = { ...baseTransaction, value: tenEthInWei };
+    const result = JSON.parse(serializeTransaction(tx));
+    expect(result.value).toBe("10000000000000000000");
+  });
+  it("serialises a value that would be corrupted by Number() to the exact string", () => {
+    const precisionLoss = 9007199254740993n;
+    const tx = { ...baseTransaction, value: precisionLoss };
+    const result = JSON.parse(serializeTransaction(tx));
+    expect(result.value).toBe("9007199254740993");
+    expect(result.value).not.toBe("9007199254740992");
+  });
+});

package/index.js

@@ -15,9 +15,11 @@ const helpers_decodeLoginToken = require("./helpers/decodeLoginToken.js");
 const helpers_decodeToken = require("./helpers/decodeToken.js");
 const helpers_getApiURL = require("./helpers/getApiURL.js");
 const helpers_getBridgeURL = require("./helpers/getBridgeURL.js");
+const helpers_getDisplayName = require("./helpers/getDisplayName.js");
 const helpers_getMvxApiURL = require("./helpers/getMvxApiURL.js");
 const helpers_getMvxChainId = require("./helpers/getMvxChainId.js");
 const helpers_getMvxExplorerAddress = require("./helpers/getMvxExplorerAddress.js");
+const helpers_safeImageUrl = require("./helpers/safeImageUrl.js");
 const helpers_serializeTransaction = require("./helpers/serializeTransaction.js");
 ;/* empty css                */
 const reactjs_components_AccountAddress_AccountAddress = require("./reactjs/components/AccountAddress/AccountAddress.js");
@@ -104,9 +106,11 @@ exports.decodeLoginToken = helpers_decodeLoginToken.decodeLoginToken;
 exports.decodeToken = helpers_decodeToken.decodeToken;
 exports.getApiURL = helpers_getApiURL.getApiURL;
 exports.getBridgeURL = helpers_getBridgeURL.getBridgeURL;
+exports.getDisplayName = helpers_getDisplayName.getDisplayName;
 exports.getMvxApiURL = helpers_getMvxApiURL.getMvxApiURL;
 exports.getMvxChainId = helpers_getMvxChainId.getMvxChainId;
 exports.getMvxExplorerAddress = helpers_getMvxExplorerAddress.getMvxExplorerAddress;
+exports.safeImageUrl = helpers_safeImageUrl.safeImageUrl;
 exports.serializeTransaction = helpers_serializeTransaction.serializeTransaction;
 exports.AccountAddress = reactjs_components_AccountAddress_AccountAddress.AccountAddress;
 exports.AmountCard = reactjs_components_AmountCard_AmountCard.AmountCard;
@@ -161,12 +165,12 @@ exports.SuiMethods = reactjs_init_init.SuiMethods;
 exports.init = reactjs_init_init.init;
 exports.useGetAllTokensQuery = reactjs_queries_useGetAllTokens_query.useGetAllTokensQuery;
 exports.useGetChainsQuery = reactjs_queries_useGetChains_query.useGetChainsQuery;
-exports.invalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.invalidateEvmTokensBalances;
 exports.useGetNonMvxTokensBalancesQuery = reactjs_queries_useGetNonMvxTokensBalances_query.useGetNonMvxTokensBalancesQuery;
-exports.invalidateHistoryQuery = reactjs_queries_useGetHistory_query.invalidateHistoryQuery;
+exports.useInvalidateEvmTokensBalances = reactjs_queries_useGetNonMvxTokensBalances_query.useInvalidateEvmTokensBalances;
 exports.useGetHistoryQuery = reactjs_queries_useGetHistory_query.useGetHistoryQuery;
-exports.invalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.invalidateMvxTokensBalancesQuery;
+exports.useInvalidateHistoryQuery = reactjs_queries_useGetHistory_query.useInvalidateHistoryQuery;
 exports.useGetMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useGetMvxTokensBalancesQuery;
+exports.useInvalidateMvxTokensBalancesQuery = reactjs_queries_useGetMvxTokensBalances_query.useInvalidateMvxTokensBalancesQuery;
 exports.useGetRateMutation = reactjs_queries_useGetRate_mutation.useGetRateMutation;
 exports.delay = reactjs_utils_delay.delay;
 exports.formatAmount = reactjs_utils_formatAmount.formatAmount;

package/index.mjs

@@ -12,9 +12,11 @@ import { decodeLoginToken } from "./helpers/decodeLoginToken.mjs";
 import { decodeToken } from "./helpers/decodeToken.mjs";
 import { getApiURL } from "./helpers/getApiURL.mjs";
 import { getBridgeURL } from "./helpers/getBridgeURL.mjs";
+import { getDisplayName } from "./helpers/getDisplayName.mjs";
 import { getMvxApiURL } from "./helpers/getMvxApiURL.mjs";
 import { getMvxChainId } from "./helpers/getMvxChainId.mjs";
 import { getMvxExplorerAddress } from "./helpers/getMvxExplorerAddress.mjs";
+import { safeImageUrl } from "./helpers/safeImageUrl.mjs";
 import { serializeTransaction } from "./helpers/serializeTransaction.mjs";
 /* empty css                */
 import { AccountAddress } from "./reactjs/components/AccountAddress/AccountAddress.mjs";
@@ -66,9 +68,9 @@ import { useSuiConnect } from "./reactjs/hooks/useSuiConnect.mjs";
 import { SuiMethods, init } from "./reactjs/init/init.mjs";
 import { useGetAllTokensQuery } from "./reactjs/queries/useGetAllTokens.query.mjs";
 import { useGetChainsQuery } from "./reactjs/queries/useGetChains.query.mjs";
-import { invalidateEvmTokensBalances, useGetNonMvxTokensBalancesQuery } from "./reactjs/queries/useGetNonMvxTokensBalances.query.mjs";
-import { invalidateHistoryQuery, useGetHistoryQuery } from "./reactjs/queries/useGetHistory.query.mjs";
-import { invalidateMvxTokensBalancesQuery, useGetMvxTokensBalancesQuery } from "./reactjs/queries/useGetMvxTokensBalances.query.mjs";
+import { useGetNonMvxTokensBalancesQuery, useInvalidateEvmTokensBalances } from "./reactjs/queries/useGetNonMvxTokensBalances.query.mjs";
+import { useGetHistoryQuery, useInvalidateHistoryQuery } from "./reactjs/queries/useGetHistory.query.mjs";
+import { useGetMvxTokensBalancesQuery, useInvalidateMvxTokensBalancesQuery } from "./reactjs/queries/useGetMvxTokensBalances.query.mjs";
 import { useGetRateMutation } from "./reactjs/queries/useGetRate.mutation.mjs";
 import { delay } from "./reactjs/utils/delay.mjs";
 import { formatAmount } from "./reactjs/utils/formatAmount.mjs";
@@ -133,6 +135,7 @@ export {
   getChains,
   getCleanStringAmount,
   getCompletePathname,
+  getDisplayName,
   getInitialTokens,
   getMvxApiURL,
   getMvxChainId,
@@ -144,9 +147,6 @@ export {
   getTransactions,
   hasEnoughFunds,
   init,
-  invalidateEvmTokensBalances,
-  invalidateHistoryQuery,
-  invalidateMvxTokensBalancesQuery,
   isStringBase64,
   isStringFloat,
   mxClsx,
@@ -154,6 +154,7 @@ export {
   removeCommas,
   roundAmount,
   safeDocument,
+  safeImageUrl,
   safeWindow,
   sendTransactions,
   serializeTransaction,
@@ -182,6 +183,9 @@ export {
   useGetMvxTokensBalancesQuery,
   useGetNonMvxTokensBalancesQuery,
   useGetRateMutation,
+  useInvalidateEvmTokensBalances,
+  useInvalidateHistoryQuery,
+  useInvalidateMvxTokensBalancesQuery,
   useResolveTokenChain,
   useSecondAmountSchema,
   useSendTransactions,