@swapkit/helpers 1.0.0-rc.6 → 1.0.0-rc.60

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 import { Chain } from '@swapkit/types';
+import { ChainId } from '@swapkit/types';
 import type { CoinGeckoList } from '@swapkit/tokens';
 import { FeeOption } from '@swapkit/types';
 import type { MayaList } from '@swapkit/tokens';
 import { MemoType } from '@swapkit/types';
+import type { Options } from 'ky';
 import type { PancakeswapETHList } from '@swapkit/tokens';
 import type { PancakeswapList } from '@swapkit/tokens';
 import type { PangolinList } from '@swapkit/tokens';
@@ -13,6 +15,8 @@ import type { TraderjoeList } from '@swapkit/tokens';
 import type { UniswapList } from '@swapkit/tokens';
 import type { WoofiList } from '@swapkit/tokens';
 
+declare type AllowedNumberTypes = 'bigint' | 'number' | 'string';
+
 export declare const assetFromString: (assetString: string) => {
     chain: Chain;
     symbol: string;
@@ -23,25 +27,38 @@ export declare const assetFromString: (assetString: string) => {
 export declare class AssetValue extends BigIntArithmetics {
     address?: string;
     chain: Chain;
-    isSynthetic: boolean;
     isGasAsset: boolean;
+    isSynthetic: boolean;
     symbol: string;
+    tax?: TokenTax;
     ticker: string;
     type: ReturnType<typeof getAssetType>;
-    constructor(params: AssetValueParams);
-    get assetValue(): string;
-    toString(short?: boolean): string;
+    constructor({ value, decimal, tax, chain, symbol, identifier, }: {
+        decimal: number;
+        value: SwapKitValueType;
+        tax?: TokenTax;
+    } & ({
+        chain: Chain;
+        symbol: string;
+        identifier?: never;
+    } | {
+        identifier: string;
+        chain?: never;
+        symbol?: never;
+    }));
+    toString(): string;
+    toUrl(): string;
     eq({ chain, symbol }: {
         chain: Chain;
         symbol: string;
     }): boolean;
-    static fromString(assetString: string, value?: number | string): Promise<AssetValue>;
-    static fromStringSync(assetString: string, value?: number | string): AssetValue | undefined;
-    static fromIdentifier(assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`, value?: number | string): Promise<AssetValue>;
-    static fromIdentifierSync(identifier: TokenNames, value?: number | string): AssetValue;
-    static fromChainOrSignature(assetString: CommonAssetString, value?: number | string): AssetValue;
-    static fromTCQuote(identifier: TCTokenNames, value?: number | string): Promise<AssetValue>;
-    static fromTCQuoteStatic(identifier: TCTokenNames, value?: number | string): AssetValue;
+    chainId(): ChainId;
+    static fromUrl(urlAsset: string, value?: NumberPrimitives): Promise<AssetValue>;
+    static fromString(assetString: string, value?: NumberPrimitives): Promise<AssetValue>;
+    static fromIdentifier(assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}` | TokenNames, value?: NumberPrimitives): Promise<AssetValue>;
+    static fromStringSync(assetString: string, value?: NumberPrimitives): AssetValue;
+    static fromIdentifierSync(assetString: TokenNames, value?: NumberPrimitives): AssetValue;
+    static fromChainOrSignature(assetString: CommonAssetString, value?: NumberPrimitives): AssetValue;
     static loadStaticAssets(): Promise<{
         ok: true;
     } | {
@@ -51,16 +68,6 @@ export declare class AssetValue extends BigIntArithmetics {
     }>;
 }
 
-declare type AssetValueParams = {
-    decimal: number;
-    value: SwapKitValueType;
-} & ({
-    chain: Chain;
-    symbol: string;
-} | {
-    identifier: string;
-});
-
 export declare class BigIntArithmetics {
 
     decimalMultiplier: bigint;
@@ -68,24 +75,12 @@ export declare class BigIntArithmetics {
     decimal?: number;
     static fromBigInt(value: bigint, decimal?: number): BigIntArithmetics;
     static shiftDecimals({ value, from, to, }: {
-        value: InitialisationValueType;
+        value: InstanceType<typeof SwapKitNumber>;
         from: number;
         to: number;
     }): BigIntArithmetics;
     constructor(params: SKBigIntParams);
-    /**
-     * @deprecated Use `getBaseValue('string')` instead
-     */
-    get baseValue(): string;
-    /**
-     * @deprecated Use `getBaseValue('number')` instead
-     */
-    get baseValueNumber(): number;
-    /**
-     * @deprecated Use `getBaseValue('bigint')` instead
-     */
-    get baseValueBigInt(): bigint;
-    set(value: SKBigIntParams): any;
+    set(value: SKBigIntParams): this;
     add(...args: InitialisationValueType[]): this;
     sub(...args: InitialisationValueType[]): this;
     mul(...args: InitialisationValueType[]): this;
@@ -95,16 +90,24 @@ export declare class BigIntArithmetics {
     lt(value: InitialisationValueType): boolean;
     lte(value: InitialisationValueType): boolean;
     eqValue(value: InitialisationValueType): boolean;
-    getValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T];
-    getBaseValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T];
+    getValue<T extends AllowedNumberTypes>(type: T): NumberPrimitivesType[T];
+    getBaseValue<T extends AllowedNumberTypes>(type: T): NumberPrimitivesType[T];
     getBigIntValue(value: InitialisationValueType, decimal?: number): bigint;
-    formatBigIntToSafeValue(value: bigint, decimal?: number): string;
     toSignificant(significantDigits?: number): string;
+    toFixed(fixedDigits?: number): string;
+    toAbbreviation(digits?: number): string;
+    toCurrency(currency?: string, { currencyPosition, decimal, decimalSeparator, thousandSeparator, }?: {
+        currencyPosition?: string | undefined;
+        decimal?: number | undefined;
+        decimalSeparator?: string | undefined;
+        thousandSeparator?: string | undefined;
+    }): string;
+    formatBigIntToSafeValue(value: bigint, decimal?: number): string;
 }
 
 export declare type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
 
-export declare const derivationPathToString: ([network, chainId, account, change, index]: number[]) => string;
+export declare function derivationPathToString([network, chainId, account, change, index]: number[]): string;
 
 declare const errorMessages: {
     /**
@@ -153,6 +156,7 @@ declare const errorMessages: {
     readonly core_transaction_deposit_to_pool_error: 10310;
     readonly core_transaction_deposit_insufficient_funds_error: 10311;
     readonly core_transaction_deposit_gas_error: 10312;
+    readonly core_transaction_invalid_sender_address: 10313;
     readonly core_transaction_deposit_server_error: 10313;
     /**
      * Wallets
@@ -164,7 +168,17 @@ declare const errorMessages: {
     readonly helpers_number_different_decimals: 99101;
 };
 
-export declare const filterAssets: (assets: AssetValue[]) => AssetValue[];
+export declare const filterAssets: (tokens: {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+}[]) => {
+    value: string;
+    decimal: number;
+    chain: Chain;
+    symbol: string;
+}[];
 
 export declare function formatBigIntToSafeValue({ value, bigIntDecimal, decimal, }: {
     value: bigint;
@@ -177,16 +191,16 @@ export declare const gasFeeMultiplier: Record<FeeOption, number>;
 export declare const getAssetType: ({ chain, symbol }: {
     chain: Chain;
     symbol: string;
-}) => "KUJI" | "Synth" | "Native" | "GAIA" | "BEP2" | "BEP20" | "ERC20" | "AVAX" | "POLYGON" | "ARBITRUM" | "OPTIMISM";
+}) => Chain.Avalanche | Chain.Cosmos | Chain.Kujira | "Synth" | "Native" | "BEP2" | "BEP20" | "ERC20" | "POLYGON" | "ARBITRUM" | "OPTIMISM";
 
-export declare const getAsymmetricAssetShare: ({ liquidityUnits, poolUnits, assetDepth, }: ShareParams<{
+export declare function getAsymmetricAssetShare({ liquidityUnits, poolUnits, assetDepth, }: ShareParams<{
     assetDepth: string;
-}>) => SwapKitNumber;
+}>): SwapKitNumber;
 
-export declare const getAsymmetricAssetWithdrawAmount: ({ percent, assetDepth, liquidityUnits, poolUnits, }: ShareParams<{
+export declare function getAsymmetricAssetWithdrawAmount({ percent, assetDepth, liquidityUnits, poolUnits, }: ShareParams<{
     percent: number;
     assetDepth: string;
-}>) => SwapKitNumber;
+}>): SwapKitNumber;
 
 /**
  *  Ref: https://gitlab.com/thorchain/thornode/-/issues/657
@@ -199,14 +213,14 @@ export declare const getAsymmetricAssetWithdrawAmount: ({ percent, assetDepth, l
  *  share = (s * A * (2 * T^2 - 2 * T * s + s^2))/T^3
  *  (part1 * (part2 - part3 + part4)) / part5
  */
-export declare const getAsymmetricRuneShare: ({ liquidityUnits, poolUnits, runeDepth, }: ShareParams<{
+export declare function getAsymmetricRuneShare({ liquidityUnits, poolUnits, runeDepth, }: ShareParams<{
     runeDepth: string;
-}>) => SwapKitNumber;
+}>): SwapKitNumber;
 
-export declare const getAsymmetricRuneWithdrawAmount: ({ percent, runeDepth, liquidityUnits, poolUnits, }: ShareParams<{
+export declare function getAsymmetricRuneWithdrawAmount({ percent, runeDepth, liquidityUnits, poolUnits, }: ShareParams<{
     percent: number;
     runeDepth: string;
-}>) => SwapKitNumber;
+}>): SwapKitNumber;
 
 export declare const getCommonAssetInfo: (assetString: CommonAssetString) => {
     identifier: string;
@@ -218,40 +232,36 @@ export declare const getDecimal: ({ chain, symbol }: {
     symbol: string;
 }) => Promise<number>;
 
-export declare const getEstimatedPoolShare: ({ runeDepth, poolUnits, assetDepth, liquidityUnits, runeAmount, assetAmount, }: ShareParams<{
+export declare function getEstimatedPoolShare({ runeDepth, poolUnits, assetDepth, liquidityUnits, runeAmount, assetAmount, }: ShareParams<{
     runeAmount: string;
     assetAmount: string;
     runeDepth: string;
     assetDepth: string;
-}>) => number;
+}>): number;
 
-export declare const getLiquiditySlippage: ({ runeAmount, assetAmount, runeDepth, assetDepth, }: PoolParams) => number;
+export declare function getLiquiditySlippage({ runeAmount, assetAmount, runeDepth, assetDepth, }: PoolParams): number;
 
 export declare const getMemoFor: <T extends MemoType>(memoType: T, options: MemoOptions<T>) => string;
 
-export declare const getMinAmountByChain: (chain: Chain) => AssetValue;
+export declare function getMinAmountByChain(chain: Chain): AssetValue;
 
-export declare const getRequest: <T>(url: string, params?: {
-    [x: string]: any;
-} | undefined) => Promise<T>;
-
-export declare const getSymmetricPoolShare: ({ liquidityUnits, poolUnits, runeDepth, assetDepth, }: ShareParams<{
+export declare function getSymmetricPoolShare({ liquidityUnits, poolUnits, runeDepth, assetDepth, }: ShareParams<{
     runeDepth: string;
     assetDepth: string;
-}>) => {
+}>): {
     assetAmount: SwapKitNumber;
     runeAmount: SwapKitNumber;
 };
 
-export declare const getSymmetricWithdraw: ({ liquidityUnits, poolUnits, runeDepth, assetDepth, percent, }: ShareParams<{
+export declare function getSymmetricWithdraw({ liquidityUnits, poolUnits, runeDepth, assetDepth, percent, }: ShareParams<{
     runeDepth: string;
     assetDepth: string;
     percent: number;
-}>) => {
+}>): {
     [k: string]: SwapKitNumber;
 };
 
-export declare const getTHORNameCost: (year: number) => number;
+export declare function getTHORNameCost(year: number): number;
 
 declare type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
 
@@ -291,7 +301,7 @@ export declare type MemoOptions<T extends MemoType> = {
     [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
 }[T];
 
-declare type NumberPrimitives = bigint | number | string;
+export declare type NumberPrimitives = bigint | number | string;
 
 declare type NumberPrimitivesType = {
     bigint: bigint;
@@ -306,7 +316,10 @@ declare type PoolParams<T = {}> = T & {
     assetDepth: string;
 };
 
-export declare const postRequest: <T>(url: string, body: string, headers?: Record<string, string>, parseAsString?: boolean) => Promise<T>;
+export declare const RequestClient: {
+    get: <T>(url: string | URL | Request, options?: Options) => Promise<T>;
+    post: <T_1>(url: string | URL | Request, options?: Options) => Promise<T_1>;
+};
 
 declare type ShareParams<T = {}> = T & {
     liquidityUnits: string;
@@ -324,12 +337,11 @@ export declare class SwapKitError extends Error {
 
 export declare class SwapKitNumber extends BigIntArithmetics {
     eq(value: SwapKitValueType): boolean;
+    static fromBigInt(value: bigint, decimal?: number): SwapKitNumber;
 }
 
 export declare type SwapKitValueType = BigIntArithmetics | string | number;
 
-declare type TCTokenNames = (typeof ThorchainList)['tokens'][number]['identifier'];
-
 export declare type ThornameRegisterParam = {
     name: string;
     chain: string;
@@ -339,9 +351,14 @@ export declare type ThornameRegisterParam = {
     expiryBlock?: string;
 };
 
-declare type TokenNames = TCTokenNames | (typeof CoinGeckoList)['tokens'][number]['identifier'] | (typeof MayaList)['tokens'][number]['identifier'] | (typeof PancakeswapETHList)['tokens'][number]['identifier'] | (typeof PancakeswapList)['tokens'][number]['identifier'] | (typeof PangolinList)['tokens'][number]['identifier'] | (typeof StargateARBList)['tokens'][number]['identifier'] | (typeof SushiswapList)['tokens'][number]['identifier'] | (typeof TraderjoeList)['tokens'][number]['identifier'] | (typeof WoofiList)['tokens'][number]['identifier'] | (typeof UniswapList)['tokens'][number]['identifier'];
+declare type TokenNames = (typeof ThorchainList)['tokens'][number]['identifier'] | (typeof CoinGeckoList)['tokens'][number]['identifier'] | (typeof MayaList)['tokens'][number]['identifier'] | (typeof PancakeswapETHList)['tokens'][number]['identifier'] | (typeof PancakeswapList)['tokens'][number]['identifier'] | (typeof PangolinList)['tokens'][number]['identifier'] | (typeof StargateARBList)['tokens'][number]['identifier'] | (typeof SushiswapList)['tokens'][number]['identifier'] | (typeof TraderjoeList)['tokens'][number]['identifier'] | (typeof WoofiList)['tokens'][number]['identifier'] | (typeof UniswapList)['tokens'][number]['identifier'];
+
+declare type TokenTax = {
+    buy: number;
+    sell: number;
+};
 
-export declare const validateTHORName: (name: string) => boolean;
+export declare function validateTHORName(name: string): boolean;
 
 declare type WithAddress<T = {}> = T & {
     address: string;