@swapkit/helpers 1.0.0-rc.3 → 1.0.0-rc.30

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

@@ -8,37 +8,40 @@ describe('SwapKitNumber', () => {
       const skNumber1 = new SwapKitNumber(1);
       expect(skNumber1.getValue('string')).toBe('1');
       expect(skNumber1.getValue('number')).toBe(1);
-      expect(skNumber1.getValue('bigint')).toBe(100000000n);
+      expect(skNumber1.getBaseValue('bigint')).toBe(100000000n);
 
       const skNumber2 = new SwapKitNumber('1');
       expect(skNumber2.getValue('string')).toBe('1');
-      expect(skNumber2.getValue('bigint')).toBe(100000000n);
+      expect(skNumber2.getBaseValue('bigint')).toBe(100000000n);
 
+      /**
+       * because by default we have 8 decimals - it will be rounded to 0 on base value
+       */
       const skNumber3 = new SwapKitNumber('0.0000000001');
       expect(skNumber3.getValue('string')).toBe('0.0000000001');
-      expect(skNumber3.getValue('bigint')).toBe(1n);
+      expect(skNumber3.getBaseValue('bigint')).toBe(0n);
 
-      const skNumber4 = new SwapKitNumber(0.000000001);
-      expect(skNumber4.getValue('string')).toBe('0.000000001');
-      expect(skNumber4.getValue('bigint')).toBe(1n);
+      const skNumber4 = new SwapKitNumber({ value: '0.0000000001', decimal: 10 });
+      expect(skNumber4.getValue('string')).toBe('0.0000000001');
+      expect(skNumber4.getBaseValue('bigint')).toBe(1n);
 
-      const skNumber6 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
-      expect(skNumber6.getValue('string')).toBe('0.101');
-      expect(skNumber6.getValue('bigint')).toBe(10050000n);
+      const skNumber5 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
+      expect(skNumber5.getValue('string')).toBe('0.101');
+      expect(skNumber5.getBaseValue('bigint')).toBe(100n);
 
-      const skNumber7 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
-      expect(skNumber7.getValue('string')).toBe('-0.101');
-      expect(skNumber7.getValue('bigint')).toBe(-10050000n);
-      expect(skNumber7.decimal).toBe(3);
-      expect(skNumber7.getValue('number')).toBe(-0.101);
-      expect(skNumber7.decimalMultiplier).toBe(100000000n);
+      const skNumber6 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
+      expect(skNumber6.getValue('string')).toBe('-0.101');
+      expect(skNumber6.getBaseValue('bigint')).toBe(-100n);
+      expect(skNumber6.decimal).toBe(3);
+      expect(skNumber6.getValue('number')).toBe(-0.101);
+      expect(skNumber6.decimalMultiplier).toBe(100000000n);
     });
 
     test('creates SwapKitInstance from BigInt: (12.345678901234, decimals: 12)', () => {
       const skNumber = SwapKitNumber.fromBigInt(12345678901234n, 12);
 
       expect(skNumber.getValue('string')).toBe('12.345678901234');
-      expect(skNumber.getValue('bigint')).toBe(12345678901234n);
+      expect(skNumber.getBaseValue('bigint')).toBe(12345678901234n);
     });
   });
 
@@ -46,22 +49,22 @@ describe('SwapKitNumber', () => {
     test('shifts up and bumps number', () => {
       const skNumber = new SwapKitNumber(1);
       expect(skNumber.getValue('string')).toBe('1');
-      expect(skNumber.getValue('bigint')).toBe(100000000n);
+      expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
-        from: 6,
-        to: 8,
+        from: 8,
+        to: 6,
       });
 
-      expect(shiftedSkNumber.getValue('string')).toBe('100');
-      expect(shiftedSkNumber.getValue('bigint')).toBe(10000000000n);
+      expect(shiftedSkNumber.getValue('string')).toBe('1');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(1000000n);
     });
 
     test('shifts down and rounds down number', () => {
       const skNumber = new SwapKitNumber(2.12345678);
       expect(skNumber.getValue('string')).toBe('2.12345678');
-      expect(skNumber.getValue('bigint')).toBe(212345678n);
+      expect(skNumber.getBaseValue('bigint')).toBe(212345678n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -70,7 +73,20 @@ describe('SwapKitNumber', () => {
       });
 
       expect(shiftedSkNumber.getValue('string')).toBe('2.123456');
-      expect(shiftedSkNumber.getValue('bigint')).toBe(212345600n);
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(2123456n);
+    });
+
+    test('shift eth from 18 to 8', () => {
+      const skNumber = new SwapKitNumber({ value: '0.2', decimal: 18 });
+
+      const shiftedSkNumber = SwapKitNumber.shiftDecimals({
+        value: skNumber,
+        from: 18,
+        to: 8,
+      });
+
+      expect(shiftedSkNumber.getValue('string')).toBe('0.2');
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(20000000n);
     });
   });
 
@@ -102,7 +118,7 @@ describe('SwapKitNumber', () => {
     describe('bigint', () => {
       test('returns bigint value', () => {
         const skNumber = new SwapKitNumber(1);
-        expect(skNumber.getValue('bigint')).toBe(100000000n);
+        expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
       });
     });
   });
@@ -150,6 +166,76 @@ describe('SwapKitNumber', () => {
     });
   });
 
+  describe('toAbbreviation', () => {
+    test('returns abbreviation with up to 3 integer digits', () => {
+      const skNumber = new SwapKitNumber(1234.5678);
+      expect(skNumber.toAbbreviation()).toBe('1.23K');
+
+      const skNumber2 = new SwapKitNumber(1234567.5678);
+      expect(skNumber2.toAbbreviation()).toBe('1.23M');
+
+      const skNumber3 = new SwapKitNumber(1234567890.5678);
+      expect(skNumber3.toAbbreviation()).toBe('1.23B');
+
+      const skNumber4 = new SwapKitNumber(1234567890123.5678);
+      expect(skNumber4.toAbbreviation()).toBe('1.23T');
+
+      const skNumber5 = new SwapKitNumber(1234567890123456.5678);
+      expect(skNumber5.toAbbreviation()).toBe('1.23Q');
+
+      const skNumber6 = new SwapKitNumber(1234567890123456789.5678);
+      expect(skNumber6.toAbbreviation()).toBe('1.23Qi');
+
+      const skNumber7 = new SwapKitNumber(1234567890123456789012.5678);
+      expect(skNumber7.toAbbreviation()).toBe('1.23S');
+
+      const skNumber8 = new SwapKitNumber(1234.5678);
+      expect(skNumber8.toAbbreviation(0)).toBe('1K');
+
+      const skNumber9 = new SwapKitNumber(1234.5678);
+      expect(skNumber9.toAbbreviation(1)).toBe('1.2K');
+
+      const skNumber10 = new SwapKitNumber(123456.78);
+      expect(skNumber10.toAbbreviation()).toBe('123.46K');
+    });
+  });
+
+  describe('toCurrency', () => {
+    test('returns abbreviation with up to 3 integer digits', () => {
+      const skNumber = new SwapKitNumber(1234.5678);
+      expect(skNumber.toCurrency()).toBe('$1,234.56');
+      expect(
+        skNumber.toCurrency('€', {
+          decimalSeparator: ',',
+          thousandSeparator: ' ',
+          currencyPosition: 'end',
+        }),
+      ).toBe('1 234,56€');
+
+      const skNumber2 = new SwapKitNumber(0.5678);
+      expect(skNumber2.toCurrency()).toBe('$0.5678');
+      expect(
+        skNumber2.toCurrency('€', {
+          decimalSeparator: ',',
+          currencyPosition: 'end',
+        }),
+      ).toBe('0,5678€');
+
+      const skNumber3 = new SwapKitNumber(0.00005678);
+      expect(skNumber3.toCurrency()).toBe('$0.000057');
+      expect(
+        skNumber3.toCurrency('€', {
+          decimalSeparator: ',',
+          thousandSeparator: ' ',
+          currencyPosition: 'end',
+        }),
+      ).toBe('0,000057€');
+
+      const skNumber4 = new SwapKitNumber(12345);
+      expect(skNumber4.toCurrency()).toBe('$12,345');
+    });
+  });
+
   describe('add', () => {
     test('adds same type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
@@ -158,7 +244,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.add(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('15.5');
-      expect(result.getValue('bigint')).toBe(1550000000n);
+      expect(result.getBaseValue('bigint')).toBe(1550000000n);
     });
 
     test('adds different type numbers correctly', () => {
@@ -166,14 +252,14 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.add(6, '0.5');
 
       expect(result.getValue('string')).toBe('16.5');
-      expect(result.getValue('bigint')).toBe(1650000000n);
+      expect(result.getBaseValue('bigint')).toBe(1650000000n);
     });
 
     test('adds large decimal numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(0.0000000001);
       const result = skNumber1.add(6.000000000001, '0.0000000000000005');
       expect(result.getValue('string')).toBe('6.0000000001010005');
-      expect(result.getValue('bigint')).toBe(60000000001010005n);
+      expect(result.getBaseValue('bigint')).toBe(600000000n);
     });
   });
 
@@ -185,7 +271,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.sub(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('4.5');
-      expect(result.getValue('bigint')).toBe(450000000n);
+      expect(result.getBaseValue('bigint')).toBe(450000000n);
     });
 
     test('subtracts different type numbers correctly', () => {
@@ -193,7 +279,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.sub(6, '0.5');
 
       expect(result.getValue('string')).toBe('3.5');
-      expect(result.getValue('bigint')).toBe(350000000n);
+      expect(result.getBaseValue('bigint')).toBe(350000000n);
     });
 
     test('can process negative results', () => {
@@ -203,8 +289,8 @@ describe('SwapKitNumber', () => {
 
       expect(result0.getValue('string')).toBe('0');
       expect(resultMinus.getValue('string')).toBe('-10');
-      expect(result0.getValue('bigint')).toBe(0n);
-      expect(resultMinus.getValue('bigint')).toBe(-1000000000n);
+      expect(result0.getBaseValue('bigint')).toBe(0n);
+      expect(resultMinus.getBaseValue('bigint')).toBe(-1000000000n);
     });
   });
 
@@ -216,7 +302,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('25');
-      expect(result.getValue('bigint')).toBe(2500000000n);
+      expect(result.getBaseValue('bigint')).toBe(2500000000n);
     });
 
     test('multiplies different type numbers correctly', () => {
@@ -224,7 +310,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul(6, '0.5');
 
       expect(result.getValue('string')).toBe('30');
-      expect(result.getValue('bigint')).toBe(3000000000n);
+      expect(result.getBaseValue('bigint')).toBe(3000000000n);
     });
 
     test('multiplies numbers correctly if decimals of SKN is lower than number multiplied with', () => {
@@ -232,19 +318,19 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul('0.00001');
 
       expect(result.getValue('string')).toBe('10');
-      expect(result.getValue('bigint')).toBe(1000000000n);
+      expect(result.getBaseValue('bigint')).toBe(100000n);
     });
 
     test('should correctly round the result of multiplication', () => {
-      const skNumber1 = new SwapKitNumber({ decimal: 2, value: 1.23 });
+      const skNumber1 = new SwapKitNumber({ decimal: 3, value: 1.23 });
       const skNumber2 = new SwapKitNumber({ decimal: 4, value: 4.56 });
 
       const result = skNumber1.mul(skNumber2);
 
       // The exact result of 1.23 * 4.56 is 5.6088
       // If we round it to 2 decimal places, we should get 5.61
-      expect(result.getValue('string')).toBe('5.61');
-      expect(result.getValue('bigint')).toBe(560880000n);
+      expect(result.getValue('string')).toBe('5.609');
+      expect(result.getBaseValue('bigint')).toBe(5608n);
 
       const skNumber3 = new SwapKitNumber({ decimal: 2, value: 1.23 });
       const skNumber4 = new SwapKitNumber(-1.234567891);
@@ -254,7 +340,7 @@ describe('SwapKitNumber', () => {
       // The exact result of 1.23 * -1.234567891 is -1,518518505
       // If we round it to 2 decimal places, we should get 5.61
       expect(result2.getValue('string')).toBe('-1.52');
-      expect(result2.getValue('bigint')).toBe(-1518518505n);
+      expect(result2.getBaseValue('bigint')).toBe(-151n);
     });
   });
 
@@ -266,13 +352,13 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('4');
-      expect(result.getValue('bigint')).toBe(400000000n);
+      expect(result.getBaseValue('bigint')).toBe(400000000n);
 
       const skNumber4 = new SwapKitNumber(10.12);
       const result2 = skNumber4.div(0.0001);
 
       expect(result2.getValue('string')).toBe('101200');
-      expect(result2.getValue('bigint')).toBe(10120000000000n);
+      expect(result2.getBaseValue('bigint')).toBe(10120000000000n);
     });
 
     test('divides different type numbers correctly', () => {
@@ -280,7 +366,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(5, '0.5');
 
       expect(result.getValue('string')).toBe('8');
-      expect(result.getValue('bigint')).toBe(800000000n);
+      expect(result.getBaseValue('bigint')).toBe(800000000n);
     });
 
     test('divides different type numbers correctly when decimal is set', () => {
@@ -288,7 +374,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(0.001);
 
       expect(result.getValue('string')).toBe('1200');
-      expect(result.getValue('bigint')).toBe(120000000000n);
+      expect(result.getBaseValue('bigint')).toBe(120000n);
     });
 
     test('divides smaller number by larger number', () => {
@@ -296,7 +382,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(2);
 
       expect(result.getValue('string')).toBe('0.5');
-      expect(result.getValue('bigint')).toBe(50000000n);
+      expect(result.getBaseValue('bigint')).toBe(50000000n);
     });
 
     test('divides a number with 18 decimals by a negative number with less decimals', () => {
@@ -307,7 +393,7 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 1.000000000000000010 / -2 is -0.500000000000000005
       expect(result.getValue('string')).toBe('-0.500000000000000005');
-      expect(result.getValue('bigint')).toBe(-500000000000000005n);
+      expect(result.getBaseValue('bigint')).toBe(-500000000000000005n);
     });
 
     test('divides a number with 2 decimals by a negative number with more decimals', () => {
@@ -318,7 +404,7 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 2 / -0.000005 is -400000
       expect(result.getValue('string')).toBe('-400000');
-      expect(result.getValue('bigint')).toBe(-40000000000000n);
+      expect(result.getBaseValue('bigint')).toBe(-40000000n);
     });
   });
 
@@ -329,7 +415,7 @@ describe('SwapKitNumber', () => {
 
       const result = skNumber1.mul(skNumber2);
       expect(result.getValue('string')).toBe('987654321000000987654321000');
-      expect(result.getValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
+      expect(result.getBaseValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
     });
 
     test('divide huge numbers', () => {
@@ -338,7 +424,7 @@ describe('SwapKitNumber', () => {
 
       const result = skNumber1.div(skNumber2);
       expect(result.getValue('string')).toBe('1012.4999999873447625');
-      expect(result.getValue('bigint')).toBe(1012499999987344762500n);
+      expect(result.getBaseValue('bigint')).toBe(1012499999987344762500n);
     });
   });
 

package/src/modules/assetValue.ts

@@ -17,9 +17,15 @@ import type { CommonAssetString } from '../helpers/asset.ts';
 import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from '../helpers/asset.ts';
 import { validateIdentifier } from '../helpers/validators.ts';
 
-import { BigIntArithmetics } from './bigIntArithmetics.ts';
+import type { NumberPrimitives } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 import type { SwapKitValueType } from './swapKitNumber.ts';
 
+const safeValue = (value: NumberPrimitives, decimal: number) =>
+  typeof value === 'bigint'
+    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    : value;
+
 type AssetValueParams = { decimal: number; value: SwapKitValueType } & (
   | { chain: Chain; symbol: string }
   | { identifier: string }
@@ -51,33 +57,27 @@ const getStaticToken = (identifier: TokenNames) => {
   return tokenInfo || { decimal: BaseDecimal.THOR, identifier: '' };
 };
 
-const createAssetValue = async (assetString: string, value: number | string = 0) => {
+const createAssetValue = async (assetString: string, value: NumberPrimitives = 0) => {
   validateIdentifier(assetString);
 
   const decimal = await getDecimal(getAssetInfo(assetString));
-  return new AssetValue({ decimal, value, identifier: assetString });
+  const parsedValue = safeValue(value, decimal);
+
+  return new AssetValue({ decimal, value: parsedValue, identifier: assetString });
 };
 
 export class AssetValue extends BigIntArithmetics {
-  address?: string;
-  chain: Chain;
-  isSynthetic = false;
-  isGasAsset = false;
-  symbol: string;
-  ticker: string;
-  type: ReturnType<typeof getAssetType>;
-
   constructor(params: AssetValueParams) {
+    const identifier =
+      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
+
     super(
       params.value instanceof BigIntArithmetics
         ? params.value
         : { decimal: params.decimal, value: params.value },
     );
 
-    const identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
     const assetInfo = getAssetInfo(identifier);
-
     this.type = getAssetType(assetInfo);
     this.chain = assetInfo.chain;
     this.ticker = assetInfo.ticker;
@@ -87,67 +87,68 @@ export class AssetValue extends BigIntArithmetics {
     this.isGasAsset = assetInfo.isGasAsset;
   }
 
-  get assetValue() {
-    return `${this.getValue('string')} ${this.ticker}`;
-  }
+  address?: string;
+  isSynthetic = false;
+  isGasAsset = false;
+  chain: Chain;
+  symbol: string;
+  ticker: string;
+  type: ReturnType<typeof getAssetType>;
+
+  toString(short = false) {
+    // THOR.RUNE | ETH/ETH
+    const shortFormat = this.isSynthetic ? this.symbol.split('-')[0] : this.ticker;
 
-  toString() {
-    return `${this.chain}.${this.symbol}`;
+    return short
+      ? shortFormat
+      : // THOR.ETH/ETH | ETH.USDT-0x1234567890
+        `${this.chain}.${this.symbol}`;
   }
 
   eq({ chain, symbol }: { chain: Chain; symbol: string }) {
     return this.chain === chain && this.symbol === symbol;
   }
 
-  static async fromString(assetString: string, value: number | string = 0) {
+  static async fromString(assetString: string, value: NumberPrimitives = 0) {
     return createAssetValue(assetString, value);
   }
 
-  static fromStringSync(assetString: string, value: number | string = 0) {
+  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
+    const { isSynthetic } = getAssetInfo(assetString);
     const { decimal, identifier: tokenIdentifier } = getStaticToken(
       assetString as unknown as TokenNames,
     );
 
-    return tokenIdentifier
-      ? new AssetValue({ decimal, identifier: tokenIdentifier, value })
+    const parsedValue = safeValue(value, decimal);
+
+    const asset = tokenIdentifier
+      ? new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue })
+      : isSynthetic
+      ? new AssetValue({ decimal: 8, identifier: assetString, value: parsedValue })
       : undefined;
+
+    return asset;
   }
 
   static async fromIdentifier(
     assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`,
-    value: number | string = 0,
+    value: NumberPrimitives = 0,
   ) {
     return createAssetValue(assetString, value);
   }
 
-  static fromIdentifierSync(identifier: TokenNames, value: number | string = 0) {
+  static fromIdentifierSync(identifier: TokenNames, value: NumberPrimitives = 0) {
     const { decimal, identifier: tokenIdentifier } = getStaticToken(identifier);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ decimal, identifier: tokenIdentifier, value });
+    return new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue });
   }
 
-  static fromChainOrSignature(assetString: CommonAssetString, value: number | string = 0) {
+  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
     const { decimal, identifier } = getCommonAssetInfo(assetString);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ value, decimal, identifier });
-  }
-
-  static async fromTCQuote(identifier: TCTokenNames, value: number | string = 0) {
-    const decimal = await getDecimal(getAssetInfo(identifier));
-    const shiftedValue = this.shiftDecimals({ value, from: BaseDecimal.THOR, to: decimal });
-
-    return new AssetValue({ value: shiftedValue, identifier, decimal });
-  }
-
-  static fromTCQuoteStatic(identifier: TCTokenNames, value: number | string = 0) {
-    const tokenInfo = getStaticToken(identifier);
-    const shiftedValue = this.shiftDecimals({
-      value,
-      from: BaseDecimal.THOR,
-      to: tokenInfo.decimal,
-    });
-
-    return new AssetValue({ ...tokenInfo, value: shiftedValue });
+    return new AssetValue({ value: parsedValue, decimal, identifier });
   }
 
   static async loadStaticAssets() {
@@ -198,39 +199,41 @@ export const getMinAmountByChain = (chain: Chain) => {
     case Chain.Bitcoin:
     case Chain.Litecoin:
     case Chain.BitcoinCash:
-      return asset.add(10001);
+      return asset.set(0.00010001);
 
     case Chain.Dogecoin:
-      return asset.add(100000001);
+      return asset.set(1.00000001);
 
     case Chain.Avalanche:
     case Chain.Ethereum:
-      return asset.add(10 * 10 ** 9);
+      return asset.set(0.00000001);
 
     case Chain.THORChain:
     case Chain.Maya:
-      return asset.add(0);
+      return asset.set(0);
 
     default:
-      return asset.add(1);
+      return asset.set(0.00000001);
   }
 };
 
 const getAssetInfo = (identifier: string) => {
   const isSynthetic = identifier.slice(0, 14).includes('/');
-  const adjustedIdentifier = identifier.includes('.')
-    ? identifier
-    : `${Chain.THORChain}.${identifier}`;
+  const [synthChain, synthSymbol] = identifier.split('.').pop()!.split('/');
+  const adjustedIdentifier =
+    identifier.includes('.') && !isSynthetic ? identifier : `${Chain.THORChain}.${synthSymbol}`;
 
   const [chain, symbol] = adjustedIdentifier.split('.') as [Chain, string];
-  const [ticker, address] = symbol.split('-') as [string, string?];
+  const [ticker, address] = (isSynthetic ? synthSymbol : symbol).split('-') as [string, string?];
 
   return {
     address: address?.toLowerCase(),
     chain,
     isGasAsset: isGasAsset({ chain, symbol }),
     isSynthetic,
-    symbol: address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol,
-    ticker: isSynthetic ? symbol : ticker,
+    symbol:
+      (isSynthetic ? `${synthChain}/` : '') +
+      (address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol),
+    ticker: ticker,
   };
 };