@swapkit/helpers 1.0.0-rc.99 → 1.0.0

package/src/modules/__tests__/assetValue.test.ts

@@ -41,6 +41,17 @@ describe("AssetValue", () => {
       });
 
       expect(atomDerived.toString()).toBe("THOR.ATOM");
+
+      const radixXWBTC = new AssetValue({
+        identifier:
+          "RADIX.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+        decimal: 8,
+        value: 11112222,
+      });
+
+      expect(radixXWBTC.toString()).toBe(
+        "RADIX.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+      );
     });
   });
 
@@ -56,7 +67,7 @@ describe("AssetValue", () => {
         "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
       );
 
-      const thor = AssetValue.fromChainOrSignature("ETH.THOR");
+      const thor = AssetValue.from({ asset: "ETH.THOR" });
       expect(thor.toUrl()).toBe("ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044");
 
       const ethSynth = new AssetValue({
@@ -79,9 +90,9 @@ describe("AssetValue", () => {
 
   describe("eq", () => {
     test("checks if assets are same chain and symbol", () => {
-      const firstThor = AssetValue.fromChainOrSignature("ETH.THOR");
-      const secondThor = AssetValue.fromChainOrSignature("ETH.THOR");
-      const vThor = AssetValue.fromChainOrSignature("ETH.vTHOR");
+      const firstThor = AssetValue.from({ asset: "ETH.THOR" });
+      const secondThor = AssetValue.from({ asset: "ETH.THOR" });
+      const vThor = AssetValue.from({ asset: "ETH.vTHOR" });
       const firstUsdc = new AssetValue({
         chain: Chain.Avalanche,
         symbol: "USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
@@ -95,26 +106,51 @@ describe("AssetValue", () => {
         value: 1234,
       });
 
+      expect(firstThor.eqAsset(firstThor)).toBe(true);
+      expect(firstThor.eqAsset(secondThor)).toBe(true);
+      expect(firstThor.eqAsset(vThor)).toBe(false);
+      expect(firstThor.eqAsset(firstUsdc)).toBe(false);
+      expect(firstThor.eqAsset(secondUsdc)).toBe(false);
+
+      expect(firstUsdc.eqAsset(firstThor)).toBe(false);
+      expect(firstUsdc.eqAsset(secondThor)).toBe(false);
+      expect(firstUsdc.eqAsset(vThor)).toBe(false);
+      expect(firstUsdc.eqAsset(firstUsdc)).toBe(true);
+      expect(firstUsdc.eqAsset(secondUsdc)).toBe(true);
+    });
+
+    test("check if assets have same value, even if not same asset", () => {
+      const firstThor = AssetValue.from({ asset: "ETH.THOR", value: "20" });
+      const secondThor = AssetValue.from({ asset: "ETH.THOR", value: "35" });
+      const thirdThor = AssetValue.from({ asset: "ETH.THOR", value: "35" });
+      const vThor = AssetValue.from({ asset: "ETH.vTHOR", value: "20" });
+
+      expect(firstThor.eqValue(firstThor)).toBe(true);
+      expect(firstThor.eqValue(secondThor)).toBe(false);
+      expect(secondThor.eqValue(thirdThor)).toBe(true);
+      expect(firstThor.eqValue(vThor)).toBe(true);
+    });
+
+    test("check if assets have identical asset and value", () => {
+      const firstThor = AssetValue.from({ asset: "ETH.THOR", value: "20" });
+      const secondThor = AssetValue.from({ asset: "ETH.THOR", value: "35" });
+      const thirdThor = AssetValue.from({ asset: "ETH.THOR", value: "35" });
+      const vThor = AssetValue.from({ asset: "ETH.vTHOR", value: "20" });
+
       expect(firstThor.eq(firstThor)).toBe(true);
-      expect(firstThor.eq(secondThor)).toBe(true);
+      expect(firstThor.eq(secondThor)).toBe(false);
+      expect(secondThor.eq(thirdThor)).toBe(true);
       expect(firstThor.eq(vThor)).toBe(false);
-      expect(firstThor.eq(firstUsdc)).toBe(false);
-      expect(firstThor.eq(secondUsdc)).toBe(false);
-
-      expect(firstUsdc.eq(firstThor)).toBe(false);
-      expect(firstUsdc.eq(secondThor)).toBe(false);
-      expect(firstUsdc.eq(vThor)).toBe(false);
-      expect(firstUsdc.eq(firstUsdc)).toBe(true);
-      expect(firstUsdc.eq(secondUsdc)).toBe(true);
     });
   });
 
   describe("from bigint", () => {
     test("returns asset value with correct decimal", async () => {
-      const avaxUSDCAsset = await AssetValue.fromIdentifier(
-        `${Chain.Avalanche}.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e`,
-        1234567800n,
-      );
+      const avaxUSDCAsset = await AssetValue.from({
+        asset: `${Chain.Avalanche}.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e`,
+        value: 1234567800n,
+        asyncTokenLookup: true,
+      });
       expect(avaxUSDCAsset.getValue("string")).toBe("1234.5678");
     });
   });
@@ -129,19 +165,20 @@ describe("AssetValue", () => {
       });
       expect(avaxUSDCAsset.toString()).toBe("AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e");
 
-      const thor = AssetValue.fromChainOrSignature("ETH.THOR");
+      const thor = AssetValue.from({ asset: "ETH.THOR" });
       expect(thor.toString()).toBe("ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044");
 
-      const ethSynth = await AssetValue.fromIdentifier("ETH/ETH");
+      const ethSynth = await AssetValue.from({ asset: "ETH/ETH", asyncTokenLookup: true });
       expect(ethSynth.toString()).toBe("ETH/ETH");
     });
   });
 
   describe("fromIdentifier", () => {
     test("creates AssetValue from string", async () => {
-      const avaxUSDCAsset = await AssetValue.fromIdentifier(
-        "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
-      );
+      const avaxUSDCAsset = await AssetValue.from({
+        asset: "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
+        asyncTokenLookup: true,
+      });
 
       expect(avaxUSDCAsset).toEqual(
         expect.objectContaining({
@@ -155,8 +192,12 @@ describe("AssetValue", () => {
         }),
       );
     });
+
     test("creates AssetValue from string with multiple dashes", async () => {
-      const ethPendleLptAsset = await AssetValue.fromIdentifier("ETH.PENDLE-LPT-0x1234");
+      const ethPendleLptAsset = await AssetValue.from({
+        asset: "ETH.PENDLE-LPT-0x1234",
+        asyncTokenLookup: true,
+      });
 
       expect(ethPendleLptAsset).toEqual(
         expect.objectContaining({
@@ -175,7 +216,10 @@ describe("AssetValue", () => {
   describe("fromString", () => {
     test("creates AssetValue from string", async () => {
       const fakeAvaxAssetString = "AVAX.ASDF-1234";
-      const fakeAvaxAsset = await AssetValue.fromString(fakeAvaxAssetString);
+      const fakeAvaxAsset = await AssetValue.from({
+        asset: fakeAvaxAssetString,
+        asyncTokenLookup: true,
+      });
 
       expect(fakeAvaxAsset).toEqual(
         expect.objectContaining({
@@ -189,9 +233,13 @@ describe("AssetValue", () => {
         }),
       );
     });
+
     test("creates AssetValue from string with multiple dashes", async () => {
       const fakeAvaxAssetString = "AVAX.ASDF-LP-1234";
-      const fakeAvaxAsset = await AssetValue.fromString(fakeAvaxAssetString);
+      const fakeAvaxAsset = await AssetValue.from({
+        asset: fakeAvaxAssetString,
+        asyncTokenLookup: true,
+      });
 
       expect(fakeAvaxAsset).toEqual(
         expect.objectContaining({
@@ -205,12 +253,36 @@ describe("AssetValue", () => {
         }),
       );
     });
+
+    test("creates AssetValue with _ symbol", async () => {
+      const radixXWBTC = await AssetValue.from({
+        asset: "XRD.XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+        asyncTokenLookup: true,
+      });
+
+      expect(radixXWBTC).toEqual(
+        expect.objectContaining({
+          address: "resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+          chain: Chain.Radix,
+          decimal: 8,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: "XWBTC-resource_rdx1t580qxc7upat7lww4l2c4jckacafjeudxj5wpjrrct0p3e82sq4y75",
+          ticker: "XWBTC",
+        }),
+      );
+    });
   });
 
   describe("fromStringWithBase", () => {
     test("creates AssetValue from string with base", async () => {
       const fakeAvaxAssetString = "AVAX.ASDF-1234";
-      const fakeAvaxAsset = await AssetValue.fromStringWithBase(fakeAvaxAssetString, 1, 8);
+      const fakeAvaxAsset = await AssetValue.from({
+        asset: fakeAvaxAssetString,
+        value: 1,
+        fromBaseDecimal: 8,
+        asyncTokenLookup: true,
+      });
 
       expect(fakeAvaxAsset).toEqual(
         expect.objectContaining({
@@ -223,24 +295,24 @@ describe("AssetValue", () => {
           ticker: "ASDF",
         }),
       );
-      expect(fakeAvaxAsset.getValue("string")).toBe("100000000");
-      expect(fakeAvaxAsset.getBaseValue("string")).toBe("100000000000000000000000000");
+      expect(fakeAvaxAsset.getValue("string")).toBe("0.00000001");
+      expect(fakeAvaxAsset.getBaseValue("string")).toBe("10000000000");
     });
   });
 
   describe("fromUrl", () => {
-    test("creates AssetValue from url like format", async () => {
+    test("creates AssetValue from url like format", () => {
       const synthETHString = "THOR.ETH.ETH";
       const ethString = "ETH.ETH";
       const thorString = "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044";
       const synthThorString = "THOR.ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044";
       const synthDashesString = "THOR.ETH.PENDLE-LPT-0x1234";
 
-      const synthETH = await AssetValue.fromUrl(synthETHString);
-      const eth = await AssetValue.fromUrl(ethString);
-      const thor = await AssetValue.fromUrl(thorString);
-      const synthThor = await AssetValue.fromUrl(synthThorString);
-      const synthDashes = await AssetValue.fromUrl(synthDashesString);
+      const synthETH = AssetValue.fromUrl(synthETHString);
+      const eth = AssetValue.fromUrl(ethString);
+      const thor = AssetValue.fromUrl(thorString);
+      const synthThor = AssetValue.fromUrl(synthThorString);
+      const synthDashes = AssetValue.fromUrl(synthDashesString);
 
       expect(synthETH.toString()).toBe("ETH/ETH");
       expect(eth.toString()).toBe("ETH.ETH");
@@ -253,9 +325,9 @@ describe("AssetValue", () => {
   describe("fromIdentifierSync", () => {
     test("(same as fromIdentifier) - creates AssetValue from string via `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
-      const thor = AssetValue.fromIdentifierSync(
-        "ARB.USDT-0XFD086BC7CD5C481DCC9C85EBE478A1C0B69FCBB9",
-      );
+      const thor = AssetValue.from({
+        asset: "ARB.USDT-0XFD086BC7CD5C481DCC9C85EBE478A1C0B69FCBB9",
+      });
 
       expect(thor).toBeDefined();
       expect(thor).toEqual(
@@ -275,7 +347,9 @@ describe("AssetValue", () => {
   describe("fromStringSync", () => {
     test("creates AssetValue from string via `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
-      const thor = AssetValue.fromStringSync("ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044");
+      const thor = AssetValue.from({
+        asset: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
+      });
 
       expect(thor).toBeDefined();
       expect(thor).toEqual(
@@ -290,7 +364,9 @@ describe("AssetValue", () => {
         }),
       );
 
-      const usdc = AssetValue.fromStringSync("ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48");
+      const usdc = AssetValue.from({
+        asset: "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+      });
       expect(usdc).toBeDefined();
       expect(usdc).toEqual(
         expect.objectContaining({
@@ -308,7 +384,7 @@ describe("AssetValue", () => {
     test("returns safe decimals if string is not in `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = "AVAX.USDC-1234";
-      const fakeAvaxUSDCAsset = AssetValue.fromStringSync(fakeAvaxUSDCAssetString);
+      const fakeAvaxUSDCAsset = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
 
       expect(fakeAvaxUSDCAsset).toBeDefined();
       expect(fakeAvaxUSDCAsset).toEqual(
@@ -327,10 +403,10 @@ describe("AssetValue", () => {
     test("returns safe decimals if string is not in `@swapkit/tokens` lists with multiple dashes", async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = "AVAX.USDC-LPT-1234";
-      const fakeAvaxUSDCAsset = AssetValue.fromStringSync(fakeAvaxUSDCAssetString);
+      const fakeAvaxUSDCAsset2 = AssetValue.from({ asset: fakeAvaxUSDCAssetString });
 
-      expect(fakeAvaxUSDCAsset).toBeDefined();
-      expect(fakeAvaxUSDCAsset).toEqual(
+      expect(fakeAvaxUSDCAsset2).toBeDefined();
+      expect(fakeAvaxUSDCAsset2).toEqual(
         expect.objectContaining({
           address: "1234",
           chain: Chain.Avalanche,
@@ -346,7 +422,7 @@ describe("AssetValue", () => {
     test("returns proper avax string with address from `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
       const avaxBTCb = "AVAX.BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50";
-      const AvaxBTCb = AssetValue.fromStringSync(avaxBTCb);
+      const AvaxBTCb = AssetValue.from({ asset: avaxBTCb });
 
       expect(AvaxBTCb).toBeDefined();
       expect(AvaxBTCb).toEqual(
@@ -356,8 +432,8 @@ describe("AssetValue", () => {
           decimal: 8,
           isGasAsset: false,
           isSynthetic: false,
-          symbol: "BTC.b-0x152b9d0fdc40c096757f570a51e494bd4b943e50",
-          ticker: "BTC.b",
+          symbol: "BTC.B-0x152b9d0fdc40c096757f570a51e494bd4b943e50",
+          ticker: "BTC.B",
         }),
       );
     });
@@ -366,7 +442,11 @@ describe("AssetValue", () => {
   describe("fromStringWithBaseSync", () => {
     test("creates AssetValue from string with base decimals via `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
-      const btc = AssetValue.fromStringWithBaseSync("BTC.BTC", 5200000000000, 8);
+      const btc = AssetValue.from({
+        asset: "BTC.BTC",
+        value: 5200000000000,
+        fromBaseDecimal: 8,
+      });
 
       expect(btc).toBeDefined();
       expect(btc).toEqual(
@@ -387,7 +467,11 @@ describe("AssetValue", () => {
     test("returns safe decimals if string is not in `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
       const fakeAvaxUSDCAssetString = "AVAX.USDC-1234";
-      const fakeAvaxUSDCAsset = AssetValue.fromStringWithBaseSync(fakeAvaxUSDCAssetString, 1, 8);
+      const fakeAvaxUSDCAsset = AssetValue.from({
+        asset: fakeAvaxUSDCAssetString,
+        value: 1,
+        fromBaseDecimal: 8,
+      });
 
       expect(fakeAvaxUSDCAsset).toBeDefined();
       expect(fakeAvaxUSDCAsset).toEqual(
@@ -409,7 +493,11 @@ describe("AssetValue", () => {
     test("returns proper avax string with address from `@swapkit/tokens` lists", async () => {
       await AssetValue.loadStaticAssets();
       const avaxUSDC = "AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e";
-      const AvaxUSDC = AssetValue.fromStringWithBaseSync(avaxUSDC, 100000000, 8);
+      const AvaxUSDC = AssetValue.from({
+        asset: avaxUSDC,
+        value: 100000000,
+        fromBaseDecimal: 8,
+      });
 
       expect(AvaxUSDC).toBeDefined();
       expect(AvaxUSDC).toEqual(
@@ -431,33 +519,7 @@ describe("AssetValue", () => {
 
   describe("fromChainOrSignature", () => {
     test("creates AssetValue from common asset string or chain", () => {
-      const customBaseAsset = [
-        Chain.Cosmos,
-        Chain.BinanceSmartChain,
-        Chain.THORChain,
-        Chain.Maya,
-        Chain.Arbitrum,
-        Chain.Optimism,
-      ];
-      const filteredChains = Object.values(Chain).filter((c) => !customBaseAsset.includes(c));
-
-      for (const chain of filteredChains) {
-        const asset = AssetValue.fromChainOrSignature(chain);
-        expect(asset).toEqual(
-          expect.objectContaining({
-            address: undefined,
-            chain,
-            decimal: BaseDecimal[chain],
-            isGasAsset: true,
-            isSynthetic: false,
-            symbol: chain,
-            ticker: chain,
-            type: "Native",
-          }),
-        );
-      }
-
-      const cosmosAsset = AssetValue.fromChainOrSignature(Chain.Cosmos);
+      const cosmosAsset = AssetValue.from({ chain: Chain.Cosmos });
       expect(cosmosAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -471,7 +533,7 @@ describe("AssetValue", () => {
         }),
       );
 
-      const bscAsset = AssetValue.fromChainOrSignature(Chain.BinanceSmartChain);
+      const bscAsset = AssetValue.from({ chain: Chain.BinanceSmartChain });
       expect(bscAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -485,7 +547,7 @@ describe("AssetValue", () => {
         }),
       );
 
-      const thorAsset = AssetValue.fromChainOrSignature(Chain.THORChain);
+      const thorAsset = AssetValue.from({ chain: Chain.THORChain });
       expect(thorAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -499,7 +561,7 @@ describe("AssetValue", () => {
         }),
       );
 
-      const cacaoAsset = AssetValue.fromChainOrSignature(Chain.Maya);
+      const cacaoAsset = AssetValue.from({ chain: Chain.Maya });
       expect(cacaoAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -513,33 +575,34 @@ describe("AssetValue", () => {
         }),
       );
 
-      const thor = AssetValue.fromChainOrSignature("ETH.THOR");
-      expect(thor).toEqual(
-        expect.objectContaining({
-          address: "0xa5f2211b9b8170f694421f2046281775e8468044",
-          chain: Chain.Ethereum,
-          decimal: 18,
-          isGasAsset: false,
-          isSynthetic: false,
-          symbol: "THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
-          ticker: "THOR",
-        }),
-      );
-
-      const vthor = AssetValue.fromChainOrSignature("ETH.vTHOR");
-      expect(vthor).toEqual(
-        expect.objectContaining({
-          address: "0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
-          chain: Chain.Ethereum,
-          decimal: 18,
-          isGasAsset: false,
-          isSynthetic: false,
-          symbol: "vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
-          ticker: "vTHOR",
-        }),
-      );
-
-      const arbAsset = AssetValue.fromChainOrSignature(Chain.Arbitrum);
+      // TODO enable when BE fixes case sensitivity
+      //   const thor = AssetValue.from({ asset: "ETH.THOR" });
+      //   expect(thor).toEqual(
+      //     expect.objectContaining({
+      //       address: "0xa5f2211b9b8170f694421f2046281775e8468044",
+      //       chain: Chain.Ethereum,
+      //       decimal: 18,
+      //       isGasAsset: false,
+      //       isSynthetic: false,
+      //       symbol: "THOR-0xa5f2211b9b8170f694421f2046281775e8468044",
+      //       ticker: "THOR",
+      //     }),
+      //   );
+
+      //   const vthor = AssetValue.from({ asset: "ETH.vTHOR" });
+      //   expect(vthor).toEqual(
+      //     expect.objectContaining({
+      //       address: "0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+      //       chain: Chain.Ethereum,
+      //       decimal: 18,
+      //       isGasAsset: false,
+      //       isSynthetic: false,
+      //       symbol: "vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d",
+      //       ticker: "vTHOR",
+      //     }),
+      //   );
+
+      const arbAsset = AssetValue.from({ chain: Chain.Arbitrum });
       expect(arbAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -553,7 +616,7 @@ describe("AssetValue", () => {
         }),
       );
 
-      const opAsset = AssetValue.fromChainOrSignature(Chain.Optimism);
+      const opAsset = AssetValue.from({ chain: Chain.Optimism });
       expect(opAsset).toEqual(
         expect.objectContaining({
           address: undefined,
@@ -566,14 +629,20 @@ describe("AssetValue", () => {
           type: "Native",
         }),
       );
-    });
-  });
 
-  describe("loadStaticAssets", () => {
-    test("loads static assets from `@swapkit/tokens` lists", async () => {
-      // Dummy test - think of sth more meaningful
-      const { ok } = await AssetValue.loadStaticAssets();
-      expect(ok).toBe(true);
+      const xrdAsset = AssetValue.from({ chain: Chain.Radix });
+      expect(xrdAsset).toEqual(
+        expect.objectContaining({
+          address: undefined,
+          chain: Chain.Radix,
+          decimal: BaseDecimal.XRD,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: "XRD",
+          ticker: "XRD",
+          type: "Native",
+        }),
+      );
     });
   });
 });