@tcswap/helpers 4.5.15

package/src/utils/__tests__/explorerUrls.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { Chain, CosmosChains, EVMChains, getChainConfig, UTXOChains } from "@tcswap/helpers";
+import { getExplorerAddressUrl, getExplorerTxUrl } from "../explorerUrls";
+
+describe("Explorer URLs", () => {
+  describe("CosmosChains", () => {
+    for (const chain of CosmosChains) {
+      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
+        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
+          `${getChainConfig(chain).explorerUrl}/tx/123456789`,
+        );
+
+        expect(getExplorerAddressUrl({ address: "asdfg", chain })).toBe(
+          `${getChainConfig(chain).explorerUrl}/address/asdfg`,
+        );
+      });
+    }
+  });
+
+  describe("EVMChains & SubstrateChains", () => {
+    for (const chain of [...EVMChains, Chain.Polkadot]) {
+      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
+        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
+          `${getChainConfig(chain).explorerUrl}/tx/0x123456789`,
+        );
+
+        expect(getExplorerAddressUrl({ address: "asdfg", chain })).toBe(
+          `${getChainConfig(chain).explorerUrl}/address/asdfg`,
+        );
+      });
+    }
+
+    test("getExplorerTxUrl adds 0x for EVM like chains", () => {
+      expect(getExplorerTxUrl({ chain: Chain.Ethereum, txHash: "12345" })).toBe("https://etherscan.io/tx/0x12345");
+    });
+  });
+
+  describe("UTXOChains", () => {
+    for (const chain of UTXOChains.filter((c) => c !== Chain.Dash)) {
+      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
+        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
+          `${getChainConfig(chain).explorerUrl}/transaction/0x123456789`,
+        );
+
+        expect(getExplorerAddressUrl({ address: "asdfg", chain })).toBe(
+          `${getChainConfig(chain).explorerUrl}/address/asdfg`,
+        );
+      });
+    }
+  });
+
+  describe("Solana", () => {
+    test("getExplorerTxUrl returns correct URL for Solana", () => {
+      expect(getExplorerTxUrl({ chain: Chain.Solana, txHash: "b123456789" })).toBe("https://solscan.io/tx/b123456789");
+
+      expect(getExplorerAddressUrl({ address: "asdfg", chain: Chain.Solana })).toBe("https://solscan.io/account/asdfg");
+    });
+  });
+});

package/src/utils/__tests__/liquidity.test.ts

@@ -0,0 +1,302 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  getAsymmetricAssetShare,
+  getAsymmetricAssetWithdrawAmount,
+  getAsymmetricRuneShare,
+  getAsymmetricRuneWithdrawAmount,
+  getEstimatedPoolShare,
+  getLiquiditySlippage,
+  getSymmetricPoolShare,
+  getSymmetricWithdraw,
+} from "../liquidity";
+
+describe("getAsymmetricRuneShare", () => {
+  test("calculates rune share for typical pool position", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("returns zero rune share for zero liquidity units", () => {
+    const result = getAsymmetricRuneShare({ liquidityUnits: "0", poolUnits: "1000000000", runeDepth: "500000000000" });
+    expect(result.getValue("number")).toBe(0);
+  });
+
+  test("returns full amount when owning all pool units", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "1000000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("string")).toBe("5000");
+  });
+});
+
+describe("getAsymmetricAssetShare", () => {
+  test("calculates asset share for typical pool position", () => {
+    const result = getAsymmetricAssetShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("returns zero asset share for zero liquidity units", () => {
+    const result = getAsymmetricAssetShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBe(0);
+  });
+});
+
+describe("getAsymmetricRuneWithdrawAmount", () => {
+  test("calculates withdrawal amount for 50% withdrawal", () => {
+    const result = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("calculates full withdrawal for 100%", () => {
+    const full = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 1,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    const half = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(full.getValue("number")).toBeCloseTo(half.getValue("number") * 2, 5);
+  });
+});
+
+describe("getAsymmetricAssetWithdrawAmount", () => {
+  test("calculates withdrawal for given percentage", () => {
+    const result = getAsymmetricAssetWithdrawAmount({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      percent: 0.25,
+      poolUnits: "1000000000",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+});
+
+describe("getSymmetricPoolShare", () => {
+  test("returns both rune and asset amounts", () => {
+    const result = getSymmetricPoolShare({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.runeAmount.getValue("number")).toBeGreaterThan(0);
+    expect(result.assetAmount.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("proportionally distributes based on liquidity units", () => {
+    const result10 = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    const result20 = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "200000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    expect(result20.runeAmount.getValue("number")).toBeCloseTo(result10.runeAmount.getValue("number") * 2, 5);
+  });
+});
+
+describe("getSymmetricWithdraw", () => {
+  test("applies percentage to both amounts", () => {
+    const result = getSymmetricWithdraw({
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      percent: 0.5,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.runeAmount?.getValue("number")).toBeGreaterThan(0);
+    expect(result.assetAmount?.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("full withdrawal equals pool share", () => {
+    const params = {
+      assetDepth: "200000000000",
+      liquidityUnits: "100000000",
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    };
+    const share = getSymmetricPoolShare(params);
+    const withdraw = getSymmetricWithdraw({ ...params, percent: 1 });
+    expect(withdraw.runeAmount?.getValue("string")).toBe(share.runeAmount.getValue("string"));
+  });
+});
+
+describe("getEstimatedPoolShare", () => {
+  test("estimates pool share after adding liquidity", () => {
+    // Returns base value representation (with 8 decimals internally)
+    // For ~4.76% share, base value is 4761905 (0.04761905 * 10^8)
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+    // Base value for percentage < 100% is < 10^8
+    expect(result).toBeLessThan(100_000_000);
+  });
+
+  test("returns 0 when adding zero liquidity", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "0",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "0",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBe(0);
+  });
+});
+
+describe("getLiquiditySlippage", () => {
+  test("returns 0 when any amount is zero", () => {
+    expect(
+      getLiquiditySlippage({ assetAmount: "0", assetDepth: "200000000000", runeAmount: "100", runeDepth: "500" }),
+    ).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "0", runeAmount: "100", runeDepth: "500" })).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "200", runeAmount: "0", runeDepth: "500" })).toBe(0);
+    expect(getLiquiditySlippage({ assetAmount: "100", assetDepth: "200", runeAmount: "100", runeDepth: "0" })).toBe(0);
+  });
+
+  test("calculates slippage for balanced add", () => {
+    const result = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "250000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThanOrEqual(0);
+    expect(result).toBeLessThan(1);
+  });
+
+  test("returns absolute value (no negatives)", () => {
+    const result = getLiquiditySlippage({
+      assetAmount: "1000000000",
+      assetDepth: "200000000000",
+      runeAmount: "100000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe("edge cases", () => {
+  test("handles very large numbers without overflow", () => {
+    const result = getAsymmetricRuneShare({
+      liquidityUnits: "999999999999999999",
+      poolUnits: "9999999999999999999",
+      runeDepth: "99999999999999999999",
+    });
+    expect(result.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("getSymmetricPoolShare with equal depths", () => {
+    const result = getSymmetricPoolShare({
+      assetDepth: "1000000000000",
+      liquidityUnits: "500000000",
+      poolUnits: "1000000000",
+      runeDepth: "1000000000000",
+    });
+    // 50% of pool should get 50% of both depths
+    expect(result.runeAmount.getValue("string")).toBe(result.assetAmount.getValue("string"));
+  });
+
+  test("getEstimatedPoolShare with existing liquidity units", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "50000000", // User already has some units
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("handles single-sided liquidity add (only rune)", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "0",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "25000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("handles single-sided liquidity add (only asset)", () => {
+    const result = getEstimatedPoolShare({
+      assetAmount: "10000000000",
+      assetDepth: "200000000000",
+      liquidityUnits: "0",
+      poolUnits: "1000000000",
+      runeAmount: "0",
+      runeDepth: "500000000000",
+    });
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test("getAsymmetricRuneWithdrawAmount with 0% withdrawal returns 0", () => {
+    const result = getAsymmetricRuneWithdrawAmount({
+      liquidityUnits: "100000000",
+      percent: 0,
+      poolUnits: "1000000000",
+      runeDepth: "500000000000",
+    });
+    expect(result.getValue("number")).toBe(0);
+  });
+
+  test("getLiquiditySlippage higher slippage for unbalanced add", () => {
+    // Balanced add (proportional to pool)
+    const balanced = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "250000000",
+      runeDepth: "500000000000",
+    });
+
+    // Unbalanced add (too much rune)
+    const unbalanced = getLiquiditySlippage({
+      assetAmount: "100000000",
+      assetDepth: "200000000000",
+      runeAmount: "1000000000", // Much higher rune
+      runeDepth: "500000000000",
+    });
+
+    expect(unbalanced).toBeGreaterThan(balanced);
+  });
+});

package/src/utils/__tests__/memo.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@tcswap/types";
+import { MemoType } from "../../types";
+
+import {
+  getMemoForDeposit,
+  getMemoForLeaveAndBond,
+  getMemoForNamePreferredAssetRegister,
+  getMemoForNameRegister,
+  getMemoForRunePoolDeposit,
+  getMemoForRunePoolWithdraw,
+  getMemoForWithdraw,
+} from "../memo";
+
+describe("getMemoForLeaveAndBond", () => {
+  test("returns correct memo for Leave", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.LEAVE });
+    expect(result).toBe("LEAVE:ABC123");
+  });
+
+  test("returns correct memo for Bond", () => {
+    const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.BOND });
+    expect(result).toBe("BOND:ABC123");
+  });
+});
+
+describe("getMemoForNameRegister", () => {
+  test("returns correct memo for name registration", () => {
+    const result = getMemoForNameRegister({
+      address: "0xaasd123",
+      chain: Chain.Ethereum,
+      name: "asdfg",
+      owner: "thor1234",
+    });
+    expect(result).toBe("~:asdfg:ETH:0xaasd123:thor1234");
+  });
+});
+
+describe("getMemoForNamePreferredAssetRegister", () => {
+  test("returns correct memo for preferred asset registration", () => {
+    const result = getMemoForNamePreferredAssetRegister({
+      asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+      chain: Chain.Ethereum,
+      name: "asdfg",
+      owner: "thor1234",
+      payout: "0x6621d872f17109d6601c49edba526ebcfd332d5d",
+    });
+    expect(result).toBe(
+      "~:asdfg:ETH:0x6621d872f17109d6601c49edba526ebcfd332d5d:thor1234:ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    );
+  });
+});
+
+describe("getMemoForDeposit", () => {
+  test("returns correct memo for deposit", () => {
+    const result = getMemoForDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
+    expect(result).toBe("+:ETH.ETH");
+  });
+
+  test("returns correct memo when paired address is not available but affiliate info is present", () => {
+    const result = getMemoForDeposit({
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+      chain: Chain.Ethereum,
+      symbol: "ETH",
+    });
+    expect(result).toBe("+:ETH.ETH::thor1abc123:500");
+  });
+});
+
+describe("getMemoForWithdraw", () => {
+  test("returns correct memo for withdraw", () => {
+    const result = getMemoForWithdraw({ basisPoints: 100, chain: Chain.Ethereum, symbol: "ETH", ticker: "ETH" });
+    expect(result).toBe("-:ETH.ETH:100");
+  });
+});
+
+describe("getMemoForRunePoolDeposit", () => {
+  test("returns correct memo for rune pool deposit", () => {
+    const result = getMemoForRunePoolDeposit();
+    expect(result).toBe("POOL+");
+  });
+});
+
+describe("getMemoForRunePoolWithdraw", () => {
+  test("returns correct memo for rune pool withdraw", () => {
+    const result = getMemoForRunePoolWithdraw({ basisPoints: 500 });
+    expect(result).toBe("POOL-:500");
+  });
+
+  test("returns correct memo when affiliate info is present", () => {
+    const result = getMemoForRunePoolWithdraw({
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+      basisPoints: 500,
+    });
+    expect(result).toBe("POOL-:500:thor1abc123:500");
+  });
+});

package/src/utils/__tests__/others.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Chain } from "@tcswap/types";
+
+import { findAssetBy } from "../asset";
+import { getChainIdentifier, getMAYANameCost, getTHORNameCost, warnOnce, wrapWithThrow } from "../others";
+
+describe("getTHORNameCost", () => {
+  test("returns 10 + numberOfYears", () => {
+    expect(getTHORNameCost(0)).toBe(10);
+    expect(getTHORNameCost(1)).toBe(11);
+    expect(getTHORNameCost(5)).toBe(15);
+    expect(getTHORNameCost(10)).toBe(20);
+  });
+
+  test("throws for negative years in THORName cost", () => {
+    expect(() => getTHORNameCost(-1)).toThrow("helpers_invalid_number_of_years");
+    expect(() => getTHORNameCost(-100)).toThrow("helpers_invalid_number_of_years");
+  });
+});
+
+describe("getMAYANameCost", () => {
+  test("returns 10 + (numberOfYears * 1.0512)", () => {
+    expect(getMAYANameCost(0)).toBe(10);
+    expect(getMAYANameCost(1)).toBe(11.0512);
+    expect(getMAYANameCost(5)).toBeCloseTo(15.256, 3);
+    expect(getMAYANameCost(10)).toBeCloseTo(20.512, 3);
+  });
+
+  test("throws for negative years in MAYAName cost", () => {
+    expect(() => getMAYANameCost(-1)).toThrow("helpers_invalid_number_of_years");
+  });
+});
+
+describe("getChainIdentifier", () => {
+  test("returns CHAIN.RUNE for THORChain", () => {
+    expect(getChainIdentifier(Chain.THORChain)).toBe("THOR.RUNE");
+  });
+
+  test("returns CHAIN.ATOM for Cosmos", () => {
+    expect(getChainIdentifier(Chain.Cosmos)).toBe("GAIA.ATOM");
+  });
+
+  test("returns CHAIN only for BinanceSmartChain", () => {
+    expect(getChainIdentifier(Chain.BinanceSmartChain)).toBe("BSC");
+  });
+
+  test("returns CHAIN.CHAIN for other chains", () => {
+    expect(getChainIdentifier(Chain.Bitcoin)).toBe("BTC.BTC");
+    expect(getChainIdentifier(Chain.Ethereum)).toBe("ETH.ETH");
+    expect(getChainIdentifier(Chain.Avalanche)).toBe("AVAX.AVAX");
+  });
+});
+
+describe("wrapWithThrow", () => {
+  test("returns function result on success", () => {
+    expect(wrapWithThrow(() => 42)).toBe(42);
+    expect(wrapWithThrow(() => "hello")).toBe("hello");
+    expect(wrapWithThrow(() => ({ a: 1 }))).toEqual({ a: 1 });
+  });
+
+  test("returns undefined on error without errorKey", () => {
+    expect(
+      wrapWithThrow(() => {
+        throw new Error("test");
+      }),
+    ).toBeUndefined();
+  });
+
+  test("throws USwapError when errorKey provided", () => {
+    expect(() =>
+      wrapWithThrow(() => {
+        throw new Error("test");
+      }, "helpers_invalid_identifier"),
+    ).toThrow("helpers_invalid_identifier");
+  });
+});
+
+describe("warnOnce", () => {
+  // Note: warnOnce skips console.warn in test environment (NODE_ENV=test)
+  // We test the behavior by calling the function multiple times and observing
+  // that the function doesn't throw and handles repeated calls gracefully
+
+  test("does not throw when condition is false", () => {
+    expect(() => warnOnce({ condition: false, id: "test_false_condition", warning: "should not warn" })).not.toThrow();
+  });
+
+  test("does not throw when condition is true", () => {
+    const uniqueId = `test_warns_${Date.now()}`;
+    expect(() => warnOnce({ condition: true, id: uniqueId, warning: "test warning message" })).not.toThrow();
+  });
+
+  test("handles repeated calls with same id without throwing", () => {
+    const uniqueId = `test_once_${Date.now()}`;
+    expect(() => {
+      warnOnce({ condition: true, id: uniqueId, warning: "first warn" });
+      warnOnce({ condition: true, id: uniqueId, warning: "second warn" });
+      warnOnce({ condition: true, id: uniqueId, warning: "third warn" });
+    }).not.toThrow();
+  });
+
+  test("handles multiple different ids without throwing", () => {
+    const uniqueId1 = `test_different_1_${Date.now()}`;
+    const uniqueId2 = `test_different_2_${Date.now()}`;
+    expect(() => {
+      warnOnce({ condition: true, id: uniqueId1, warning: "warn 1" });
+      warnOnce({ condition: true, id: uniqueId2, warning: "warn 2" });
+    }).not.toThrow();
+  });
+});
+
+describe("getAssetBy", () => {
+  test("find ETH asset by identifier", async () => {
+    const assetByIdentifier = await findAssetBy({ identifier: "ETH.ETH" });
+    expect(assetByIdentifier).toBe("ETH.ETH");
+  });
+
+  test("find ETH token by chain and contract", async () => {
+    const assetByChainAndContract = await findAssetBy({
+      chain: Chain.Ethereum,
+      contract: "0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    });
+    expect(assetByChainAndContract?.toUpperCase()).toBe("ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48");
+  });
+
+  test("return undefined if asset can't be found", async () => {
+    const assetByIdentifier = await findAssetBy({ identifier: "ARB.NOTEXISTINGTOKEN" });
+    const assetByChainAndContract = await findAssetBy({ chain: Chain.Ethereum, contract: "NOTFOUND" });
+    expect(assetByIdentifier).toBeUndefined();
+    expect(assetByChainAndContract).toBeUndefined();
+  });
+
+  describe(Chain.Radix, () => {
+    test("find Radix XRD by identifier", async () => {
+      const assetByChainAndContract = await findAssetBy({ identifier: "XRD.XRD" });
+      expect(assetByChainAndContract?.toUpperCase()).toBe("XRD.XRD".toUpperCase());
+    });
+
+    test("find Radix token by chain and contract", async () => {
+      const assetByChainAndContract = await findAssetBy({
+        chain: Chain.Radix,
+        contract: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+      });
+      expect(assetByChainAndContract?.toUpperCase()).toBe(
+        "XRD.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75".toUpperCase(),
+      );
+    });
+  });
+
+  describe(Chain.Solana, () => {
+    test("find Solana SOL by identifier", async () => {
+      const assetByChainAndContract = await findAssetBy({ identifier: "SOL.SOL" });
+      expect(assetByChainAndContract?.toUpperCase()).toBe("SOL.SOL".toUpperCase());
+    });
+
+    test("find Solana token by chain and contract", async () => {
+      const assetByChainAndContract = await findAssetBy({
+        chain: Chain.Solana,
+        contract: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      });
+      expect(assetByChainAndContract?.toUpperCase()).toBe(
+        "SOL.USDC-EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".toUpperCase(),
+      );
+    });
+  });
+});