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

package/dist/index.d.ts

@@ -1,5 +1,9 @@
+import { BaseDecimal } from '@swapkit/types';
 import { Chain } from '@swapkit/types';
+import type { ChainflipList } from '@swapkit/tokens';
+import { ChainId } from '@swapkit/types';
 import type { CoinGeckoList } from '@swapkit/tokens';
+import type { EVMChain } from '@swapkit/types';
 import { FeeOption } from '@swapkit/types';
 import type { MayaList } from '@swapkit/tokens';
 import { MemoType } from '@swapkit/types';
@@ -13,6 +17,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 +29,40 @@ 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 fromStringWithBase(assetString: string, value?: NumberPrimitives, baseDecimal?: number): Promise<AssetValue>;
+    static fromStringWithBaseSync(assetString: string, value?: NumberPrimitives, baseDecimal?: number): AssetValue;
+    static fromIdentifierSync(assetString: TokenNames, value?: NumberPrimitives): AssetValue;
+    static fromChainOrSignature(assetString: CommonAssetString, value?: NumberPrimitives): AssetValue;
     static loadStaticAssets(): Promise<{
         ok: true;
     } | {
@@ -51,16 +72,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 +79,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 +94,32 @@ export declare class BigIntArithmetics {
     lt(value: InitialisationValueType): boolean;
     lte(value: InitialisationValueType): boolean;
     eqValue(value: InitialisationValueType): boolean;
-    getValue<T extends 'number' | 'string'>(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 type CommonAssetString = `${Chain.Maya}.MAYA` | `${Chain.Ethereum}.THOR` | `${Chain.Ethereum}.vTHOR` | `${Chain.Kujira}.USK` | Chain;
+
+export declare function derivationPathToString([network, chainId, account, change, index]: [
+number,
+number,
+number,
+number,
+number | undefined
+]): string;
 
-export declare const derivationPathToString: ([network, chainId, account, change, index]: number[]) => string;
+export declare type ErrorKeys = keyof typeof errorMessages;
 
 declare const errorMessages: {
     /**
@@ -115,6 +130,7 @@ declare const errorMessages: {
     readonly core_extend_error: 10003;
     readonly core_inbound_data_not_found: 10004;
     readonly core_approve_asset_address_or_from_not_found: 10005;
+    readonly core_plugin_not_found: 10006;
     readonly core_chain_halted: 10099;
     /**
      * Core - Wallet Connection
@@ -127,6 +143,7 @@ declare const errorMessages: {
     readonly core_wallet_trezor_not_installed: 10106;
     readonly core_wallet_keplr_not_installed: 10107;
     readonly core_wallet_okx_not_installed: 10108;
+    readonly core_wallet_keepkey_not_installed: 10109;
     /**
      * Core - Swap
      */
@@ -153,18 +170,49 @@ 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_deposit_server_error: 10313;
+    readonly core_transaction_invalid_sender_address: 10313;
+    readonly core_transaction_deposit_server_error: 10314;
+    readonly core_transaction_user_rejected: 10315;
     /**
      * Wallets
      */
     readonly wallet_ledger_connection_error: 20001;
+    readonly wallet_ledger_connection_claimed: 20002;
+    readonly wallet_ledger_get_address_error: 20003;
+    readonly wallet_ledger_device_not_found: 20004;
+    readonly wallet_ledger_device_locked: 20005;
+    /**
+     * Chainflip
+     */
+    readonly chainflip_channel_error: 30001;
+    readonly chainflip_broker_recipient_error: 30002;
+    /**
+     * THORChain
+     */
     /**
      * Helpers
      */
     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 findAssetBy(params: {
+    chain: EVMChain;
+    contract: string;
+} | {
+    identifier: `${Chain}.${string}`;
+}): Promise<TokenNames | undefined>;
 
 export declare function formatBigIntToSafeValue({ value, bigIntDecimal, decimal, }: {
     value: bigint;
@@ -179,14 +227,14 @@ export declare const getAssetType: ({ chain, symbol }: {
     symbol: string;
 }) => 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 +247,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;
@@ -216,42 +264,40 @@ export declare const getCommonAssetInfo: (assetString: CommonAssetString) => {
 export declare const getDecimal: ({ chain, symbol }: {
     chain: Chain;
     symbol: string;
-}) => Promise<number>;
+}) => BaseDecimal | 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 function getMAYANameCost(year: number): number;
 
-export declare const getMinAmountByChain: (chain: Chain) => AssetValue;
+export declare const getMemoFor: <T extends MemoType>(memoType: T, options: MemoOptions<T>) => string;
 
-export declare const getRequest: <T>(url: string, params?: {
-    [x: string]: any;
-} | undefined) => Promise<T>;
+export declare function getMinAmountByChain(chain: Chain): AssetValue;
 
-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;
 
@@ -260,22 +306,27 @@ export declare const isGasAsset: ({ chain, symbol }: {
     symbol: string;
 }) => boolean;
 
-export declare type Keys = keyof typeof errorMessages;
-
 export declare type MemoOptions<T extends MemoType> = {
-    [MemoType.BOND]: WithAddress;
-    [MemoType.LEAVE]: WithAddress;
-    [MemoType.CLOSE_LOAN]: WithAddress<{
+    [MemoType.BOND]: {
+        address: string;
+    };
+    [MemoType.LEAVE]: {
+        address: string;
+    };
+    [MemoType.CLOSE_LOAN]: {
+        address: string;
         asset: string;
         minAmount?: string;
-    }>;
-    [MemoType.OPEN_LOAN]: WithAddress<{
+    };
+    [MemoType.OPEN_LOAN]: {
+        address: string;
         asset: string;
         minAmount?: string;
-    }>;
-    [MemoType.UNBOND]: WithAddress<{
+    };
+    [MemoType.UNBOND]: {
+        address: string;
         unbondAmount: number;
-    }>;
+    };
     [MemoType.DEPOSIT]: WithChain<{
         symbol: string;
         address?: string;
@@ -288,10 +339,10 @@ export declare type MemoOptions<T extends MemoType> = {
         targetAssetString?: string;
         singleSide?: boolean;
     }>;
-    [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+    [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;
@@ -299,16 +350,14 @@ declare type NumberPrimitivesType = {
     string: string;
 };
 
-declare type PoolParams<T = {}> = T & {
+declare type PoolParams = {
     runeAmount: string;
     assetAmount: string;
     runeDepth: string;
     assetDepth: string;
 };
 
-export declare const postRequest: <T>(url: string, body: string, headers?: Record<string, string>, parseAsString?: boolean) => Promise<T>;
-
-declare type ShareParams<T = {}> = T & {
+declare type ShareParams<T extends {}> = T & {
     liquidityUnits: string;
     poolUnits: string;
 };
@@ -319,17 +368,16 @@ declare type SKBigIntParams = InitialisationValueType | {
 };
 
 export declare class SwapKitError extends Error {
-    constructor(errorKey: Keys, sourceError?: any);
+    constructor(errorKey: ErrorKeys, sourceError?: any);
 }
 
 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,16 +387,22 @@ 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'];
-
-export declare const validateTHORName: (name: string) => boolean;
+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"] | (typeof ChainflipList)["tokens"][number]["identifier"];
 
-declare type WithAddress<T = {}> = T & {
-    address: string;
+declare type TokenTax = {
+    buy: number;
+    sell: number;
 };
 
-declare type WithChain<T = {}> = T & {
+export declare function validateMAYAName(name: string): boolean;
+
+export declare function validateTHORName(name: string): boolean;
+
+declare type WithChain<T extends {}> = T & {
     chain: Chain;
 };
 
+
+export * from "@swapkit/api";
+
 export { }