@orb-labs/orby-core 0.0.13 → 0.0.15

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

package/dist/esm/interfaces/application.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

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

package/dist/esm/interfaces/operation.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

package/dist/esm/types.d.ts

@@ -0,0 +1,152 @@
+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 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;
+};
+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/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,250 @@
+import { CreateOperationsStatus } from "../enums.js";
+import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { State } from "../entities/state.js";
+import { Currency } from "../entities/financial/currency.js";
+import { FungibleTokenAmount } from "../entities/financial/fungible_token_amount.js";
+import { FungibleToken } from "../entities/financial/fungible_token.js";
+import { Account } from "../entities/account.js";
+import { getChainIdFromOrbyChainId, hasError } from "./utils.js";
+export const extractAccountCluster = (accountCluster) => {
+    if (!accountCluster) {
+        return undefined;
+    }
+    else if (hasError(accountCluster)) {
+        console.error("[extractAccountCluster]", accountCluster.code, accountCluster.message);
+        return undefined;
+    }
+    return {
+        accountClusterId: accountCluster?.accountClusterId,
+        accounts: accountCluster?.accounts?.map((account) => Account.toAccount(account)),
+    };
+};
+export const extractOperationSet = (operationSet) => {
+    if (!operationSet) {
+        return undefined;
+    }
+    else if (hasError(operationSet)) {
+        console.error("[extractOperationSet]", operationSet);
+        return {
+            status: CreateOperationsStatus.INTERNAL,
+        };
+    }
+    return {
+        status: operationSet.status,
+        primaryOperation: extractOnchainOperation(operationSet.primaryOperation),
+        primaryOperationPreconditions: State.toState(operationSet.primaryOperationPreconditions),
+        inputState: State.toState(operationSet.inputState),
+        outputState: State.toState(operationSet.outputState),
+        intents: operationSet.intents?.map((intent) => extractIntent(intent)),
+        aggregateNetworkFeeInFiatCurrency: CurrencyAmount.toCurrencyAmount(operationSet.aggregateNetworkFeeInFiatCurrency),
+        aggregateOperationFeeInFiatCurrency: CurrencyAmount.toCurrencyAmount(operationSet.aggregateOperationFeeInFiatCurrency),
+        aggregateEstimatedTimeInMs: operationSet.aggregateEstimatedTimeInMs,
+    };
+};
+export const extractOnchainOperation = (onchainOperation) => {
+    if (!onchainOperation) {
+        return undefined;
+    }
+    return {
+        chainId: getChainIdFromOrbyChainId(onchainOperation.chainId),
+        data: onchainOperation.data,
+        estimatedNetworkFees: CurrencyAmount.toCurrencyAmount(onchainOperation.estimatedNetworkFees),
+        estimatedNetworkFeesInFiatCurrency: CurrencyAmount.toCurrencyAmount(onchainOperation.estimatedNetworkFeesInFiatCurrency),
+        estimatedTimeInMs: onchainOperation.estimatedTimeInMs,
+        format: onchainOperation.format,
+        from: onchainOperation.from,
+        gasLimit: onchainOperation.gasLimit
+            ? BigInt(onchainOperation.gasLimit)
+            : undefined,
+        gasPrice: onchainOperation.gasPrice
+            ? BigInt(onchainOperation.gasPrice)
+            : undefined,
+        inputState: State.toState(onchainOperation.inputState),
+        maxFeePerGas: onchainOperation.maxFeePerGas
+            ? BigInt(onchainOperation.maxFeePerGas)
+            : undefined,
+        maxPriorityFeePerGas: onchainOperation.maxPriorityFeePerGas
+            ? BigInt(onchainOperation.maxPriorityFeePerGas)
+            : undefined,
+        nativeCurrency: Currency.toCurrency(onchainOperation.nativeCurrency),
+        nonce: onchainOperation.nonce ? BigInt(onchainOperation.nonce) : undefined,
+        outputState: State.toState(onchainOperation.outputState),
+        to: onchainOperation.to,
+        txRpcUrl: onchainOperation.txRpcUrl,
+        type: onchainOperation.type,
+        value: onchainOperation.value ? BigInt(onchainOperation.value) : undefined,
+    };
+};
+export const extractIntent = (intent) => {
+    if (!intent) {
+        return undefined;
+    }
+    return {
+        estimatedProtocolFees: FungibleTokenAmount.toFungibleTokenAmount(intent.estimatedProtocolFees),
+        estimatedProtocolFeesInFiatCurrency: CurrencyAmount.toCurrencyAmount(intent.estimatedProtocolFeesInFiatCurrency),
+        inputState: State.toState(intent.inputState),
+        intentOperations: intent.intentOperations.map((operation) => extractOnchainOperation(operation)),
+        outputState: State.toState(intent.outputState),
+    };
+};
+export const extractOperationStatuses = (operationStatus) => {
+    if (hasError(operationStatus)) {
+        console.error("Error ", operationStatus);
+        return undefined;
+    }
+    return operationStatus?.map((status) => extractOperationStatus(status));
+};
+export const extractOperationStatus = (status) => {
+    if (!status) {
+        return undefined;
+    }
+    return {
+        blockHash: status.blockHash,
+        blockNumber: status.blockNumber ? BigInt(status.blockNumber) : undefined,
+        chainId: status.chainId
+            ? getChainIdFromOrbyChainId(status.chainId)
+            : undefined,
+        errorReason: status.errorReason,
+        hash: status.hash,
+        id: status.id,
+        status: status.status,
+        type: status.type,
+    };
+};
+export const extractActivities = (activities) => {
+    if (!activities) {
+        return undefined;
+    }
+    return activities.map((activity) => {
+        return {
+            aggregateFiatValueOfInputState: CurrencyAmount.toCurrencyAmount(activity.aggregateFiatValueOfInputState),
+            aggregateFiatValueOfOutputState: CurrencyAmount.toCurrencyAmount(activity.aggregateFiatValueOfOutputState),
+            aggregateNetworkFeesInFiatCurrency: CurrencyAmount.toCurrencyAmount(activity.aggregateNetworkFeesInFiatCurrency),
+            aggregateProtocolFeesInFiatCurrency: CurrencyAmount.toCurrencyAmount(activity.aggregateProtocolFeesInFiatCurrency),
+            category: activity.category,
+            initiateAt: activity.initiateAt,
+            inputState: State.toState(activity.inputState),
+            operationStatuses: extractOperationStatuses(activity.operationStatuses),
+            outputState: State.toState(activity.outputState),
+            overallStatus: activity.overallStatus,
+        };
+    });
+};
+export const extractFungibleTokenOverview = (overview) => {
+    if (!overview) {
+        return undefined;
+    }
+    else if (hasError(overview)) {
+        console.error("[extractFungibleTokenOverview]", overview.code, overview.message);
+        return undefined;
+    }
+    return {
+        tokenCount: overview.tokenCount,
+        hiddenTokenCount: overview.hiddenTokenCount,
+        totalValueInFiat: CurrencyAmount.toCurrencyAmount(overview.totalValueInFiat),
+    };
+};
+export const extractStandardizedBalances = (balances) => {
+    return balances?.map((balance) => extractStandardizedBalance(balance));
+};
+export const extractStandardizedBalance = (balance) => {
+    if (!balance) {
+        return undefined;
+    }
+    return {
+        standardizedTokenId: balance.standardizedTokenId,
+        tokenBalances: balance.tokenBalances.map((ft) => FungibleTokenAmount.toFungibleTokenAmount(ft)),
+        tokenBalancesOnChains: balance.tokenBalancesOnChains.map((ft) => FungibleTokenAmount.toFungibleTokenAmount(ft)),
+        total: CurrencyAmount.toCurrencyAmount(balance.total),
+        totalValueInFiat: CurrencyAmount.toCurrencyAmount(balance.totalValueInFiat),
+    };
+};
+export const extractStandardizedTokens = (tokens) => {
+    return tokens?.map((token) => extractStandardizedToken(token));
+};
+export const extractStandardizedToken = (token) => {
+    if (!token) {
+        return undefined;
+    }
+    return {
+        standardizedTokenId: token.standardizedTokenId,
+        currency: Currency.toCurrency(token.currency),
+        priceInFiat: CurrencyAmount.toCurrencyAmount(token.priceInFiat),
+        tokens: token.tokens.map((ft) => FungibleToken.toFungibleToken(ft)),
+    };
+};
+export const extractBlockchainInformations = (blockchainInformation) => {
+    return blockchainInformation?.map((info) => extractBlockchainInformation(info));
+};
+export const extractBlockchainInformation = (blockchainInformation) => {
+    if (!blockchainInformation) {
+        return undefined;
+    }
+    return {
+        chainId: getChainIdFromOrbyChainId(blockchainInformation.chainId),
+        environment: blockchainInformation.environment,
+        logoUrl: blockchainInformation.logoUrl,
+        name: blockchainInformation.name,
+    };
+};
+export const extractMaxAmountPerInterval = (maxAmountPerInterval) => {
+    if (!maxAmountPerInterval) {
+        return undefined;
+    }
+    return {
+        amount: maxAmountPerInterval.amount,
+        interval: {
+            amount: maxAmountPerInterval.interval.amount,
+            unit: maxAmountPerInterval.interval.unit,
+        },
+    };
+};
+export const extractAllowlistWithOpenFallback = (allowlist) => {
+    if (!allowlist) {
+        return undefined;
+    }
+    return {
+        tokenAllowlist: {
+            tokenAllowlistType: allowlist.tokenAllowlist.tokenAllowlistType,
+            sponsoredFunctions: allowlist.tokenAllowlist.sponsoredFunctions,
+        },
+        arbitraryContractAllowlist: allowlist.arbitraryContractAllowlist,
+    };
+};
+export const extractGasSponsorshipPolicy = (gasSponsorshipPolicy) => {
+    if (!gasSponsorshipPolicy) {
+        return undefined;
+    }
+    return {
+        maxTotalGasSpendForInstance: extractMaxAmountPerInterval(gasSponsorshipPolicy.maxTotalGasSpendForInstance),
+        maxGasSpendPerTransaction: gasSponsorshipPolicy.maxGasSpendPerTransaction,
+        allowlistWithOpenFallback: extractAllowlistWithOpenFallback(gasSponsorshipPolicy.allowlistWithOpenFallback),
+        maxTotalTransactionCountForInstance: extractMaxAmountPerInterval(gasSponsorshipPolicy.maxTotalTransactionCountForInstance),
+        maxTotalGasSpendPerUser: extractMaxAmountPerInterval(gasSponsorshipPolicy.maxTotalGasSpendPerUser),
+        maxTotalTransactionCountPerUser: extractMaxAmountPerInterval(gasSponsorshipPolicy.maxTotalTransactionCountPerUser),
+    };
+};
+export const extractGasSpendForInstances = (gasSpendForInstances) => {
+    return gasSpendForInstances?.map((data) => extractGasSpendForInstance(data));
+};
+export const extractGasSpendForInstance = (gasSpendForInstance) => {
+    if (!gasSpendForInstance) {
+        return;
+    }
+    return {
+        instanceName: gasSpendForInstance.instanceName,
+        gasSpentForInstance: extractGasSponsorshipData(gasSpendForInstance.gasSpentForInstance),
+    };
+};
+export const extractGasSponsorshipInformation = (gasSponsorshipData) => {
+    return gasSponsorshipData?.map((data) => extractGasSponsorshipData(data));
+};
+export const extractGasSponsorshipData = (gasSponsorshipData) => {
+    if (!gasSponsorshipData) {
+        return undefined;
+    }
+    return {
+        totalGasSpent: CurrencyAmount.toCurrencyAmount(gasSponsorshipData.totalGasSpent),
+        totalTransactionCount: gasSponsorshipData.totalTransactionCount,
+    };
+};

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;