@orb-labs/orby-core 0.0.14 → 0.0.16

package/dist/esm/actions/account_cluster.d.ts

@@ -0,0 +1,32 @@
+import { Account } from "../entities/account.js";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
+import { ChainSupportStatus, LIBRARY_TYPE, Order } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class AccountClusterActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    createAccountCluster(accounts: Account[]): Promise<AccountCluster>;
+    addToAccountCluster(accounts: Account[], accountClusterId: string): Promise<AccountCluster>;
+    removeFromAccountCluster(accounts: Account[], accountClusterId: string): Promise<AccountCluster>;
+    getVirtualNodeRpcUrlsForSupportedChains(accountClusterId: string): Promise<VirtualNodeRpcUrlForSupportedChain[]>;
+    enableChainAbstractionForAccountCluster(accountClusterId: string, enable: boolean): Promise<boolean>;
+    setCustomChainEndpointsForAccountCluster(accountClusterId: string, chainEndpoints: ChainEndpoint[]): Promise<boolean>;
+    removeCustomChainEndpointsForAccountCluster(accountClusterId: string, chainIds: bigint[]): Promise<boolean>;
+    getCustomChainEndpointsForAccountCluster(accountClusterId: string, returnChainIdsOnly: boolean): Promise<ChainEndpoint[]>;
+    isChainSupportedOnAccountCluster(accountClusterId: string, chainId: bigint): Promise<ChainSupportStatus>;
+    getNodeRpcUrl(accountClusterId: string, chainId: bigint): Promise<string>;
+    getVirtualNodeRpcUrl(accountClusterId: string, chainId: bigint, entrypointAccountAddress: string): Promise<string>;
+    getActivity(accountClusterId: string, limit?: number, offset?: number, order?: Order, startDate?: number, endDate?: number, filters?: {
+        transactionHash?: string;
+        address?: string;
+    }[]): Promise<{
+        activities: Activity[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getPortfolioOverview(accountClusterId: string): Promise<FungibleTokenOverview>;
+    getFungibleTokenPortfolio(accountClusterId: string): Promise<StandardizedBalance[]>;
+    getFungibleTokenBalances(accountClusterId: string, offset?: number, limit?: number, chainId?: bigint, tokensToOmit?: string[]): Promise<StandardizedBalance[]>;
+}

package/dist/esm/actions/admin.d.ts

@@ -0,0 +1,17 @@
+import { GasSpendForInstance, GasSponsorshipData } from "../types.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class AdminActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    createInstance(name: string): Promise<{
+        success: boolean;
+        orbyInstancePrivateUrl: string;
+        orbyInstancePublicUrl: string;
+    }>;
+    getInstanceUrls(name: string): Promise<{
+        orbyInstancePrivateUrl: string;
+        orbyInstancePublicUrl: string;
+    }>;
+    getGasSpentForCustomer(month: string, year: string): Promise<GasSponsorshipData>;
+    getGasSpentForInstances(month: string, year: string, instanceNames: string[]): Promise<GasSpendForInstance[]>;
+}

package/dist/esm/actions/application.d.ts

@@ -0,0 +1,6 @@
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class ApplicationActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    isChainAbstractionCompatible(appDomainUrl: string): Promise<boolean>;
+}

package/dist/esm/actions/blockchain.d.ts

@@ -0,0 +1,16 @@
+import { BlockchainInformation } from "../types.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class BlockchainActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getBlockchainInformation(chainId: bigint): Promise<BlockchainInformation>;
+    listBlockchainsInformation(offset?: number, limit?: number): Promise<{
+        blockchains: BlockchainInformation[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getChainsSupportedByDefault(): Promise<BlockchainInformation[]>;
+}

package/dist/esm/actions/instance.d.ts

@@ -0,0 +1,15 @@
+import { ChainEndpoint, GasSponsorshipPolicy } from "../types.js";
+import { LIBRARY_TYPE } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class InstanceActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    setCustomChainEndpointsForInstance(chainEndpoints: ChainEndpoint[]): Promise<boolean>;
+    removeCustomChainEndpointForInstance(chainIds: bigint[]): Promise<boolean>;
+    getCustomChainEndpointsForInstance(returnChainIdsOnly: boolean): Promise<boolean>;
+    enableChainAbstractionForInstance(enable: boolean): Promise<boolean>;
+    enableGasSponsorshipForInstance(enable: boolean): Promise<boolean>;
+    getGasSponsorForInstance(): Promise<string>;
+    getOrbyGasSponsorPolicyForInstance(): Promise<GasSponsorshipPolicy>;
+    setOrbyGasSponsorPolicyForInstance(gasSponsorshipPolicy: GasSponsorshipPolicy): Promise<boolean>;
+    removeOrbyGasSponsorPolicyForInstance(): Promise<boolean>;
+}

package/dist/esm/actions/operation.d.ts

@@ -0,0 +1,99 @@
+import { AccountCluster, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
+import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { LIBRARY_TYPE, OperationStatusType, QuoteType } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class OperationActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: bigint, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToSignTypedData(accountClusterId: string, data: string, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<OperationSet>;
+    isTransactionPreconditionSatisfied(accountClusterId: string, to: string, data: string, value?: bigint): Promise<boolean>;
+    isTypedDataPreconditionSatisfied(accountClusterId: string, data: string): Promise<boolean>;
+    sendSignedOperations(accountClusterId: string, signedOperations: SignedOperation[]): Promise<{
+        operationSetId: string;
+        operationResponses: OperationStatus[];
+    }>;
+    getOperationStatuses(operationIds: string[]): Promise<OperationStatus[]>;
+    estimateFiatCostToExecuteTransaction(to: string, data: string, value?: bigint): Promise<CurrencyAmount>;
+    estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
+    getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: bigint, recipient: {
+        chainId: bigint;
+        recipientAddress: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToSwap(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenDestination?: {
+            chainId: bigint;
+            address?: string;
+        };
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getQuote(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenDestination?: {
+            chainId: bigint;
+            address?: string;
+        };
+    }): Promise<OperationSet>;
+    getOperationsToBridge(accountClusterId: string, standardizedTokenId: string, amount: bigint, tokenSources?: {
+        chainId: bigint;
+        address?: string;
+    }[], tokenDestination?: {
+        chainId: bigint;
+        address?: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void, timout?: number): {
+        intervalId: NodeJS.Timeout | null;
+    };
+    sendOperationSet(accountCluster: AccountCluster, operationSet: OperationSet, signTransaction: (operation: OnchainOperation) => Promise<string | undefined>, signUserOperation: (operations: OnchainOperation[], accountAddress: string, chainId: bigint, txRpcUrl: string) => Promise<UserOperation | undefined>, signTypedData: (operation: OnchainOperation) => Promise<string | undefined>): Promise<{
+        success: boolean;
+        operationSetId?: string;
+        primaryOperationStatus?: OperationStatus;
+        operationResponses?: OperationStatus[];
+    }>;
+}

package/dist/{actions → esm/actions}/operation.js

@@ -1,8 +1,13 @@
 import { extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
-import { OperationStatusType, OperationType, } from "../enums.js";
+import { AccountType, OperationDataFormat, OperationStatusType, OperationType, } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
 import { getOrbyChainId } from "../utils/utils.js";
+import { Account } from "../entities/account.js";
+// from here: https://stackoverflow.com/questions/65152373/typescript-serialize-bigint-in-json
+BigInt.prototype.toJSON = function () {
+    return this.toString();
+};
 export class OperationActions extends LibraryRequest {
     constructor(library, client, provider) {
         super(library, client, provider);
@@ -302,7 +307,7 @@ export class OperationActions extends LibraryRequest {
         }
         return { intervalId };
     }
-    async sendOperationSet(accountClusterId, operationSet, signOperation) {
+    async sendOperationSet(accountCluster, operationSet, signTransaction, signUserOperation, signTypedData) {
         const signedOperations = [];
         const operations = operationSet.intents
             ?.map((intent) => intent.intentOperations)
@@ -319,15 +324,80 @@ export class OperationActions extends LibraryRequest {
         if (!hasPrimaryOperation) {
             return { success: false };
         }
+        const accountsMap = accountCluster.accounts.reduce((acc, account) => {
+            acc.set(account.key, account);
+            return acc;
+        }, new Map());
+        const smartAccountTransactions = operations.reduce((acc, operation) => {
+            const accountKey = Account.key(operation.from, operation.chainId);
+            const account = accountsMap.get(accountKey);
+            if (account?.accountType == AccountType.SCA &&
+                operation.format == OperationDataFormat.TRANSACTION) {
+                if (!acc.has(accountKey)) {
+                    acc.set(accountKey, []);
+                }
+                acc.get(accountKey).push(operation);
+            }
+            return acc;
+        }, new Map());
         // Loop through all the operations and sign them
         for (let i = 0; i < operations.length; i++) {
-            const signature = await signOperation(operations[i]);
+            const operation = operations[i];
+            let signature;
+            if (operation.format == OperationDataFormat.TRANSACTION) {
+                const accountKey = Account.key(operation.from, operation.chainId);
+                const account = accountsMap.get(accountKey);
+                // skip signing the transaction if the account is an SCA
+                if (account?.accountType == AccountType.SCA) {
+                    continue;
+                }
+                signature = await signTransaction(operation);
+            }
+            else if (operation.format == OperationDataFormat.TYPED_DATA) {
+                signature = await signTypedData(operation);
+            }
             if (!signature) {
                 return { success: false };
             }
-            signedOperations.push(signature);
+            signedOperations.push({
+                type: operation.type,
+                signature: signature,
+                data: operation.data,
+                from: operation.from,
+                chainId: getOrbyChainId(operation.chainId),
+            });
+        }
+        // batch sign all the smart contract transactions
+        const accountKeys = Array.from(smartAccountTransactions.keys());
+        for (const accountKey of accountKeys) {
+            const transactions = smartAccountTransactions.get(accountKey);
+            transactions.sort((operationA, _) => {
+                if (operationA.type == OperationType.APPROVE_ERC20_TOKEN) {
+                    return -1;
+                }
+                return 0;
+            });
+            const userOperation = await signUserOperation(transactions, transactions[0].from, transactions[0].chainId, transactions[0].txRpcUrl);
+            if (!userOperation) {
+                return { success: false };
+            }
+            const types = transactions.map((operation) => operation.type);
+            let type = types[0];
+            if (types.includes(OperationType.FINAL_TRANSACTION)) {
+                type = OperationType.FINAL_TRANSACTION;
+            }
+            else if (types.includes(OperationType.SUBMIT_INTENT)) {
+                type = OperationType.SUBMIT_INTENT;
+            }
+            signedOperations.push({
+                type,
+                signature: userOperation.signature,
+                data: JSON.stringify(userOperation),
+                from: transactions[0].from,
+                chainId: getOrbyChainId(transactions[0].chainId),
+            });
         }
-        const { operationSetId, operationResponses } = await this.sendSignedOperations(accountClusterId, signedOperations);
+        const { operationSetId, operationResponses } = await this.sendSignedOperations(accountCluster.accountClusterId, signedOperations);
         return {
             operationSetId,
             operationResponses,

package/dist/esm/actions/token.d.ts

@@ -0,0 +1,15 @@
+import { StandardizedToken } from "../types.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class TokenActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getStandardizedTokenIds(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<string[]>;
+    getStandardizedTokens(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<StandardizedToken[]>;
+    getFungibleTokenData(standardizedTokenIds: string[]): Promise<StandardizedToken[]>;
+}

package/dist/{actions → esm/actions}/token.js

@@ -1,4 +1,4 @@
-import { extractStandardizedTokens, } from "../utils/action_helpers.js";
+import { extractStandardizedTokens } from "../utils/action_helpers.js";
 import { LibraryRequest } from "../entities/library_request.js";
 import { getOrbyChainId } from "../utils/utils.js";
 export class TokenActions extends LibraryRequest {

package/dist/esm/constants.d.ts

@@ -0,0 +1,14 @@
+import { Blockchain } from "./enums.js";
+import { Currency } from "./entities/financial/currency.js";
+import { ChainConfigs } from "./types.js";
+export declare const Big: any;
+export declare const BLOCKCHAIN_ID: {
+    [s: string]: number;
+};
+export declare const CHAIN_CONFIGS: {
+    [s: string]: ChainConfigs;
+};
+export declare const BLOCKCHAIN_ID_TO_BLOCKCHAIN: {
+    [s: number]: Blockchain;
+};
+export declare const FIAT_CURRENCY: Currency;

package/dist/esm/entities/account.d.ts

@@ -0,0 +1,14 @@
+import { AccountType, VMType } from "../enums.js";
+export declare class Account {
+    readonly address: string;
+    readonly chainId?: bigint;
+    readonly accountType: AccountType;
+    readonly vmType: VMType;
+    readonly key: string;
+    hasSufficientBalanceForGas: boolean;
+    static toAccount(account: any): Account;
+    constructor(address: string, accountType: AccountType, vmType: VMType, chainId?: bigint);
+    static key(address: string, chainId?: bigint): string;
+    toAccountModel(): any;
+    equals(other: Account): boolean;
+}

package/dist/{entities → esm/entities}/account.js

@@ -5,7 +5,7 @@ export class Account {
         const chainId = account?.chainId
             ? getChainIdFromOrbyChainId(account.chainId)
             : undefined;
-        const formattedAccountType = account?.accountType?.toLowerCase();
+        const formattedAccountType = account?.accountType;
         if (!chainId && formattedAccountType == AccountType.SCA) {
             return undefined;
         }

package/dist/esm/entities/financial/account_balance.d.ts

@@ -0,0 +1,12 @@
+import { Account } from "../account.js";
+import { FungibleTokenAmount } from "./fungible_token_amount.js";
+export declare class AccountBalance {
+    readonly amount: FungibleTokenAmount;
+    readonly account: Account;
+    static toAccountBalance(balance?: any): AccountBalance;
+    constructor(amount: FungibleTokenAmount, account: Account);
+    equals(other: AccountBalance): boolean;
+    lessThan(other: AccountBalance): boolean;
+    greaterThan(other: AccountBalance): boolean;
+    greaterThanOrEqual(other: AccountBalance): boolean;
+}

package/dist/esm/entities/financial/asset.d.ts

@@ -0,0 +1,31 @@
+/**
+ * An Asset is any fungible financial instrument, including Ether, all ERC20 tokens, and NFTs
+ */
+export declare class Asset {
+    /**
+     * The symbol of the asset, i.e. a short textual non-unique identifier
+     */
+    readonly symbol: string;
+    /**
+     * The name of the asset, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name: string;
+    /**
+     * The name of the asset, i.e. a descriptive textual non-unique identifier
+     */
+    readonly coinGeckoId: string;
+    /**
+     * Constructs an instance of the `Asset`.
+     * @param symbol symbol of the asset
+     * @param name of the asset
+     */
+    constructor(symbol: string, name: string, coinGeckoId?: string);
+    /**
+     * Returns whether this asset is functionally equivalent to the other asset
+     * @param other the other asset
+     */
+    equals(other: Asset): boolean;
+    toAssetModel(): any;
+    static toAsset(asset?: any): Asset;
+    id(): string;
+}

package/dist/esm/entities/financial/currency.d.ts

@@ -0,0 +1,41 @@
+import { Asset } from "./asset.js";
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare class Currency extends Asset {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable in Uniswap without wrapping
+     */
+    readonly isToken: boolean;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The url for the currency logo
+     */
+    readonly logoUrl?: string;
+    /**
+     * Constructs an instance of the base class `Currency`.
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     * @param isNative whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     * @param isToken whether the currency is a token that is usable in Uniswap without wrapping
+     */
+    constructor(decimals: number, symbol: string, name: string, logoUrl?: string, isNative?: boolean, isToken?: boolean, coinGeckoId?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    equals(other: Currency): boolean;
+    /**
+     * Returns the asset representation of this currency
+     */
+    asset(): Asset;
+    static toCurrency(currency?: any): Currency;
+}

package/dist/esm/entities/financial/currency_amount.d.ts

@@ -0,0 +1,34 @@
+import JSBI from "jsbi";
+import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
+import { Currency } from "./currency.js";
+export declare class CurrencyAmount extends Fraction {
+    readonly currency: Currency;
+    readonly decimalScale: JSBI;
+    private amountInFiatCurrency?;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount(currency: Currency, rawAmount: BigintIsh | bigint): CurrencyAmount;
+    static toCurrencyAmount(amount?: any): CurrencyAmount;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount(currency: Currency, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount;
+    protected constructor(currency: Currency, numerator: BigintIsh | bigint, denominator?: BigintIsh | bigint);
+    add(other: CurrencyAmount): CurrencyAmount;
+    subtract(other: CurrencyAmount): CurrencyAmount;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount;
+    divide(other: Fraction | BigintIsh): CurrencyAmount;
+    cloneWithAmount(amount: bigint): CurrencyAmount;
+    toRawAmount(): bigint;
+    toCurrencyValue(price: CurrencyAmount): CurrencyAmount;
+    fiatValue(): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+}

package/dist/esm/entities/financial/fungible_token.d.ts

@@ -0,0 +1,41 @@
+import { Currency } from "./currency.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class FungibleToken extends Currency {
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    /**
+     * @param isNative If true, it means that this token is the native token of the chain
+     */
+    readonly isNative: boolean;
+    static toFungibleToken(token?: any): FungibleToken;
+    /**
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     */
+    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, bypassChecksum?: boolean, isNative?: boolean, coinGeckoId?: string, logoUrl?: string);
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: FungibleToken): boolean;
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency(): Currency;
+    type(): TokenType;
+    identifier(): string;
+}

package/dist/esm/entities/financial/fungible_token_amount.d.ts

@@ -0,0 +1,36 @@
+import JSBI from "jsbi";
+import { Fraction, BigintIsh, Rounding } from "@uniswap/sdk-core";
+import { FungibleToken } from "./fungible_token.js";
+import { CurrencyAmount } from "./currency_amount.js";
+export declare class FungibleTokenAmount extends Fraction {
+    readonly token: FungibleToken;
+    readonly decimalScale: JSBI;
+    private amountInFiatCurrency?;
+    /**
+     * Returns a new fungibleToken amount instance from the unitless amount of token, i.e. the raw amount
+     * @param fungibleToken the fungibleToken in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount(fungibleToken: FungibleToken, rawAmount: BigintIsh | bigint, amountInFiatCurrency?: CurrencyAmount): FungibleTokenAmount;
+    /**
+     * Construct a fungibleToken amount with a denominator that is not equal to 1
+     * @param fungibleToken the fungibleToken
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount(fungibleToken: FungibleToken, numerator: BigintIsh, denominator: BigintIsh, amountInFiatCurrency?: CurrencyAmount): FungibleTokenAmount;
+    static toFungibleTokenAmount(amount?: any): FungibleTokenAmount;
+    protected constructor(fungibleToken: FungibleToken, numerator: BigintIsh | bigint, denominator?: BigintIsh | bigint, amountInFiatCurrency?: CurrencyAmount);
+    equals(other: FungibleTokenAmount): boolean;
+    add(other: FungibleTokenAmount): FungibleTokenAmount;
+    subtract(other: FungibleTokenAmount): FungibleTokenAmount;
+    multiply(other: Fraction | BigintIsh): FungibleTokenAmount;
+    divide(other: Fraction | BigintIsh): FungibleTokenAmount;
+    greaterThanOrEqual(other: FungibleTokenAmount): boolean;
+    toRawAmount(): bigint;
+    fiatValue(): CurrencyAmount;
+    toCurrencyValue(price: CurrencyAmount): CurrencyAmount;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+}

package/dist/esm/entities/financial/non_fungible_token.d.ts

@@ -0,0 +1,39 @@
+import { Asset } from "./asset.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC721 token with a unique address and some metadata.
+ */
+export declare class NonFungibleToken extends Asset {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    readonly url?: string;
+    /**
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @param url The URL of the token's metadata
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     */
+    constructor(chainId: bigint, address: string, symbol: string, name: string, url?: string, bypassChecksum?: boolean, coinGeckoId?: string);
+    static toNonFungibleToken(nft?: any): NonFungibleToken;
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: NonFungibleToken): boolean;
+    /**
+     * Returns the asset representation of this currency
+     */
+    asset(): Asset;
+    type(): TokenType;
+    identifier(): string;
+}

package/dist/esm/entities/financial/semi_fungible_token.d.ts

@@ -0,0 +1,41 @@
+import { Currency } from "./currency.js";
+import { TokenType } from "../../enums.js";
+/**
+ * Represents an ERC1155 token with a unique address and some metadata.
+ */
+export declare class SemiFungibleToken extends Currency {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * The chain ID on which this token resides
+     */
+    readonly chainId: bigint;
+    readonly url?: string;
+    /**
+     *
+     * @param chainId The chain ID on which this token resides
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link Currency#decimals}
+     * @param symbol {@link Currency#symbol}
+     * @param name {@link Currency#name}
+     * @param url The URL of the token's metadata
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     */
+    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, url?: string, bypassChecksum?: boolean, coinGeckoId?: string);
+    static toSemiFungibleToken(sft?: any): SemiFungibleToken;
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: SemiFungibleToken): boolean;
+    /**
+     * Returns the currency object that this token represents
+     */
+    currency(): Currency;
+    type(): TokenType;
+    identifier(): string;
+}

package/dist/esm/entities/library_request.d.ts

@@ -0,0 +1,8 @@
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class LibraryRequest {
+    readonly library: LIBRARY_TYPE;
+    readonly client?: any;
+    readonly provider?: any;
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    sendRequest(method: string, params: any[]): Promise<any>;
+}