@orb-labs/orby-core 0.0.14 → 0.0.16

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

@@ -0,0 +1,22 @@
+import { FungibleToken } from "./financial/fungible_token.js";
+import { FungibleTokenAmount } from "./financial/fungible_token_amount.js";
+import { NonFungibleToken } from "./financial/non_fungible_token.js";
+import { SemiFungibleToken } from "./financial/semi_fungible_token.js";
+export declare class State {
+    private readonly fungibleTokens;
+    private readonly nonFungibleTokens;
+    private readonly semiFungibleTokens;
+    constructor(fungibleTokens: FungibleTokenAmount[], nonFungibleTokens: NonFungibleToken[], semiFungibleTokens: SemiFungibleToken[]);
+    static fromFungibleTokenAmounts(fungibleTokenAmounts: FungibleTokenAmount[]): State;
+    static fromTokenAndAmount(token?: FungibleToken, amount?: bigint): State;
+    getFungibleTokens(): FungibleTokenAmount[];
+    getNonFungibleTokens(): NonFungibleToken[];
+    getSemiFungibleTokens(): SemiFungibleToken[];
+    addTokens(fungibleTokens: FungibleTokenAmount[]): State;
+    addState(other: State): State;
+    deductState(other: State): State;
+    equals(other?: State): boolean;
+    addStates(states: State[]): State;
+    static mergeStates(states: State[]): State;
+    static toState(state: any): State;
+}

package/dist/esm/enums.d.ts

@@ -0,0 +1,116 @@
+export declare enum Blockchain {
+    ETHEREUM = "ethereum",
+    POLYGON = "polygon",
+    BINANCE = "binance",
+    ARBITRUM = "arbitrum",
+    BASE = "base",
+    AVALANCHE = "avalanche",
+    ARBITRUM_NOVA = "arbitrum_nova",
+    OPTIMISM = "optimism",
+    EVMOS = "evmos",
+    MOONBEAM = "moonbeam",
+    ETHEREUM_SEPOLIA = "ethereum_sepolia",
+    ETHEREUM_HOLESKY = "ethereum_holesky",
+    BASE_SEPOLIA = "base_sepolia",
+    ARBITRUM_SEPOLIA = "arbitrum_sepolia",
+    OPTIMISM_SEPOLIA = "optimism_sepolia",
+    POLYGON_AMOY = "polygon_amoy",
+    BINANCE_TESTNET = "binance_testnet",
+    OPBNB_TESTNET = "opbnb_testnet",
+    MOONBEAM_ALPHA = "moonbeam_alpha",
+    HARDHAT = "hardhat",
+    LOCAL_CHAIN_0 = "local_chain_0",
+    LOCAL_CHAIN_1 = "local_chain_1"
+}
+export declare enum TokenType {
+    FUNGIBLE_TOKEN = "FUNGIBLE_TOKEN",
+    NON_FUNGIBLE_TOKEN = "NON_FUNGIBLE_TOKEN",
+    SEMI_FUNGIBLE_TOKEN = "SEMI_FUNGIBLE_TOKEN",
+    FIAT = "FIAT"
+}
+export declare enum AccountType {
+    EOA = "EOA",
+    SCA = "SCA"
+}
+export declare enum VMType {
+    EVM = "EVM"
+}
+export declare enum ChainSupportStatus {
+    CHAIN_SUPPORTED = "CHAIN_SUPPORTED",
+    CHAIN_UNAVAILABLE = "CHAIN_UNAVAILABLE",
+    ACCOUNT_UNAVAILABLE = "ACCOUNT_UNAVAILABLE"
+}
+export declare enum CreateOperationsStatus {
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    INSUFFICIENT_FUNDS_FOR_GAS = "INSUFFICIENT_FUNDS_FOR_GAS",
+    INTERNAL = "INTERNAL",
+    INVALID_ARGUMENT = "INVALID_ARGUMENT",
+    NO_EXECUTION_PATH = "NO_EXECUTION_PATH",
+    SUCCESS = "SUCCESS"
+}
+export declare enum OperationDataFormat {
+    TRANSACTION = "TRANSACTION",
+    TYPED_DATA = "TYPED_DATA"
+}
+export declare enum OperationType {
+    APPROVE_ERC20_TOKEN = "APPROVE_ERC20_TOKEN",
+    CANCEL_OPERATION = "CANCEL_OPERATION",
+    CANCEL_TRANSACTION = "CANCEL_TRANSACTION",
+    FINAL_TRANSACTION = "FINAL_TRANSACTION",
+    GAS_ABSTRACTION = "GAS_ABSTRACTION",
+    NATIVE_TOKEN_TRANSFER = "NATIVE_TOKEN_TRANSFER",
+    SUBMIT_INTENT = "SUBMIT_INTENT"
+}
+export declare enum Category {
+    SEND = "SEND",
+    RECEIVE = "RECEIVE",
+    SWAP = "SWAP",
+    REBALANCE = "REBALANCE",
+    BRIDGE = "BRIDGE",
+    FUNCTION_CALL = "FUNCTION_CALL",
+    TYPED_DATA_SIGNATURE = "TYPED_DATA_SIGNATURE"
+}
+export declare enum OperationStatusType {
+    FAILED = "FAILED",
+    NOT_FOUND = "NOT_FOUND",
+    PENDING = "PENDING",
+    SUCCESSFUL = "SUCCESSFUL",
+    WAITING_PRECONDITION = "WAITING_PRECONDITION"
+}
+export declare enum QuoteType {
+    EXACT_INPUT = "EXACT_INPUT",
+    EXACT_OUTPUT = "EXACT_OUTPUT"
+}
+export declare enum Order {
+    NEWEST = "NEWEST",
+    OLDEST = "OLDEST"
+}
+export declare enum ActivityStatus {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    SUCCESS = "SUCCESS"
+}
+export declare enum BlockchainEnvironment {
+    MAINNET = "MAINNET",
+    TESTNET = "TESTNET"
+}
+export declare enum TokenAllowlistType {
+    ALL_TOKENS = "ALL_TOKENS",
+    ONLY_FUNGIBLE_TOKENS = "ONLY_FUNGIBLE_TOKENS",
+    ONLY_NON_FUNGIBLE_TOKENS = "ONLY_NON_FUNGIBLE_TOKENS",
+    ONLY_SEMI_FUNGIBLE_TOKENS = "ONLY_SEMI_FUNGIBLE_TOKENS"
+}
+export declare enum TimeIntervalUnits {
+    DAYS = "DAYS",
+    FOREVER = "FOREVER",
+    HOURS = "HOURS",
+    MINUTES = "MINUTES",
+    MONTHS = "MONTHS",
+    WEEKS = "WEEKS",
+    YEARS = "YEARS"
+}
+export declare enum LIBRARY_TYPE {
+    VIEM = "VIEM",
+    ETHERS = "ETHERS"
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,29 @@
+export * from "./interfaces/account_cluster.js";
+export * from "./interfaces/admin.js";
+export * from "./interfaces/application.js";
+export * from "./interfaces/instance.js";
+export * from "./interfaces/operation.js";
+export * from "./interfaces/token.js";
+export * from "./interfaces/orby.js";
+export * from "./interfaces/blockchain.js";
+export * from "./actions/account_cluster.js";
+export * from "./actions/admin.js";
+export * from "./actions/application.js";
+export * from "./actions/instance.js";
+export * from "./actions/operation.js";
+export * from "./actions/token.js";
+export * from "./actions/blockchain.js";
+export * from "./entities/financial/account_balance.js";
+export * from "./entities/financial/asset.js";
+export * from "./entities/financial/currency_amount.js";
+export * from "./entities/financial/currency.js";
+export * from "./entities/financial/fungible_token_amount.js";
+export * from "./entities/financial/fungible_token.js";
+export * from "./entities/financial/non_fungible_token.js";
+export * from "./entities/financial/semi_fungible_token.js";
+export * from "./entities/account.js";
+export * from "./entities/state.js";
+export * from "./enums.js";
+export * from "./types.js";
+export * from "./constants.js";
+export * from "./utils/utils.js";

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

@@ -0,0 +1,30 @@
+import { Account } from "../entities/account.js";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
+import { ChainSupportStatus, Order } from "../enums.js";
+export interface IAccountClusterActions {
+    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/interfaces/admin.d.ts

@@ -0,0 +1,14 @@
+import { GasSpendForInstance, GasSponsorshipData } from "../types.js";
+export interface IAdminActions {
+    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/interfaces/application.d.ts

@@ -0,0 +1,3 @@
+export interface IApplicationActions {
+    isChainAbstractionCompatible(appDomainUrl: string): Promise<boolean>;
+}

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

@@ -0,0 +1,13 @@
+import { BlockchainInformation } from "../types.js";
+export interface IBlockchainActions {
+    getBlockchainInformation(chainId: bigint): Promise<BlockchainInformation>;
+    listBlockchainsInformation(offset?: number, limit?: number): Promise<{
+        blockchains: BlockchainInformation[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getChainsSupportedByDefault(chainId: bigint): Promise<BlockchainInformation[]>;
+}

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

@@ -0,0 +1,12 @@
+import { ChainEndpoint, GasSponsorshipPolicy } from "../types.js";
+export interface IInstanceActions {
+    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/interfaces/operation.d.ts

@@ -0,0 +1,97 @@
+import { AccountCluster, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
+import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { OperationStatusType, QuoteType } from "../enums.js";
+export interface IOperationActions {
+    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/esm/interfaces/orby.d.ts

@@ -0,0 +1,9 @@
+import { IAccountClusterActions } from "./account_cluster.js";
+import { IAdminActions } from "./admin.js";
+import { IApplicationActions } from "./application.js";
+import { IBlockchainActions } from "./blockchain.js";
+import { IInstanceActions } from "./instance.js";
+import { IOperationActions } from "./operation.js";
+import { ITokenActions } from "./token.js";
+export interface Orby extends IAccountClusterActions, IAdminActions, IApplicationActions, IInstanceActions, IOperationActions, ITokenActions, IBlockchainActions {
+}

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

@@ -0,0 +1,12 @@
+import { StandardizedToken } from "../types.js";
+export interface ITokenActions {
+    getStandardizedTokenIds(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<string[]>;
+    getStandardizedTokens(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<StandardizedToken[]>;
+    getFungibleTokenData(standardizedTokenIds: string[]): Promise<StandardizedToken[]>;
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,172 @@
+import { Account } from "./entities/account.js";
+import { Currency } from "./entities/financial/currency.js";
+import { CurrencyAmount } from "./entities/financial/currency_amount.js";
+import { FungibleToken } from "./entities/financial/fungible_token.js";
+import { FungibleTokenAmount } from "./entities/financial/fungible_token_amount.js";
+import { State } from "./entities/state.js";
+import { ActivityStatus, BlockchainEnvironment, Category, CreateOperationsStatus, OperationDataFormat, OperationStatusType, OperationType, TimeIntervalUnits, TokenAllowlistType } from "./enums.js";
+export type AccountCluster = {
+    accountClusterId: string;
+    accounts: Account[];
+};
+export type ChainEndpoint = {
+    chainId: bigint;
+    customRpcUrls?: string[];
+    customIndexerUrls?: string[];
+};
+export interface OperationSet {
+    status: CreateOperationsStatus;
+    primaryOperation?: OnchainOperation;
+    primaryOperationPreconditions?: State;
+    inputState?: State;
+    outputState?: State;
+    intents?: Intent[];
+    aggregateNetworkFeeInFiatCurrency?: CurrencyAmount;
+    aggregateOperationFeeInFiatCurrency?: CurrencyAmount;
+    aggregateEstimatedTimeInMs?: number;
+}
+export type Intent = {
+    estimatedProtocolFees?: FungibleTokenAmount;
+    estimatedProtocolFeesInFiatCurrency?: CurrencyAmount;
+    inputState?: State;
+    intentOperations?: OnchainOperation[];
+    outputState?: State;
+};
+export type UserOperation = {
+    sender: string;
+    nonce: string;
+    factory: string;
+    factoryData: string;
+    callData: string;
+    callGasLimit: string;
+    verificationGasLimit: string;
+    preVerificationGas: string;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    paymasterVerificationGasLimit: string;
+    paymasterPostOpGasLimit: string;
+    signature: string;
+    paymaster: string;
+    paymasterData: string;
+    entrypoint: string;
+};
+export interface OnchainOperation {
+    chainId: bigint;
+    data: string;
+    estimatedNetworkFees?: CurrencyAmount;
+    estimatedNetworkFeesInFiatCurrency?: CurrencyAmount;
+    estimatedTimeInMs?: number;
+    format: OperationDataFormat;
+    from?: string;
+    gasLimit?: bigint;
+    gasPrice?: bigint;
+    inputState?: State;
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    nativeCurrency?: Currency;
+    nonce?: bigint;
+    outputState?: State;
+    to?: string;
+    txRpcUrl: string;
+    type: OperationType;
+    value?: bigint;
+}
+export type SignedOperation = {
+    type: OperationType;
+    signature: string;
+    category?: Category;
+    data?: string;
+    from?: string;
+    chainId?: string;
+};
+export type OperationStatus = {
+    blockHash?: string;
+    blockNumber?: bigint;
+    chainId?: bigint;
+    errorReason?: string;
+    hash?: string;
+    id?: string;
+    status: OperationStatusType;
+    type: OperationType;
+};
+export type Activity = {
+    aggregateFiatValueOfInputState?: CurrencyAmount;
+    aggregateFiatValueOfOutputState?: CurrencyAmount;
+    aggregateNetworkFeesInFiatCurrency?: CurrencyAmount;
+    aggregateProtocolFeesInFiatCurrency?: CurrencyAmount;
+    category: Category;
+    initiateAt?: Date;
+    inputState?: State;
+    operationStatuses: OperationStatus[];
+    outputState?: State;
+    overallStatus: ActivityStatus;
+};
+export type FungibleTokenOverview = {
+    tokenCount: number;
+    hiddenTokenCount: number;
+    totalValueInFiat: CurrencyAmount;
+};
+export type StandardizedBalance = {
+    standardizedTokenId: string;
+    tokenBalances: FungibleTokenAmount[];
+    tokenBalancesOnChains: FungibleTokenAmount[];
+    total: CurrencyAmount;
+    totalValueInFiat?: CurrencyAmount;
+};
+export type StandardizedToken = {
+    standardizedTokenId: string;
+    currency: Currency;
+    priceInFiat?: CurrencyAmount;
+    tokens: FungibleToken[];
+};
+export type BlockchainInformation = {
+    chainId: bigint;
+    environment: BlockchainEnvironment;
+    logoUrl?: string;
+    name?: string;
+};
+export type ContractAllowlistWithAllMethodFallback = {
+    contractAddress: string;
+    sponsoredFunctions?: string[];
+};
+export type TokenAllowlistWithAllMethodsFallback = {
+    sponsoredFunctions?: string[];
+    tokenAllowlistType: TokenAllowlistType;
+};
+export type AllowlistWithOpenFallback = {
+    arbitraryContractAllowlist?: ContractAllowlistWithAllMethodFallback[];
+    tokenAllowlist?: TokenAllowlistWithAllMethodsFallback;
+};
+export type TimeInterval = {
+    amount?: bigint;
+    unit: TimeIntervalUnits;
+};
+export type MaxAmountPerInterval = {
+    amount: bigint;
+    interval: TimeInterval;
+};
+export type GasSponsorshipPolicy = {
+    allowlistWithOpenFallback?: AllowlistWithOpenFallback;
+    maxGasSpendPerTransaction?: bigint;
+    maxTotalGasSpendForInstance?: MaxAmountPerInterval;
+    maxTotalGasSpendPerUser?: MaxAmountPerInterval;
+    maxTotalTransactionCountForInstance?: MaxAmountPerInterval;
+    maxTotalTransactionCountPerUser?: MaxAmountPerInterval;
+};
+export type GasSpendForInstance = {
+    instanceName?: string;
+    gasSpentForInstance?: GasSponsorshipData;
+};
+export type GasSponsorshipData = {
+    totalGasSpent: CurrencyAmount;
+    totalTransactionCount: bigint;
+};
+export type ChainConfigs = {
+    environment: BlockchainEnvironment;
+    chainId: bigint;
+};
+export type VirtualNodeRpcUrlForSupportedChain = {
+    chainId: string;
+    entrypointAccountAddress: string;
+    virtualNodeRpcUrl: string;
+};

package/dist/esm/utils/action_helpers.d.ts

@@ -0,0 +1,22 @@
+import { AccountCluster, Activity, AllowlistWithOpenFallback, BlockchainInformation, FungibleTokenOverview, GasSpendForInstance, GasSponsorshipData, GasSponsorshipPolicy, Intent, MaxAmountPerInterval, OnchainOperation, OperationSet, OperationStatus, StandardizedBalance, StandardizedToken } from "../types.js";
+export declare const extractAccountCluster: (accountCluster?: any) => AccountCluster;
+export declare const extractOperationSet: (operationSet?: any) => OperationSet;
+export declare const extractOnchainOperation: (onchainOperation?: any) => OnchainOperation;
+export declare const extractIntent: (intent?: any) => Intent;
+export declare const extractOperationStatuses: (operationStatus?: any[]) => OperationStatus[];
+export declare const extractOperationStatus: (status?: any) => OperationStatus;
+export declare const extractActivities: (activities?: any[]) => Activity[];
+export declare const extractFungibleTokenOverview: (overview?: any) => FungibleTokenOverview;
+export declare const extractStandardizedBalances: (balances?: any) => StandardizedBalance[];
+export declare const extractStandardizedBalance: (balance?: any) => StandardizedBalance;
+export declare const extractStandardizedTokens: (tokens?: any) => StandardizedToken[];
+export declare const extractStandardizedToken: (token?: any) => StandardizedToken;
+export declare const extractBlockchainInformations: (blockchainInformation?: any[]) => BlockchainInformation[];
+export declare const extractBlockchainInformation: (blockchainInformation?: any) => BlockchainInformation;
+export declare const extractMaxAmountPerInterval: (maxAmountPerInterval?: any) => MaxAmountPerInterval;
+export declare const extractAllowlistWithOpenFallback: (allowlist?: any) => AllowlistWithOpenFallback;
+export declare const extractGasSponsorshipPolicy: (gasSponsorshipPolicy?: any) => GasSponsorshipPolicy;
+export declare const extractGasSpendForInstances: (gasSpendForInstances?: any[]) => GasSpendForInstance[];
+export declare const extractGasSpendForInstance: (gasSpendForInstance?: any) => GasSpendForInstance;
+export declare const extractGasSponsorshipInformation: (gasSponsorshipData?: any[]) => GasSponsorshipData[];
+export declare const extractGasSponsorshipData: (gasSponsorshipData?: any) => GasSponsorshipData;

package/dist/esm/utils/utils.d.ts

@@ -0,0 +1,10 @@
+import { Blockchain } from "../enums.js";
+export declare const getChainIdFromOrbyChainId: (value: string) => bigint | undefined;
+export declare const getOrbyChainId: (chainId: bigint) => string;
+export declare const getBlockchainIdFromBlockchain: (blockchain: Blockchain) => number;
+export declare const hasError: (data: any) => {
+    code: number;
+    message: string;
+};
+export declare const getBlockchainFromName: (chainName: string) => Blockchain;
+export declare const isMainnet: (chainId: bigint) => boolean;

package/dist/esm/utils/validateAndParseAddress.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates an address and returns the parsed (checksummed) version of that address
+ * @param address the unchecksummed hex address
+ */
+export declare function validateAndParseAddress(address: string): string;
+/**
+ * Checks if an address is valid by checking 0x prefix, length === 42 and hex encoding.
+ * @param address the unchecksummed hex address
+ */
+export declare function checkValidAddress(address: string): string;