@orb-labs/orby-core 0.0.13 → 0.0.15

package/dist/cjs/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/cjs/interfaces/admin.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/dist/cjs/interfaces/application.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/interfaces/blockchain.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/interfaces/instance.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/interfaces/operation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/interfaces/orby.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/utils/action_helpers.js

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

package/dist/cjs/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;