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

package/helpers/tests/assertRateConfirmationMatchesIntent.spec.js

@@ -1,64 +1,2 @@
 #!/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);
-  });
-});
+"use strict";const r=require("../../types/errors.js"),e=require("../assertRateConfirmationMatchesIntent.js"),o=(n={})=>({to:"0xdeadbeef",data:"0x",gasLimit:BigInt(21e3),value:BigInt(0),account:"0xSender",txHash:"",...n});describe("assertRateConfirmationMatchesIntent",()=>{const n={fromChainId:"1",sender:"0xSender"};it("does not throw for an empty transactions array",()=>{expect(()=>e.assertRateConfirmationMatchesIntent(n,[])).not.toThrow()}),it("does not throw when chainID and account match",()=>{const t=o({chainID:"1",account:"0xSender"});expect(()=>e.assertRateConfirmationMatchesIntent(n,[t])).not.toThrow()}),it("does not throw when chainID is undefined (field absent)",()=>{const t=o({account:"0xSender"});expect(()=>e.assertRateConfirmationMatchesIntent(n,[t])).not.toThrow()}),it("throws RateConfirmationMismatchError when chainID does not match fromChainId",()=>{const t=o({chainID:"999",account:"0xSender"});expect(()=>e.assertRateConfirmationMatchesIntent(n,[t])).toThrow(r.RateConfirmationMismatchError)}),it("throws RateConfirmationMismatchError when account does not match sender (case-insensitive)",()=>{const t=o({account:"0xAttacker"});expect(()=>e.assertRateConfirmationMatchesIntent(n,[t])).toThrow(r.RateConfirmationMismatchError)}),it("does not throw when account matches sender case-insensitively",()=>{const t=o({account:"0xsender"}),a={fromChainId:"1",sender:"0xSENDER"};expect(()=>e.assertRateConfirmationMatchesIntent(a,[t])).not.toThrow()}),it("throws RateConfirmationMismatchError when MvX sender field does not match",()=>{const t=o({account:"0xSender",sender:"erd1attacker"}),a={fromChainId:"1",sender:"erd1legit"};expect(()=>e.assertRateConfirmationMatchesIntent(a,[t])).toThrow(r.RateConfirmationMismatchError)}),it("throws on the bad transaction when mixed valid and invalid transactions are present",()=>{const t=o({chainID:"1",account:"0xSender"}),a=o({chainID:"999",account:"0xSender"});expect(()=>e.assertRateConfirmationMatchesIntent(n,[t,a])).toThrow(r.RateConfirmationMismatchError)})});

package/helpers/tests/assertRateConfirmationMatchesIntent.spec.mjs

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

package/helpers/tests/base64Utils.spec.js

@@ -1,30 +1,2 @@
 #!/usr/bin/env node
-"use strict";
-const helpers_base64Utils = require("../base64Utils.js");
-describe("base64Utils", () => {
-  it("encodes a string to base64", () => {
-    const input = "Hello, World!";
-    const expectedOutput = "SGVsbG8sIFdvcmxkIQ==";
-    expect(helpers_base64Utils.encodeToBase64(input)).toBe(expectedOutput);
-  });
-  it("decodes a base64 string", () => {
-    const input = "SGVsbG8sIFdvcmxkIQ==";
-    const expectedOutput = "Hello, World!";
-    expect(helpers_base64Utils.decodeBase64(input)).toBe(expectedOutput);
-  });
-  it("encodes an empty string to base64", () => {
-    const input = "";
-    const expectedOutput = "";
-    expect(helpers_base64Utils.encodeToBase64(input)).toBe(expectedOutput);
-  });
-  it("decodes an empty base64 string", () => {
-    const input = "";
-    const expectedOutput = "";
-    expect(helpers_base64Utils.decodeBase64(input)).toBe(expectedOutput);
-  });
-  it("retrieve the given input if is an invalid base64 string", () => {
-    const input = "Invalid base64 string";
-    const decoded = helpers_base64Utils.decodeBase64(input);
-    expect(decoded).toEqual(input);
-  });
-});
+"use strict";const s=require("../base64Utils.js");describe("base64Utils",()=>{it("encodes a string to base64",()=>{expect(s.encodeToBase64("Hello, World!")).toBe("SGVsbG8sIFdvcmxkIQ==")}),it("decodes a base64 string",()=>{expect(s.decodeBase64("SGVsbG8sIFdvcmxkIQ==")).toBe("Hello, World!")}),it("encodes an empty string to base64",()=>{expect(s.encodeToBase64("")).toBe("")}),it("decodes an empty base64 string",()=>{expect(s.decodeBase64("")).toBe("")}),it("retrieve the given input if is an invalid base64 string",()=>{const e="Invalid base64 string",t=s.decodeBase64(e);expect(t).toEqual(e)})});

package/helpers/tests/base64Utils.spec.mjs

@@ -1,28 +1,15 @@
-import { encodeToBase64, decodeBase64 } from "../base64Utils.mjs";
+import { encodeToBase64 as n, decodeBase64 as s } from "../base64Utils.mjs";
 describe("base64Utils", () => {
   it("encodes a string to base64", () => {
-    const input = "Hello, World!";
-    const expectedOutput = "SGVsbG8sIFdvcmxkIQ==";
-    expect(encodeToBase64(input)).toBe(expectedOutput);
-  });
-  it("decodes a base64 string", () => {
-    const input = "SGVsbG8sIFdvcmxkIQ==";
-    const expectedOutput = "Hello, World!";
-    expect(decodeBase64(input)).toBe(expectedOutput);
-  });
-  it("encodes an empty string to base64", () => {
-    const input = "";
-    const expectedOutput = "";
-    expect(encodeToBase64(input)).toBe(expectedOutput);
-  });
-  it("decodes an empty base64 string", () => {
-    const input = "";
-    const expectedOutput = "";
-    expect(decodeBase64(input)).toBe(expectedOutput);
-  });
-  it("retrieve the given input if is an invalid base64 string", () => {
-    const input = "Invalid base64 string";
-    const decoded = decodeBase64(input);
-    expect(decoded).toEqual(input);
+    expect(n("Hello, World!")).toBe("SGVsbG8sIFdvcmxkIQ==");
+  }), it("decodes a base64 string", () => {
+    expect(s("SGVsbG8sIFdvcmxkIQ==")).toBe("Hello, World!");
+  }), it("encodes an empty string to base64", () => {
+    expect(n("")).toBe("");
+  }), it("decodes an empty base64 string", () => {
+    expect(s("")).toBe("");
+  }), it("retrieve the given input if is an invalid base64 string", () => {
+    const t = "Invalid base64 string", e = s(t);
+    expect(e).toEqual(t);
   });
 });

package/helpers/tests/decodeLoginToken.spec.js

@@ -1,35 +1,2 @@
 #!/usr/bin/env node
-"use strict";
-const helpers_decodeLoginToken = require("../decodeLoginToken.js");
-describe("decodeLoginToken", () => {
-  it("decodes a valid login token", () => {
-    const token = "aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9";
-    const expectedPayload = {
-      origin: "https://devnet.template-dapp.multiversx.com",
-      blockHash: "ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",
-      ttl: 86400,
-      extraInfo: { timestamp: 1733489400 }
-    };
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toEqual(expectedPayload);
-  });
-  it("returns null for an invalid login token", () => {
-    const token = "invalid.token.here";
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for an empty token", () => {
-    const token = "";
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with less than 4 parts", () => {
-    const token = "part1.part2.part3";
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with more than 4 parts", () => {
-    const token = "part1.part2.part3.part4.part5";
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with invalid JSON in extraInfo", () => {
-    const token = "b3JpZ2lu.blockHash.3600.invalidBase64";
-    expect(helpers_decodeLoginToken.decodeLoginToken(token)).toBeNull();
-  });
-});
+"use strict";const t=require("../decodeLoginToken.js");describe("decodeLoginToken",()=>{it("decodes a valid login token",()=>{const e="aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9",o={origin:"https://devnet.template-dapp.multiversx.com",blockHash:"ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",ttl:86400,extraInfo:{timestamp:1733489400}};expect(t.decodeLoginToken(e)).toEqual(o)}),it("returns null for an invalid login token",()=>{expect(t.decodeLoginToken("invalid.token.here")).toBeNull()}),it("returns null for an empty token",()=>{expect(t.decodeLoginToken("")).toBeNull()}),it("returns null for a token with less than 4 parts",()=>{expect(t.decodeLoginToken("part1.part2.part3")).toBeNull()}),it("returns null for a token with more than 4 parts",()=>{expect(t.decodeLoginToken("part1.part2.part3.part4.part5")).toBeNull()}),it("returns null for a token with invalid JSON in extraInfo",()=>{expect(t.decodeLoginToken("b3JpZ2lu.blockHash.3600.invalidBase64")).toBeNull()})});

package/helpers/tests/decodeLoginToken.spec.mjs

@@ -1,33 +1,22 @@
-import { decodeLoginToken } from "../decodeLoginToken.mjs";
+import { decodeLoginToken as e } from "../decodeLoginToken.mjs";
 describe("decodeLoginToken", () => {
   it("decodes a valid login token", () => {
-    const token = "aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9";
-    const expectedPayload = {
+    const t = "aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9", n = {
       origin: "https://devnet.template-dapp.multiversx.com",
       blockHash: "ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",
       ttl: 86400,
       extraInfo: { timestamp: 1733489400 }
     };
-    expect(decodeLoginToken(token)).toEqual(expectedPayload);
-  });
-  it("returns null for an invalid login token", () => {
-    const token = "invalid.token.here";
-    expect(decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for an empty token", () => {
-    const token = "";
-    expect(decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with less than 4 parts", () => {
-    const token = "part1.part2.part3";
-    expect(decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with more than 4 parts", () => {
-    const token = "part1.part2.part3.part4.part5";
-    expect(decodeLoginToken(token)).toBeNull();
-  });
-  it("returns null for a token with invalid JSON in extraInfo", () => {
-    const token = "b3JpZ2lu.blockHash.3600.invalidBase64";
-    expect(decodeLoginToken(token)).toBeNull();
+    expect(e(t)).toEqual(n);
+  }), it("returns null for an invalid login token", () => {
+    expect(e("invalid.token.here")).toBeNull();
+  }), it("returns null for an empty token", () => {
+    expect(e("")).toBeNull();
+  }), it("returns null for a token with less than 4 parts", () => {
+    expect(e("part1.part2.part3")).toBeNull();
+  }), it("returns null for a token with more than 4 parts", () => {
+    expect(e("part1.part2.part3.part4.part5")).toBeNull();
+  }), it("returns null for a token with invalid JSON in extraInfo", () => {
+    expect(e("b3JpZ2lu.blockHash.3600.invalidBase64")).toBeNull();
   });
 });

package/helpers/tests/decodeToken.spec.js

@@ -1,28 +1,2 @@
 #!/usr/bin/env node
-"use strict";
-const helpers_decodeToken = require("../decodeToken.js");
-describe("decodeToken", () => {
-  it("decodes a valid native auth token", async () => {
-    const token = "ZXJkMXdoOWMwc2pyMnhuOGh6ZjAybHd3Y3I0amsyczg0dGF0OXVkMmthcTZ6cjd4enB2bDlsNXE4YXdtZXg.YUhSMGNITTZMeTlrWlhadVpYUXVkR1Z0Y0d4aGRHVXRaR0Z3Y0M1dGRXeDBhWFpsY25ONExtTnZiUS5lZjc2YjRjNzZlZjZlMTNhNjM5MDc2N2ZjNzhhODhjYTRiYmI1OTE4YTJiOWRkYzQ0OTQyOTI3NjkzNjUwNjUxLjg2NDAwLmV5SjBhVzFsYzNSaGJYQWlPakUzTXpNME9EazBNREI5.04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01";
-    const expectedPayload = {
-      address: "erd1wh9c0sjr2xn8hzf02lwwcr4jk2s84tat9ud2kaq6zr7xzpvl9l5q8awmex",
-      blockHash: "ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",
-      body: "aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9",
-      extraInfo: {
-        timestamp: 1733489400
-      },
-      origin: "https://devnet.template-dapp.multiversx.com",
-      signature: "04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01",
-      ttl: 86400
-    };
-    expect(helpers_decodeToken.decodeToken(token)).toEqual(expectedPayload);
-  });
-  it("returns null for an invalid native auth token", async () => {
-    const token = "invalid.token.here";
-    expect(helpers_decodeToken.decodeToken(token)).toBeNull();
-  });
-  it("returns null for an empty token", async () => {
-    const token = "";
-    expect(helpers_decodeToken.decodeToken(token)).toBeNull();
-  });
-});
+"use strict";const a=require("../decodeToken.js");describe("decodeToken",()=>{it("decodes a valid native auth token",async()=>{const e="ZXJkMXdoOWMwc2pyMnhuOGh6ZjAybHd3Y3I0amsyczg0dGF0OXVkMmthcTZ6cjd4enB2bDlsNXE4YXdtZXg.YUhSMGNITTZMeTlrWlhadVpYUXVkR1Z0Y0d4aGRHVXRaR0Z3Y0M1dGRXeDBhWFpsY25ONExtTnZiUS5lZjc2YjRjNzZlZjZlMTNhNjM5MDc2N2ZjNzhhODhjYTRiYmI1OTE4YTJiOWRkYzQ0OTQyOTI3NjkzNjUwNjUxLjg2NDAwLmV5SjBhVzFsYzNSaGJYQWlPakUzTXpNME9EazBNREI5.04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01",c={address:"erd1wh9c0sjr2xn8hzf02lwwcr4jk2s84tat9ud2kaq6zr7xzpvl9l5q8awmex",blockHash:"ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",body:"aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9",extraInfo:{timestamp:1733489400},origin:"https://devnet.template-dapp.multiversx.com",signature:"04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01",ttl:86400};expect(a.decodeToken(e)).toEqual(c)}),it("returns null for an invalid native auth token",async()=>{expect(a.decodeToken("invalid.token.here")).toBeNull()}),it("returns null for an empty token",async()=>{expect(a.decodeToken("")).toBeNull()})});

package/helpers/tests/decodeToken.spec.mjs

@@ -1,8 +1,7 @@
-import { decodeToken } from "../decodeToken.mjs";
+import { decodeToken as a } from "../decodeToken.mjs";
 describe("decodeToken", () => {
   it("decodes a valid native auth token", async () => {
-    const token = "ZXJkMXdoOWMwc2pyMnhuOGh6ZjAybHd3Y3I0amsyczg0dGF0OXVkMmthcTZ6cjd4enB2bDlsNXE4YXdtZXg.YUhSMGNITTZMeTlrWlhadVpYUXVkR1Z0Y0d4aGRHVXRaR0Z3Y0M1dGRXeDBhWFpsY25ONExtTnZiUS5lZjc2YjRjNzZlZjZlMTNhNjM5MDc2N2ZjNzhhODhjYTRiYmI1OTE4YTJiOWRkYzQ0OTQyOTI3NjkzNjUwNjUxLjg2NDAwLmV5SjBhVzFsYzNSaGJYQWlPakUzTXpNME9EazBNREI5.04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01";
-    const expectedPayload = {
+    const e = "ZXJkMXdoOWMwc2pyMnhuOGh6ZjAybHd3Y3I0amsyczg0dGF0OXVkMmthcTZ6cjd4enB2bDlsNXE4YXdtZXg.YUhSMGNITTZMeTlrWlhadVpYUXVkR1Z0Y0d4aGRHVXRaR0Z3Y0M1dGRXeDBhWFpsY25ONExtTnZiUS5lZjc2YjRjNzZlZjZlMTNhNjM5MDc2N2ZjNzhhODhjYTRiYmI1OTE4YTJiOWRkYzQ0OTQyOTI3NjkzNjUwNjUxLjg2NDAwLmV5SjBhVzFsYzNSaGJYQWlPakUzTXpNME9EazBNREI5.04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01", c = {
       address: "erd1wh9c0sjr2xn8hzf02lwwcr4jk2s84tat9ud2kaq6zr7xzpvl9l5q8awmex",
       blockHash: "ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651",
       body: "aHR0cHM6Ly9kZXZuZXQudGVtcGxhdGUtZGFwcC5tdWx0aXZlcnN4LmNvbQ.ef76b4c76ef6e13a6390767fc78a88ca4bbb5918a2b9ddc44942927693650651.86400.eyJ0aW1lc3RhbXAiOjE3MzM0ODk0MDB9",
@@ -13,14 +12,10 @@ describe("decodeToken", () => {
       signature: "04a986df7f0142837f9b1ca1ae4829f7b471e4c3470602ca6a16f2a4d7c6616c4e7628a93b4ce87d9534e95ab9215f893faeb9e0904e1d834007c16e43b12d01",
       ttl: 86400
     };
-    expect(decodeToken(token)).toEqual(expectedPayload);
-  });
-  it("returns null for an invalid native auth token", async () => {
-    const token = "invalid.token.here";
-    expect(decodeToken(token)).toBeNull();
-  });
-  it("returns null for an empty token", async () => {
-    const token = "";
-    expect(decodeToken(token)).toBeNull();
+    expect(a(e)).toEqual(c);
+  }), it("returns null for an invalid native auth token", async () => {
+    expect(a("invalid.token.here")).toBeNull();
+  }), it("returns null for an empty token", async () => {
+    expect(a("")).toBeNull();
   });
 });

package/helpers/tests/safeImageUrl.spec.js

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

package/helpers/tests/safeImageUrl.spec.mjs

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

package/helpers/tests/serializeTransaction.spec.js

@@ -1,37 +1,2 @@
 #!/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");
-  });
-});
+"use strict";const s=require("../serializeTransaction.js"),n={to:"0x1234567890abcdef1234567890abcdef12345678",data:"0x",gasLimit:21000n,value:0n,account:"0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef",txHash:""};describe("serializeTransaction",()=>{it("serialises a normal small BigInt correctly",()=>{const a={...n,value:100n},e=JSON.parse(s.serializeTransaction(a));expect(e.value).toBe("100")}),it("serialises a BigInt at exactly Number.MAX_SAFE_INTEGER correctly",()=>{const e={...n,value:9007199254740991n},t=JSON.parse(s.serializeTransaction(e));expect(t.value).toBe("9007199254740991")}),it("serialises 10 ETH in wei (above Number.MAX_SAFE_INTEGER) to the exact string without rounding",()=>{const e={...n,value:10000000000000000000n},t=JSON.parse(s.serializeTransaction(e));expect(t.value).toBe("10000000000000000000")}),it("serialises a value that would be corrupted by Number() to the exact string",()=>{const e={...n,value:9007199254740993n},t=JSON.parse(s.serializeTransaction(e));expect(t.value).toBe("9007199254740993"),expect(t.value).not.toBe("9007199254740992")})});

package/helpers/tests/serializeTransaction.spec.mjs

@@ -1,5 +1,5 @@
-import { serializeTransaction } from "../serializeTransaction.mjs";
-const baseTransaction = {
+import { serializeTransaction as s } from "../serializeTransaction.mjs";
+const n = {
   to: "0x1234567890abcdef1234567890abcdef12345678",
   data: "0x",
   gasLimit: 21000n,
@@ -9,27 +9,16 @@ const baseTransaction = {
 };
 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");
+    const a = { ...n, value: 100n }, e = JSON.parse(s(a));
+    expect(e.value).toBe("100");
+  }), it("serialises a BigInt at exactly Number.MAX_SAFE_INTEGER correctly", () => {
+    const e = { ...n, value: 9007199254740991n }, t = JSON.parse(s(e));
+    expect(t.value).toBe("9007199254740991");
+  }), it("serialises 10 ETH in wei (above Number.MAX_SAFE_INTEGER) to the exact string without rounding", () => {
+    const e = { ...n, value: 10000000000000000000n }, t = JSON.parse(s(e));
+    expect(t.value).toBe("10000000000000000000");
+  }), it("serialises a value that would be corrupted by Number() to the exact string", () => {
+    const e = { ...n, value: 9007199254740993n }, t = JSON.parse(s(e));
+    expect(t.value).toBe("9007199254740993"), expect(t.value).not.toBe("9007199254740992");
   });
 });