@orb-labs/orby-core 0.0.26 → 0.0.28

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

@@ -1,4 +1,4 @@
-import { AccountCluster, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
+import { AccountCluster, Activity, 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";
@@ -32,6 +32,7 @@ export declare class OperationActions extends LibraryRequest {
         operationSetId: string;
         operationResponses: OperationStatus[];
     }>;
+    getOperationSet(operationSetId: string): Promise<Activity>;
     getOperationStatuses(operationIds: string[]): Promise<OperationStatus[]>;
     estimateFiatCostToExecuteTransaction(data: string, to?: string, value?: bigint): Promise<CurrencyAmount>;
     estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
@@ -94,6 +95,9 @@ export declare class OperationActions extends LibraryRequest {
             address?: string;
         }[];
     }): Promise<OperationSet>;
+    subscribeToOperationSetStatus(operationSetId?: string, onOperationSetStatusUpdateCallback?: (activity?: Activity) => void, timeout?: number): {
+        intervalId: NodeJS.Timeout | null;
+    };
     subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void, timout?: number): {
         intervalId: NodeJS.Timeout | null;
     };

package/dist/esm/actions/operation.js

@@ -1,6 +1,6 @@
-import { extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
+import { extractActivity, extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
-import { AccountType, OperationDataFormat, OperationStatusType, OperationType, } from "../enums.js";
+import { AccountType, ActivityStatus, OperationDataFormat, OperationStatusType, OperationType, } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
 import { Account } from "../entities/account.js";
 // from here: https://stackoverflow.com/questions/65152373/typescript-serialize-bigint-in-json
@@ -12,62 +12,35 @@ export class OperationActions extends LibraryRequest {
         super(library, client, provider);
     }
     async getOperationsToExecuteTransaction(accountClusterId, data, to, value, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const operationSet = await this.sendRequest("orby_getOperationsToExecuteTransaction", [
             {
                 accountClusterId,
                 to,
                 data,
                 value,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
     }
     async getOperationsToSignTypedData(accountClusterId, data, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [
             {
                 accountClusterId,
                 data,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
     }
     async getOperationsToSignTransactionOrSignTypedData(accountClusterId, data, to, value, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const operationSet = await this.sendRequest("orby_getOperationsToSignTransactionOrSignTypedData", [
             {
                 accountClusterId,
                 to,
                 data,
                 value,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
@@ -121,6 +94,14 @@ export class OperationActions extends LibraryRequest {
             operationResponses: extractOperationStatuses(operationResponses),
         };
     }
+    async getOperationSet(operationSetId) {
+        const { activity, code, message } = await this.sendRequest("orby_getOperationSet", [{ operationSetId }]);
+        if (code && message) {
+            console.error("[getOperationSet]", code, message);
+            return undefined;
+        }
+        return extractActivity(activity);
+    }
     async getOperationStatuses(operationIds) {
         const { operationStatuses } = await this.sendRequest("orby_getOperationStatuses", [{ operationIds }]);
         return extractOperationStatuses(operationStatuses);
@@ -148,15 +129,6 @@ export class OperationActions extends LibraryRequest {
         return CurrencyAmount.toCurrencyAmount(estimatedCost);
     }
     async getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const formattedRecepient = {
             chainId: await this.getOrbyChainId(recipient.chainId),
             address: recipient.address,
@@ -167,7 +139,7 @@ export class OperationActions extends LibraryRequest {
                 standardizedTokenId,
                 amount,
                 recipient: formattedRecepient,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
@@ -193,22 +165,13 @@ export class OperationActions extends LibraryRequest {
                     : undefined,
             }
             : undefined;
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const operationSet = await this.sendRequest("orby_getOperationsToSwap", [
             {
                 accountClusterId,
                 swapType,
                 input: formattedInput,
                 output: formattedOutput,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
@@ -255,15 +218,6 @@ export class OperationActions extends LibraryRequest {
                 address: tokenDestination.address,
             }
             : undefined;
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: await Promise.all(gasToken.tokenSources?.map(async ({ chainId, address }) => ({
-                    chainId: await this.getOrbyChainId(chainId),
-                    address,
-                }))),
-            }
-            : undefined;
         const operationSet = await this.sendRequest("orby_getOperationsToBridge", [
             {
                 accountClusterId,
@@ -271,11 +225,52 @@ export class OperationActions extends LibraryRequest {
                 amount,
                 tokenSources: formattedTokenSources,
                 tokenDestination: formattedDestination,
-                gasToken: formattedGasToken,
+                gasToken: await this.formatGasToken(gasToken),
             },
         ]);
         return extractOperationSet(operationSet);
     }
+    subscribeToOperationSetStatus(operationSetId, onOperationSetStatusUpdateCallback, timeout) {
+        let intervalId = null;
+        let totalWaitTime = 0;
+        const timeoutOrDefault = timeout ?? 300_000;
+        if (operationSetId) {
+            const waitTime = 500;
+            intervalId = setInterval(async () => {
+                let statusSummary = ActivityStatus.WAITING_PRECONDITION;
+                try {
+                    const activity = operationSetId
+                        ? await this?.getOperationSet(operationSetId)
+                        : undefined;
+                    if (activity) {
+                        statusSummary = activity?.overallStatus;
+                    }
+                    onOperationSetStatusUpdateCallback?.(activity);
+                }
+                catch (error) {
+                    console.error("[subscribeToOperationSetStatus]", error);
+                }
+                finally {
+                    totalWaitTime += waitTime;
+                    if (intervalId &&
+                        ![
+                            ActivityStatus.WAITING_TOKEN_APPROVAL_TRANSACTIONS,
+                            ActivityStatus.WAITING_GAS_ABSTRACTION,
+                            ActivityStatus.WAITING_PRECONDITION,
+                        ].includes(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 };
+    }
     subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback, timout) {
         let intervalId = null;
         let totalWaitTime = 0;
@@ -302,18 +297,25 @@ export class OperationActions extends LibraryRequest {
                         statusSummary = OperationStatusType.SUCCESSFUL;
                     }
                     primaryOperation = statuses?.find((status) => status.type == OperationType.FINAL_TRANSACTION);
-                    if (primaryOperation?.status == OperationStatusType.PENDING) {
-                        statusSummary = OperationStatusType.PENDING;
+                    if ([
+                        OperationStatusType.PENDING,
+                        OperationStatusType.SUCCESSFUL,
+                    ].includes(primaryOperation?.status)) {
+                        statusSummary = primaryOperation?.status;
                     }
                     onOperationStatusesUpdateCallback?.(statusSummary, primaryOperation, statuses);
                 }
                 catch (error) {
-                    console.error("[useWaitForStatusCompletion]", error);
+                    console.error("[subscribeToOperationStatuses]", error);
                 }
                 finally {
                     totalWaitTime += waitTime;
                     if (intervalId &&
-                        OperationStatusType.WAITING_PRECONDITION != statusSummary) {
+                        ![
+                            OperationStatusType.WAITING_TOKEN_APPROVAL_TRANSACTIONS,
+                            OperationStatusType.WAITING_GAS_ABSTRACTION,
+                            OperationStatusType.WAITING_PRECONDITION,
+                        ].includes(statusSummary)) {
                         clearInterval(intervalId);
                         intervalId = null;
                     }

package/dist/esm/constants.d.ts

@@ -1,9 +1,9 @@
 import { Currency } from "./entities/financial/currency.js";
-import { ChainConfigs } from "./types.js";
+import { BlockchainInformation } from "./types.js";
 export declare const Big: any;
 export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 export declare const ONE_ADDRESS = "0x0000000000000000000000000000000000000001";
 export declare const TWO_ADDRESS = "0x0000000000000000000000000000000000000002";
 export declare const NATIVE_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000";
-export declare const CHAIN_CONFIGS: Record<number, ChainConfigs>;
+export declare const CHAIN_CONFIGS: Record<number, BlockchainInformation>;
 export declare const FIAT_CURRENCY: Currency;

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

@@ -8,4 +8,17 @@ export declare class LibraryRequest {
     protected getOrbyChainId: (chainId: bigint) => Promise<string>;
     protected getVirtualEnvironment: (id: bigint) => Promise<VMType>;
     protected providerUrl(): string;
+    formatGasToken(gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<{
+        tokenSources: {
+            chainId: string;
+            address: string;
+        }[] | undefined;
+        standardizedTokenId: string;
+    } | undefined>;
 }

package/dist/esm/entities/library_request.js

@@ -67,4 +67,16 @@ export class LibraryRequest {
         const endIndex = url.indexOf(match[1]) + match[1].length;
         return url.slice(0, endIndex);
     }
+    async formatGasToken(gasToken) {
+        if (!gasToken) {
+            return undefined;
+        }
+        const tokenSources = gasToken.tokenSources
+            ? await Promise.all(gasToken.tokenSources.map(async ({ chainId, address }) => ({
+                chainId: await this.getOrbyChainId(chainId),
+                address,
+            })))
+            : undefined;
+        return { ...gasToken, tokenSources };
+    }
 }

package/dist/esm/enums.d.ts

@@ -48,11 +48,15 @@ export declare enum Category {
     TYPED_DATA_SIGNATURE = "TYPED_DATA_SIGNATURE"
 }
 export declare enum OperationStatusType {
+    CANCELLED = "CANCELLED",
     FAILED = "FAILED",
     NOT_FOUND = "NOT_FOUND",
     PENDING = "PENDING",
     SUCCESSFUL = "SUCCESSFUL",
-    WAITING_PRECONDITION = "WAITING_PRECONDITION"
+    WAITING_GAS_ABSTRACTION = "WAITING_GAS_ABSTRACTION",
+    WAITING_TOKEN_APPROVAL_TRANSACTIONS = "WAITING_TOKEN_APPROVAL_TRANSACTIONS",
+    WAITING_PRECONDITION = "WAITING_PRECONDITION",
+    WAITING_TIMEOUT = "WAITING_TIMEOUT"
 }
 export declare enum QuoteType {
     EXACT_INPUT = "EXACT_INPUT",
@@ -65,8 +69,13 @@ export declare enum Order {
 export declare enum ActivityStatus {
     CANCELLED = "CANCELLED",
     FAILED = "FAILED",
+    NOT_FOUND = "NOT_FOUND",
     PENDING = "PENDING",
-    SUCCESS = "SUCCESS"
+    SUCCESSFUL = "SUCCESSFUL",
+    WAITING_GAS_ABSTRACTION = "WAITING_GAS_ABSTRACTION",
+    WAITING_TOKEN_APPROVAL_TRANSACTIONS = "WAITING_TOKEN_APPROVAL_TRANSACTIONS",
+    WAITING_PRECONDITION = "WAITING_PRECONDITION",
+    WAITING_TIMEOUT = "WAITING_TIMEOUT"
 }
 export declare enum BlockchainEnvironment {
     MAINNET = "MAINNET",

package/dist/esm/enums.js

@@ -57,11 +57,15 @@ export var Category;
 })(Category || (Category = {}));
 export var OperationStatusType;
 (function (OperationStatusType) {
+    OperationStatusType["CANCELLED"] = "CANCELLED";
     OperationStatusType["FAILED"] = "FAILED";
     OperationStatusType["NOT_FOUND"] = "NOT_FOUND";
     OperationStatusType["PENDING"] = "PENDING";
     OperationStatusType["SUCCESSFUL"] = "SUCCESSFUL";
+    OperationStatusType["WAITING_GAS_ABSTRACTION"] = "WAITING_GAS_ABSTRACTION";
+    OperationStatusType["WAITING_TOKEN_APPROVAL_TRANSACTIONS"] = "WAITING_TOKEN_APPROVAL_TRANSACTIONS";
     OperationStatusType["WAITING_PRECONDITION"] = "WAITING_PRECONDITION";
+    OperationStatusType["WAITING_TIMEOUT"] = "WAITING_TIMEOUT";
 })(OperationStatusType || (OperationStatusType = {}));
 export var QuoteType;
 (function (QuoteType) {
@@ -77,8 +81,13 @@ export var ActivityStatus;
 (function (ActivityStatus) {
     ActivityStatus["CANCELLED"] = "CANCELLED";
     ActivityStatus["FAILED"] = "FAILED";
+    ActivityStatus["NOT_FOUND"] = "NOT_FOUND";
     ActivityStatus["PENDING"] = "PENDING";
-    ActivityStatus["SUCCESS"] = "SUCCESS";
+    ActivityStatus["SUCCESSFUL"] = "SUCCESSFUL";
+    ActivityStatus["WAITING_GAS_ABSTRACTION"] = "WAITING_GAS_ABSTRACTION";
+    ActivityStatus["WAITING_TOKEN_APPROVAL_TRANSACTIONS"] = "WAITING_TOKEN_APPROVAL_TRANSACTIONS";
+    ActivityStatus["WAITING_PRECONDITION"] = "WAITING_PRECONDITION";
+    ActivityStatus["WAITING_TIMEOUT"] = "WAITING_TIMEOUT";
 })(ActivityStatus || (ActivityStatus = {}));
 export var BlockchainEnvironment;
 (function (BlockchainEnvironment) {

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

@@ -1,4 +1,4 @@
-import { AccountCluster, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
+import { AccountCluster, Activity, 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 {
@@ -31,6 +31,7 @@ export interface IOperationActions {
         operationResponses: OperationStatus[];
     }>;
     getOperationStatuses(operationIds: string[]): Promise<OperationStatus[]>;
+    getOperationSet(operationSetId: string): Promise<Activity>;
     estimateFiatCostToExecuteTransaction(data: string, to?: string, value?: bigint): Promise<CurrencyAmount>;
     estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
     getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: bigint, recipient: {
@@ -95,6 +96,9 @@ export interface IOperationActions {
     subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void, timout?: number): {
         intervalId: NodeJS.Timeout | null;
     };
+    subscribeToOperationSetStatus(operationSetId?: string, onOperationSetStatusUpdateCallback?: (activity?: Activity) => 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;

package/dist/esm/types.d.ts

@@ -95,6 +95,8 @@ export type Activity = {
     aggregateNetworkFeesInFiatCurrency?: CurrencyAmount;
     aggregateProtocolFeesInFiatCurrency?: CurrencyAmount;
     category: Category;
+    gasTokenAmount?: FungibleTokenAmount;
+    gasTokenAmountInFiatCurrency?: CurrencyAmount;
     initiateAt?: Date;
     inputState?: State;
     operationStatuses: OperationStatus[];
@@ -120,10 +122,13 @@ export type StandardizedToken = {
     tokens: FungibleToken[];
 };
 export type BlockchainInformation = {
-    chainId: bigint;
     environment: BlockchainEnvironment;
-    logoUrl?: string;
-    name?: string;
+    chainId: bigint;
+    vmType: VMType;
+    logoUrl: string;
+    name: string;
+    genesisBlockHash?: string;
+    nativeCurrency: Currency;
 };
 export type ContractAllowlistWithAllMethodFallback = {
     contractAddress: string;
@@ -161,15 +166,6 @@ export type GasSponsorshipData = {
     totalGasSpent: CurrencyAmount;
     totalTransactionCount: bigint;
 };
-export type ChainConfigs = {
-    environment: BlockchainEnvironment;
-    chainId: bigint;
-    vmType: VMType;
-    logoUrl: string;
-    name: string;
-    genesisBlockHash?: string;
-    nativeCurrency: Currency;
-};
 export type VirtualNodeRpcUrlForSupportedChain = {
     chainId: string;
     entrypointAccountAddress: string;

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

@@ -6,13 +6,13 @@ 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 extractActivity: (activity?: 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;

package/dist/esm/utils/action_helpers.js

@@ -5,7 +5,7 @@ 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";
+import { extractBlockchainInformation, getChainIdFromOrbyChainId, hasError, notEmpty, } from "./utils.js";
 export const extractAccountCluster = (accountCluster) => {
     if (!accountCluster) {
         return undefined;
@@ -115,20 +115,26 @@ 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,
-        };
-    });
+    return activities
+        .map((activity) => extractActivity(activity))
+        .filter(notEmpty);
+};
+export const extractActivity = (activity) => {
+    if (!activity) {
+        return undefined;
+    }
+    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) {
@@ -176,17 +182,6 @@ export const extractStandardizedToken = (token) => {
 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;

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

@@ -3,7 +3,10 @@ import { Currency } from "../entities/financial/currency.js";
 import { FungibleToken } from "../entities/financial/fungible_token.js";
 import { FungibleTokenAmount } from "../entities/financial/fungible_token_amount.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { BlockchainInformation } from "../types.js";
+export declare const notEmpty: <T>(value: T) => value is NonNullable<T>;
 export declare const initializeBlockchainInformation: (orbyUrl: string) => Promise<void>;
+export declare const extractBlockchainInformation: (blockchainInformation?: any) => BlockchainInformation;
 export declare const getChainIdFromOrbyChainId: (value: string) => bigint | undefined;
 export declare const getVirtualEnvironment: (id: bigint) => Promise<VMType>;
 export declare const hasError: (data: any) => {

package/dist/esm/utils/utils.js

@@ -4,6 +4,8 @@ import { Currency } from "../entities/financial/currency.js";
 import { FungibleToken } from "../entities/financial/fungible_token.js";
 import { FungibleTokenAmount } from "../entities/financial/fungible_token_amount.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+// used to filter out null and undefined values: https://stackoverflow.com/questions/43118692/typescript-filter-out-nulls-from-an-array
+export const notEmpty = (value) => value != undefined && value != null;
 export const initializeBlockchainInformation = async (orbyUrl) => {
     const response = await fetch(orbyUrl, {
         method: "POST",
@@ -25,14 +27,24 @@ export const initializeBlockchainInformation = async (orbyUrl) => {
     result.edges?.map((blockchainInfo) => {
         const chainId = getChainIdFromOrbyChainId(blockchainInfo.chainId);
         if (chainId && blockchainInfo?.name) {
-            CHAIN_CONFIGS[Number(chainId)] = {
-                ...blockchainInfo,
-                chainId: chainId,
-                nativeCurrency: Currency.toCurrency(blockchainInfo?.nativeCurrency),
-            };
+            CHAIN_CONFIGS[Number(chainId)] =
+                extractBlockchainInformation(blockchainInfo);
         }
     });
 };
+export const extractBlockchainInformation = (blockchainInformation) => {
+    if (!blockchainInformation) {
+        return undefined;
+    }
+    return {
+        chainId: getChainIdFromOrbyChainId(blockchainInformation.chainId),
+        environment: blockchainInformation.environment,
+        logoUrl: blockchainInformation.logoUrl,
+        name: blockchainInformation.name,
+        vmType: blockchainInformation.vmType,
+        nativeCurrency: Currency.toCurrency(blockchainInformation.nativeCurrency),
+    };
+};
 export const getChainIdFromOrbyChainId = (value) => {
     let chainId = undefined;
     const formattedValue = validateAndLowerCase(value);