@orb-labs/orby-core 0.0.14 → 0.0.15

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

@@ -0,0 +1,99 @@
+import { OnchainOperation, OperationSet, OperationStatus, SignedOperation } 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(accountClusterId: string, operationSet: OperationSet, signOperation: (operation: OnchainOperation) => Promise<SignedOperation | undefined>): Promise<{
+        success: boolean;
+        operationSetId?: string;
+        primaryOperationStatus?: OperationStatus;
+        operationResponses?: OperationStatus[];
+    }>;
+}

package/dist/esm/actions/operation.js

@@ -0,0 +1,341 @@
+import { extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
+import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { OperationStatusType, OperationType, } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { getOrbyChainId } from "../utils/utils.js";
+export class OperationActions extends LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getOperationsToExecuteTransaction(accountClusterId, to, data, value, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToExecuteTransaction", [
+            {
+                accountClusterId,
+                to,
+                data,
+                value,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async getOperationsToSignTypedData(accountClusterId, data, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [
+            {
+                accountClusterId,
+                data,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
+        const operationSet = await this.sendRequest("orby_getOperationsToCancelTransaction", [
+            {
+                accountClusterId,
+                operationSetId,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async isTransactionPreconditionSatisfied(accountClusterId, to, data, value) {
+        const { satisfied } = await this.sendRequest("orby_isTransactionPreconditionSatisfied", [
+            {
+                accountClusterId,
+                to,
+                data,
+                value,
+            },
+        ]);
+        return satisfied;
+    }
+    async isTypedDataPreconditionSatisfied(accountClusterId, data) {
+        const { satisfied, code, message } = await this.sendRequest("orby_isTypedDataPreconditionSatisfied", [
+            {
+                accountClusterId,
+                data,
+            },
+        ]);
+        if (code && message) {
+            console.error("[isTypedDataPreconditionSatisfied]", code, message);
+            return undefined;
+        }
+        return satisfied;
+    }
+    async sendSignedOperations(accountClusterId, signedOperations) {
+        const { operationSetId, operationResponses, code, message } = await this.sendRequest("orby_sendSignedOperations", [
+            {
+                accountClusterId,
+                signedOperations,
+            },
+        ]);
+        if (code && message) {
+            console.error("[sendSignedOperations]", code, message);
+            return undefined;
+        }
+        return {
+            operationSetId,
+            operationResponses: extractOperationStatuses(operationResponses),
+        };
+    }
+    async getOperationStatuses(operationIds) {
+        const { operationStatuses } = await this.sendRequest("orby_getOperationStatuses", [{ operationIds }]);
+        return extractOperationStatuses(operationStatuses);
+    }
+    async estimateFiatCostToExecuteTransaction(to, data, value) {
+        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToExecuteTransaction", [
+            {
+                to,
+                data,
+                value,
+            },
+        ]);
+        if (code && message) {
+            console.error("[estimateFiatCostToExecuteTransaction]", code, message);
+            return undefined;
+        }
+        return CurrencyAmount.toCurrencyAmount(estimatedCost);
+    }
+    async estimateFiatCostToSignTypedData(data) {
+        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToSignTypedData", [{ data }]);
+        if (code && message) {
+            console.error("[estimateFiatCostToSignTypedData]", code, message);
+            return undefined;
+        }
+        return CurrencyAmount.toCurrencyAmount(estimatedCost);
+    }
+    async getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedRecepient = {
+            chainId: getOrbyChainId(recipient.chainId),
+            recipientAddress: recipient.recipientAddress,
+        };
+        const operationSet = await this.sendRequest("orby_getOperationsToTransferToken", [
+            {
+                accountClusterId,
+                standardizedTokenId,
+                amount,
+                recipient: formattedRecepient,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async getOperationsToSwap(accountClusterId, swapType, input, output, gasToken) {
+        const formattedInput = input
+            ? {
+                ...input,
+                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedOutput = output
+            ? {
+                ...output,
+                tokenDestination: output?.tokenDestination
+                    ? {
+                        chainId: getOrbyChainId(output.tokenDestination.chainId),
+                        address: output.tokenDestination.address,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToSwap", [
+            {
+                accountClusterId,
+                swapType,
+                input: formattedInput,
+                output: formattedOutput,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async getQuote(accountClusterId, swapType, input, output) {
+        const formattedInput = input
+            ? {
+                ...input,
+                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const formattedOutput = output
+            ? {
+                ...output,
+                tokenDestination: output?.tokenDestination
+                    ? {
+                        chainId: getOrbyChainId(output.tokenDestination.chainId),
+                        address: output.tokenDestination.address,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getQuote", [
+            {
+                accountClusterId,
+                swapType,
+                input: formattedInput,
+                output: formattedOutput,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    async getOperationsToBridge(accountClusterId, standardizedTokenId, amount, tokenSources, tokenDestination, gasToken) {
+        const formattedTokenSources = tokenSources.map(({ chainId, address }) => ({
+            chainId: getOrbyChainId(chainId),
+            address,
+        }));
+        const formattedDestination = tokenDestination
+            ? {
+                chainId: getOrbyChainId(tokenDestination.chainId),
+                address: tokenDestination.address,
+            }
+            : undefined;
+        const formattedGasToken = gasToken
+            ? {
+                ...gasToken,
+                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
+                    chainId: getOrbyChainId(chainId),
+                    address,
+                })),
+            }
+            : undefined;
+        const operationSet = await this.sendRequest("orby_getOperationsToBridge", [
+            {
+                accountClusterId,
+                standardizedTokenId,
+                amount,
+                tokenSources: formattedTokenSources,
+                tokenDestination: formattedDestination,
+                gasToken: formattedGasToken,
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
+    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback, timout) {
+        let intervalId = null;
+        let totalWaitTime = 0;
+        const timeoutOrDefault = timout ?? 300_000;
+        if (ids && ids?.length > 0) {
+            const waitTime = 500;
+            intervalId = setInterval(async () => {
+                let statusSummary = OperationStatusType.WAITING_PRECONDITION;
+                let primaryOperation;
+                try {
+                    const statuses = ids && ids?.length > 0
+                        ? await this?.getOperationStatuses(ids)
+                        : undefined;
+                    if (!ids || ids?.length == 0) {
+                        statusSummary = OperationStatusType.NOT_FOUND;
+                    }
+                    else if (!statuses) {
+                        statusSummary = OperationStatusType.NOT_FOUND;
+                    }
+                    else if (statuses.some((status) => status.status == OperationStatusType.FAILED)) {
+                        statusSummary = OperationStatusType.FAILED;
+                    }
+                    else if (statuses.every((status) => status.status == OperationStatusType.SUCCESSFUL)) {
+                        statusSummary = OperationStatusType.SUCCESSFUL;
+                    }
+                    primaryOperation = statuses?.find((status) => status.type == OperationType.FINAL_TRANSACTION);
+                    if (primaryOperation?.status == OperationStatusType.PENDING) {
+                        statusSummary = OperationStatusType.PENDING;
+                    }
+                    onOperationStatusesUpdateCallback?.(statusSummary, primaryOperation, statuses);
+                }
+                catch (error) {
+                    console.error("[useWaitForStatusCompletion]", error);
+                }
+                finally {
+                    totalWaitTime += waitTime;
+                    if (intervalId &&
+                        OperationStatusType.WAITING_PRECONDITION != statusSummary) {
+                        clearInterval(intervalId);
+                        intervalId = null;
+                    }
+                    else if (intervalId && totalWaitTime >= timeoutOrDefault) {
+                        // we cant wait for more than 2 ETH blocks
+                        clearInterval(intervalId);
+                        intervalId = null;
+                    }
+                }
+            }, waitTime);
+        }
+        return { intervalId };
+    }
+    async sendOperationSet(accountClusterId, operationSet, signOperation) {
+        const signedOperations = [];
+        const operations = operationSet.intents
+            ?.map((intent) => intent.intentOperations)
+            .flat()
+            ?.concat(operationSet.primaryOperation)
+            .filter((value) => value != undefined && value != null);
+        if (operations?.length == 0) {
+            return { success: true, operationResponses: [] };
+        }
+        else if (!operations) {
+            return { success: false };
+        }
+        const hasPrimaryOperation = operations.find((operation) => operation.type == OperationType.FINAL_TRANSACTION);
+        if (!hasPrimaryOperation) {
+            return { success: false };
+        }
+        // Loop through all the operations and sign them
+        for (let i = 0; i < operations.length; i++) {
+            const signature = await signOperation(operations[i]);
+            if (!signature) {
+                return { success: false };
+            }
+            signedOperations.push(signature);
+        }
+        const { operationSetId, operationResponses } = await this.sendSignedOperations(accountClusterId, signedOperations);
+        return {
+            operationSetId,
+            operationResponses,
+            success: true,
+            primaryOperationStatus: {
+                type: OperationType.FINAL_TRANSACTION,
+                status: OperationStatusType.WAITING_PRECONDITION,
+            },
+        };
+    }
+}

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/esm/actions/token.js

@@ -0,0 +1,46 @@
+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 {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getStandardizedTokenIds(tokens) {
+        const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+            return { chainId: getOrbyChainId(chainId), tokenAddress };
+        });
+        const { standardizedTokenIds, message, code } = await this.sendRequest("orby_getStandardizedTokenIds", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getStandardizedTokenIds]", code, message);
+            return undefined;
+        }
+        return standardizedTokenIds;
+    }
+    async getStandardizedTokens(tokens) {
+        const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+            return { chainId: getOrbyChainId(chainId), tokenAddress };
+        });
+        const { standardizedTokens, message, code } = await this.sendRequest("orby_getStandardizedTokens", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getStandardizedTokens]", code, message);
+            return undefined;
+        }
+        return extractStandardizedTokens(standardizedTokens);
+    }
+    async getFungibleTokenData(standardizedTokenIds) {
+        const { data, message, code } = await this.sendRequest("orby_getFungibleTokenData", [{ standardizedTokenIds }]);
+        if (code && message) {
+            console.error("[getFungibleTokenData]", code, message);
+            return undefined;
+        }
+        return extractStandardizedTokens(data);
+    }
+}

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/constants.js

@@ -0,0 +1,133 @@
+import toFormat from "toformat";
+import _Big from "big.js";
+import { Blockchain, BlockchainEnvironment } from "./enums.js";
+import { Currency } from "./entities/financial/currency.js";
+export const Big = toFormat(_Big);
+export const BLOCKCHAIN_ID = {
+    [Blockchain.ETHEREUM]: 1,
+    [Blockchain.POLYGON]: 137,
+    [Blockchain.BINANCE]: 56,
+    [Blockchain.ARBITRUM]: 42161,
+    [Blockchain.ARBITRUM_NOVA]: 42170,
+    [Blockchain.OPTIMISM]: 10,
+    [Blockchain.EVMOS]: 9001,
+    [Blockchain.MOONBEAM]: 1284,
+    [Blockchain.BASE]: 8453,
+    [Blockchain.AVALANCHE]: 43114,
+    // testnets
+    [Blockchain.ETHEREUM_SEPOLIA]: 11155111,
+    [Blockchain.ETHEREUM_HOLESKY]: 17000,
+    [Blockchain.ARBITRUM_SEPOLIA]: 421614,
+    [Blockchain.OPTIMISM_SEPOLIA]: 11155420,
+    [Blockchain.POLYGON_AMOY]: 80002,
+    [Blockchain.BINANCE_TESTNET]: 97,
+    [Blockchain.OPBNB_TESTNET]: 5611,
+    [Blockchain.MOONBEAM_ALPHA]: 1287,
+    [Blockchain.BASE_SEPOLIA]: 84532,
+    // local testing
+    [Blockchain.HARDHAT]: 31337,
+    [Blockchain.LOCAL_CHAIN_0]: 1_000_000_000_001,
+    [Blockchain.LOCAL_CHAIN_1]: 1_000_000_000_002,
+};
+export const CHAIN_CONFIGS = {
+    [Blockchain.ETHEREUM]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(1),
+    },
+    [Blockchain.POLYGON]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(137),
+    },
+    [Blockchain.BINANCE]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(56),
+    },
+    [Blockchain.ARBITRUM]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(42161),
+    },
+    [Blockchain.ARBITRUM_NOVA]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(42170),
+    },
+    [Blockchain.OPTIMISM]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(10),
+    },
+    [Blockchain.EVMOS]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(9001),
+    },
+    [Blockchain.MOONBEAM]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(1284),
+    },
+    [Blockchain.BASE]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(8453),
+    },
+    [Blockchain.AVALANCHE]: {
+        environment: BlockchainEnvironment.MAINNET,
+        chainId: BigInt(43114),
+    },
+    // testnets
+    [Blockchain.ETHEREUM_SEPOLIA]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(11155111),
+    },
+    [Blockchain.ETHEREUM_HOLESKY]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(17000),
+    },
+    [Blockchain.ARBITRUM_SEPOLIA]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(421614),
+    },
+    [Blockchain.BASE_SEPOLIA]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(84532),
+    },
+    [Blockchain.OPTIMISM_SEPOLIA]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(11155420),
+    },
+    [Blockchain.BINANCE_TESTNET]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(97),
+    },
+    [Blockchain.OPBNB_TESTNET]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(5611),
+    },
+    [Blockchain.MOONBEAM_ALPHA]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(1287),
+    },
+    [Blockchain.POLYGON_AMOY]: {
+        environment: BlockchainEnvironment.TESTNET,
+        chainId: BigInt(80002),
+    },
+};
+export const BLOCKCHAIN_ID_TO_BLOCKCHAIN = {
+    [1]: Blockchain.ETHEREUM,
+    [137]: Blockchain.POLYGON,
+    [56]: Blockchain.BINANCE,
+    [42161]: Blockchain.ARBITRUM,
+    [42170]: Blockchain.ARBITRUM_NOVA,
+    [10]: Blockchain.OPTIMISM,
+    [9001]: Blockchain.EVMOS,
+    [1284]: Blockchain.MOONBEAM,
+    [8453]: Blockchain.BASE,
+    [43114]: Blockchain.AVALANCHE,
+    // testnets
+    [11155111]: Blockchain.ETHEREUM_SEPOLIA,
+    [84532]: Blockchain.BASE_SEPOLIA,
+    [17000]: Blockchain.ETHEREUM_HOLESKY,
+    [421614]: Blockchain.ARBITRUM_SEPOLIA,
+    [11155420]: Blockchain.OPTIMISM_SEPOLIA,
+    [80002]: Blockchain.POLYGON_AMOY,
+    [97]: Blockchain.BINANCE_TESTNET,
+    [5611]: Blockchain.OPBNB_TESTNET,
+    [1287]: Blockchain.MOONBEAM_ALPHA,
+};
+export const FIAT_CURRENCY = new Currency(6, "USD", "US Dollar", undefined, false, false);

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;
+}