@swapkit/helpers 1.0.0-rc.8 → 1.0.0-rc.80

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

@@ -1,59 +1,86 @@
-import { describe, expect, it } from 'vitest';
+import { Chain } from "@swapkit/types";
+import { describe, expect, test } from "vitest";
 
-import { derivationPathToString, getTHORNameCost, validateTHORName } from '../others.ts';
+import { findAssetBy } from "../asset.ts";
+import { derivationPathToString, getTHORNameCost, validateTHORName } from "../others.ts";
 
-describe('derivationPathToString', () => {
-  it('should return the correct string for a full path', () => {
+describe("derivationPathToString", () => {
+  test("should return the correct string for a full path", () => {
     const path = [1, 2, 3, 4, 5];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4/5");
+    expect(derivationPathToString(path)).toEqual("1'/2'/3'/4/5");
   });
 
-  it('should return the correct string for a short path', () => {
+  test("should return the correct string for a short path", () => {
     const path = [1, 2, 3, 4];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4");
+    expect(derivationPathToString(path)).toEqual("1'/2'/3'/4");
   });
 });
 
-describe('getTHORNameCost', () => {
-  describe('for correct values', () => {
-    [
+describe("getTHORNameCost", () => {
+  describe("for correct values", () => {
+    const costCases = [
       [1, 11],
       [2, 12],
       [3, 13],
       [10, 20],
-    ].forEach(([years, expected]) => {
-      it(`returns correct ${expected} cost for ${years} years`, () => {
+    ];
+
+    for (const [years, expected] of costCases) {
+      test(`returns correct ${expected} cost for ${years} years`, () => {
         const result = getTHORNameCost(years);
         expect(result).toBe(expected);
       });
-    });
+    }
   });
 
-  it('throws an error for negative years', () => {
-    expect(() => getTHORNameCost(-1)).toThrowError('Invalid number of year');
+  test("throws an error for negative years", () => {
+    expect(() => getTHORNameCost(-1)).toThrowError("Invalid number of year");
   });
 });
 
-describe('validateTHORName', () => {
+describe("validateTHORName", () => {
   const casesWithExpectation: [string, boolean][] = [
-    ['validname', true],
-    ['valid-name', true],
-    ['valid_name', true],
-    ['valid+name', true],
-    ['name_with_numbers123', true],
-    ['UPPER_CASE', true],
-    ['toolongname123456789012345678901', false],
-    ['invalid@name', false],
-    ['invalid!name', false],
-    ['invalid#name', false],
+    ["validname", true],
+    ["valid-name", true],
+    ["valid_name", true],
+    ["valid+name", true],
+    ["name_with_numbers123", true],
+    ["UPPER_CASE", true],
+    ["toolongname123456789012345678901", false],
+    ["invalid@name", false],
+    ["invalid!name", false],
+    ["invalid#name", false],
   ];
 
-  casesWithExpectation.forEach(([name, expected]) => {
-    it(`returns ${expected} for THORName "${name}"`, () => {
+  for (const [name, expected] of casesWithExpectation) {
+    test(`returns ${expected} for THORName "${name}"`, () => {
       const result = validateTHORName(name);
       expect(result).toBe(expected);
     });
+  }
+});
+
+describe("getAssetBy", () => {
+  test("find asset by identifier", async () => {
+    const assetByIdentifier = await findAssetBy({ identifier: "ETH.ETH" });
+    expect(assetByIdentifier).toBe("ETH.ETH");
+  });
+
+  test("find asset by chain and contract", async () => {
+    const assetByChainAndContract = await findAssetBy({
+      chain: Chain.Ethereum,
+      contract: "0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48",
+    });
+    expect(assetByChainAndContract).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).toBe(undefined);
+    expect(assetByChainAndContract).toBe(undefined);
   });
 });

package/src/helpers/asset.ts

@@ -1,61 +1,64 @@
-import type { EVMChain } from '@swapkit/types';
-import { BaseDecimal, Chain, ChainToRPC, FeeOption } from '@swapkit/types';
+import { RequestClient } from "@swapkit/api";
+import type { EVMChain } from "@swapkit/types";
+import { BaseDecimal, Chain, ChainToRPC, EVMChains, FeeOption } from "@swapkit/types";
+import type { TokenNames } from "../types.ts";
 
-import type { AssetValue } from '../index.ts';
+const getDecimalMethodHex = "0x313ce567";
 
-import { postRequest } from './others.ts';
-
-const getDecimalMethodHex = '0x313ce567';
-
-export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
+export type CommonAssetString =
+  | `${Chain.Maya}.MAYA`
+  | `${Chain.Ethereum}.THOR`
+  | `${Chain.Ethereum}.vTHOR`
+  | `${Chain.Kujira}.USK`
+  | Chain;
 
 const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
   try {
-    const response = await postRequest<string>(
-      ChainToRPC[chain],
-      JSON.stringify({
-        method: 'eth_call',
-        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, 'latest'],
+    const { result } = await RequestClient.post<{ result: string }>(ChainToRPC[chain], {
+      headers: {
+        accept: "*/*",
+        "content-type": "application/json",
+        "cache-control": "no-cache",
+      },
+      body: JSON.stringify({
         id: 44,
-        jsonrpc: '2.0',
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, "latest"],
       }),
-      { accept: '*/*', 'cache-control': 'no-cache', 'content-type': 'application/json' },
-      true,
-    );
+    });
 
-    const { result } = JSON.parse(response) as { result: string };
-
-    return parseInt(BigInt(result).toString());
+    return Number.parseInt(BigInt(result).toString());
   } catch (error) {
     console.error(error);
     return BaseDecimal[chain];
   }
 };
 
-const getETHAssetDecimal = async (symbol: string) => {
+const getETHAssetDecimal = (symbol: string) => {
   if (symbol === Chain.Ethereum) return BaseDecimal.ETH;
-  const [, address] = symbol.split('-');
+  const [, address] = symbol.split("-");
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Ethereum, to: address })
     : BaseDecimal.ETH;
 };
 
-const getAVAXAssetDecimal = async (symbol: string) => {
-  const [, address] = symbol.split('-');
+const getAVAXAssetDecimal = (symbol: string) => {
+  const [, address] = symbol.split("-");
 
-  return address?.startsWith('0x')
+  return address?.startsWith("0x")
     ? getContractDecimals({ chain: Chain.Avalanche, to: address.toLowerCase() })
     : BaseDecimal.AVAX;
 };
 
-const getBSCAssetDecimal = async (symbol: string) => {
+const getBSCAssetDecimal = (symbol: string) => {
   if (symbol === Chain.BinanceSmartChain) return BaseDecimal.BSC;
 
   return BaseDecimal.BSC;
 };
 
-export const getDecimal = async ({ chain, symbol }: { chain: Chain; symbol: string }) => {
+export const getDecimal = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
     case Chain.Ethereum:
       return getETHAssetDecimal(symbol);
@@ -76,33 +79,24 @@ export const gasFeeMultiplier: Record<FeeOption, number> = {
 
 export const isGasAsset = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Ethereum:
-    case Chain.Avalanche:
-      return symbol === chain;
-
     case Chain.Arbitrum:
     case Chain.Optimism:
-      return 'ETH' === symbol;
-
+      return symbol === "ETH";
     case Chain.Maya:
-      return symbol === 'CACAO';
-
+      return symbol === "CACAO";
     case Chain.Kujira:
-      return symbol === 'KUJI';
-
+      return symbol === "KUJI";
     case Chain.Cosmos:
-      return symbol === 'ATOM';
+      return symbol === "ATOM";
     case Chain.Polygon:
-      return symbol === 'MATIC';
+      return symbol === "MATIC";
     case Chain.BinanceSmartChain:
-      return symbol === 'BNB';
+      return symbol === "BNB";
     case Chain.THORChain:
-      return symbol === 'RUNE';
+      return symbol === "RUNE";
+
+    default:
+      return symbol === chain;
   }
 };
 
@@ -110,86 +104,118 @@ export const getCommonAssetInfo = (
   assetString: CommonAssetString,
 ): { identifier: string; decimal: number } => {
   switch (assetString) {
-    case 'ETH.THOR':
-      return { identifier: 'ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044', decimal: 18 };
-    case 'ETH.vTHOR':
-      return { identifier: 'ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d', decimal: 18 };
+    case `${Chain.Ethereum}.THOR`:
+      return { identifier: "ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044", decimal: 18 };
+    case `${Chain.Ethereum}.vTHOR`:
+      return { identifier: "ETH.vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d", decimal: 18 };
 
     case Chain.Cosmos:
-      return { identifier: 'GAIA.ATOM', decimal: BaseDecimal[assetString] };
+      return { identifier: "GAIA.ATOM", decimal: BaseDecimal[assetString] };
     case Chain.THORChain:
-      return { identifier: 'THOR.RUNE', decimal: BaseDecimal[assetString] };
+      return { identifier: "THOR.RUNE", decimal: BaseDecimal[assetString] };
     case Chain.BinanceSmartChain:
-      return { identifier: 'BSC.BNB', decimal: BaseDecimal[assetString] };
+      return { identifier: "BSC.BNB", decimal: BaseDecimal[assetString] };
     case Chain.Maya:
-      return { identifier: 'MAYA.CACAO', decimal: BaseDecimal.MAYA };
-    case 'MAYA.MAYA':
-      return { identifier: 'MAYA.MAYA', decimal: 4 };
+      return { identifier: "MAYA.CACAO", decimal: BaseDecimal.MAYA };
+    case `${Chain.Maya}.MAYA`:
+      return { identifier: "MAYA.MAYA", decimal: 4 };
 
-    case Chain.Kujira:
-    case Chain.Arbitrum:
-    case Chain.Optimism:
-    case Chain.BitcoinCash:
-    case Chain.Litecoin:
-    case Chain.Dogecoin:
-    case Chain.Binance:
-    case Chain.Avalanche:
-    case Chain.Polygon:
-    case Chain.Bitcoin:
-    case Chain.Ethereum:
+    case `${Chain.Kujira}.USK`:
+      return { identifier: `${Chain.Kujira}.USK`, decimal: 6 };
+
+    default:
       return { identifier: `${assetString}.${assetString}`, decimal: BaseDecimal[assetString] };
   }
 };
 
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO: Refactor
 export const getAssetType = ({ chain, symbol }: { chain: Chain; symbol: string }) => {
-  if (symbol.includes('/')) return 'Synth';
+  if (symbol.includes("/")) return "Synth";
 
   switch (chain) {
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Litecoin:
-    case Chain.Maya:
-    case Chain.THORChain:
-      return 'Native';
-
     case Chain.Cosmos:
-      return symbol === 'ATOM' ? 'Native' : Chain.Cosmos;
+      return symbol === "ATOM" ? "Native" : Chain.Cosmos;
     case Chain.Kujira:
-      return symbol === Chain.Kujira ? 'Native' : Chain.Kujira;
+      return symbol === Chain.Kujira ? "Native" : Chain.Kujira;
     case Chain.Binance:
-      return symbol === Chain.Binance ? 'Native' : 'BEP2';
+      return symbol === Chain.Binance ? "Native" : "BEP2";
     case Chain.BinanceSmartChain:
-      return symbol === Chain.Binance ? 'Native' : 'BEP20';
+      return symbol === Chain.Binance ? "Native" : "BEP20";
     case Chain.Ethereum:
-      return symbol === Chain.Ethereum ? 'Native' : 'ERC20';
+      return symbol === Chain.Ethereum ? "Native" : "ERC20";
     case Chain.Avalanche:
-      return symbol === Chain.Avalanche ? 'Native' : Chain.Avalanche;
+      return symbol === Chain.Avalanche ? "Native" : Chain.Avalanche;
     case Chain.Polygon:
-      return symbol === Chain.Polygon ? 'Native' : 'POLYGON';
+      return symbol === Chain.Polygon ? "Native" : "POLYGON";
 
     case Chain.Arbitrum:
-      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? 'Native' : 'ARBITRUM';
+      return [Chain.Ethereum, Chain.Arbitrum].includes(symbol as Chain) ? "Native" : "ARBITRUM";
     case Chain.Optimism:
-      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? 'Native' : 'OPTIMISM';
+      return [Chain.Ethereum, Chain.Optimism].includes(symbol as Chain) ? "Native" : "OPTIMISM";
+
+    default:
+      return "Native";
   }
 };
 
 export const assetFromString = (assetString: string) => {
-  const [chain, ...symbolArray] = assetString.split('.') as [Chain, ...(string | undefined)[]];
-  const synth = assetString.includes('/');
-  const symbol = symbolArray.join('.');
-  const ticker = symbol?.split('-')?.[0];
+  const [chain, ...symbolArray] = assetString.split(".") as [Chain, ...(string | undefined)[]];
+  const synth = assetString.includes("/");
+  const symbol = symbolArray.join(".");
+  const ticker = symbol?.split("-")?.[0];
 
   return { chain, symbol, ticker, synth };
 };
 
 const potentialScamRegex = new RegExp(
   /(.)\1{6}|\.ORG|\.NET|\.FINANCE|\.COM|WWW|HTTP|\\\\|\/\/|[\s$%:[\]]/,
-  'gmi',
+  "gmi",
 );
-export const filterAssets = (assets: AssetValue[]) =>
-  assets.filter(
-    (asset) =>
-      !potentialScamRegex.test(asset.toString()) && !asset.toString().includes('undefined'),
-  );
+
+const evmAssetHasAddress = (assetString: string) => {
+  const [chain, symbol] = assetString.split(".") as [EVMChain, string];
+  if (!EVMChains.includes(chain as EVMChain)) return true;
+  const [, address] = symbol.split("-") as [string, string?];
+
+  return isGasAsset({ chain: chain as Chain, symbol }) || !!address;
+};
+
+export const filterAssets = (
+  tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+  }[],
+) =>
+  tokens.filter(({ chain, value, symbol }) => {
+    const assetString = `${chain}.${symbol}`;
+
+    return (
+      !potentialScamRegex.test(assetString) && evmAssetHasAddress(assetString) && value !== "0"
+    );
+  });
+
+export async function findAssetBy(
+  params: { chain: EVMChain; contract: string } | { identifier: `${Chain}.${string}` },
+) {
+  const tokenPackages = await import("@swapkit/tokens");
+
+  for (const tokenList of Object.values(tokenPackages)) {
+    for (const { identifier, chain: tokenChain, ...rest } of tokenList.tokens) {
+      if ("identifier" in params && identifier === params.identifier) {
+        return identifier as TokenNames;
+      }
+
+      if (
+        "address" in rest &&
+        "chain" in params &&
+        tokenChain === params.chain &&
+        rest.address.toLowerCase() === params.contract.toLowerCase()
+      )
+        return identifier as TokenNames;
+    }
+  }
+
+  return;
+}

package/src/helpers/liquidity.ts

@@ -1,13 +1,13 @@
-import { BaseDecimal } from '@swapkit/types';
+import { BaseDecimal } from "@swapkit/types";
 
-import { SwapKitNumber } from '../index.ts';
+import { SwapKitNumber } from "../index.ts";
 
-type ShareParams<T = {}> = T & {
+type ShareParams<T extends {}> = T & {
   liquidityUnits: string;
   poolUnits: string;
 };
 
-type PoolParams<T = {}> = T & {
+type PoolParams = {
   runeAmount: string;
   assetAmount: string;
   runeDepth: string;
@@ -25,11 +25,11 @@ type PoolParams<T = {}> = T & {
  *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
  *  (part1 * (part2 - part3 + part4)) / part5
  */
-export const getAsymmetricRuneShare = ({
+export function getAsymmetricRuneShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
-}: ShareParams<{ runeDepth: string }>) => {
+}: ShareParams<{ runeDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(runeDepth);
@@ -43,13 +43,13 @@ export const getAsymmetricRuneShare = ({
   const numerator = part1.mul(part2.sub(part3).add(part4));
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricAssetShare = ({
+export function getAsymmetricAssetShare({
   liquidityUnits,
   poolUnits,
   assetDepth,
-}: ShareParams<{ assetDepth: string }>) => {
+}: ShareParams<{ assetDepth: string }>) {
   const s = toTCSwapKitNumber(liquidityUnits);
   const T = toTCSwapKitNumber(poolUnits);
   const A = toTCSwapKitNumber(assetDepth);
@@ -62,28 +62,31 @@ export const getAsymmetricAssetShare = ({
   const part5 = T.mul(T).mul(T);
 
   return numerator.div(part5);
-};
+}
 
-export const getAsymmetricRuneWithdrawAmount = ({
+export function getAsymmetricRuneWithdrawAmount({
   percent,
   runeDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; runeDepth: string }>) =>
-  getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; runeDepth: string }>) {
+  return getAsymmetricRuneShare({ runeDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-export const getAsymmetricAssetWithdrawAmount = ({
+export function getAsymmetricAssetWithdrawAmount({
   percent,
   assetDepth,
   liquidityUnits,
   poolUnits,
-}: ShareParams<{ percent: number; assetDepth: string }>) =>
-  getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}: ShareParams<{ percent: number; assetDepth: string }>) {
+  return getAsymmetricAssetShare({ assetDepth, liquidityUnits, poolUnits }).mul(percent);
+}
 
-const toTCSwapKitNumber = (value: string) =>
-  new SwapKitNumber({ value, decimal: BaseDecimal.THOR });
+function toTCSwapKitNumber(value: string) {
+  return SwapKitNumber.fromBigInt(BigInt(value), BaseDecimal.THOR);
+}
 
-export const getSymmetricPoolShare = ({
+export function getSymmetricPoolShare({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -91,12 +94,14 @@ export const getSymmetricPoolShare = ({
 }: ShareParams<{
   runeDepth: string;
   assetDepth: string;
-}>) => ({
-  assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
-  runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
-});
-
-export const getSymmetricWithdraw = ({
+}>) {
+  return {
+    assetAmount: toTCSwapKitNumber(assetDepth).mul(liquidityUnits).div(poolUnits),
+    runeAmount: toTCSwapKitNumber(runeDepth).mul(liquidityUnits).div(poolUnits),
+  };
+}
+
+export function getSymmetricWithdraw({
   liquidityUnits,
   poolUnits,
   runeDepth,
@@ -106,14 +111,15 @@ export const getSymmetricWithdraw = ({
   runeDepth: string;
   assetDepth: string;
   percent: number;
-}>) =>
-  Object.fromEntries(
+}>) {
+  return Object.fromEntries(
     Object.entries(getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth })).map(
       ([name, value]) => [name, value.mul(percent)],
     ),
   );
+}
 
-export const getEstimatedPoolShare = ({
+export function getEstimatedPoolShare({
   runeDepth,
   poolUnits,
   assetDepth,
@@ -125,12 +131,12 @@ export const getEstimatedPoolShare = ({
   assetAmount: string;
   runeDepth: string;
   assetDepth: string;
-}>) => {
-  const R = toTCSwapKitNumber(runeDepth);
-  const A = toTCSwapKitNumber(assetDepth);
-  const P = toTCSwapKitNumber(poolUnits);
-  const runeAddAmount = toTCSwapKitNumber(runeAmount);
-  const assetAddAmount = toTCSwapKitNumber(assetAmount);
+}>) {
+  const R = new SwapKitNumber({ value: runeDepth, decimal: 8 });
+  const A = new SwapKitNumber({ value: assetDepth, decimal: 8 });
+  const P = new SwapKitNumber({ value: poolUnits, decimal: 8 });
+  const runeAddAmount = new SwapKitNumber({ value: runeAmount, decimal: 8 });
+  const assetAddAmount = new SwapKitNumber({ value: assetAmount, decimal: 8 });
 
   // liquidityUnits = P * (r*A + a*R + 2*r*a) / (r*A + a*R + 2*R*A)
   const rA = runeAddAmount.mul(A);
@@ -142,22 +148,24 @@ export const getEstimatedPoolShare = ({
   const liquidityUnitsAfterAdd = numerator.div(denominator);
   const estimatedLiquidityUnits = toTCSwapKitNumber(liquidityUnits).add(liquidityUnitsAfterAdd);
 
-  if (liquidityUnitsAfterAdd.baseValueNumber === 0) {
-    return estimatedLiquidityUnits.div(P).baseValueNumber;
+  if (liquidityUnitsAfterAdd.getBaseValue("number") === 0) {
+    return estimatedLiquidityUnits.div(P).getBaseValue("number");
   }
 
   // get pool units after add
   const newPoolUnits = P.add(estimatedLiquidityUnits);
 
-  return estimatedLiquidityUnits.div(newPoolUnits).baseValueNumber;
-};
+  return estimatedLiquidityUnits.div(newPoolUnits).getBaseValue("number");
+}
 
-export const getLiquiditySlippage = ({
+export function getLiquiditySlippage({
   runeAmount,
   assetAmount,
   runeDepth,
   assetDepth,
-}: PoolParams) => {
+}: PoolParams) {
+  if (runeAmount === "0" || assetAmount === "0" || runeDepth === "0" || assetDepth === "0")
+    return 0;
   // formula: (t * R - T * r)/ (T*r + R*T)
   const R = toTCSwapKitNumber(runeDepth);
   const T = toTCSwapKitNumber(assetDepth);
@@ -168,5 +176,5 @@ export const getLiquiditySlippage = ({
   const denominator = T.mul(runeAddAmount).add(R.mul(T));
 
   // set absolute value of percent, no negative allowed
-  return Math.abs(numerator.div(denominator).baseValueNumber);
-};
+  return Math.abs(numerator.div(denominator).getBaseValue("number"));
+}