@orb-labs/orby-core 0.0.13 → 0.0.15

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ### Unreleased
 
+### 0.0.15
+
+- feat: support dual module format builds
+
+### 0.0.14
+
+- passing optional request timeout to subscribeToOperationStatuses
+- increase default timeout to 5 minutes
+
 ### 0.0.13
 
 - fixing types of returned values from the `getCustomChainEndpointsForAccountCluster` function

package/dist/actions/operation.d.ts

@@ -87,7 +87,7 @@ export declare class OperationActions extends LibraryRequest {
             address?: string;
         }[];
     }): Promise<OperationSet>;
-    subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void): {
+    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<{

package/dist/actions/operation.js

@@ -251,13 +251,15 @@ export class OperationActions extends LibraryRequest {
         ]);
         return extractOperationSet(operationSet);
     }
-    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback) {
+    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback, timout) {
         let intervalId = null;
         let totalWaitTime = 0;
+        const timeoutOrDefault = timout ?? 300_000;
         if (ids && ids?.length > 0) {
             const waitTime = 500;
             intervalId = setInterval(async () => {
                 let statusSummary = OperationStatusType.WAITING_PRECONDITION;
+                let primaryOperation;
                 try {
                     const statuses = ids && ids?.length > 0
                         ? await this?.getOperationStatuses(ids)
@@ -274,7 +276,7 @@ export class OperationActions extends LibraryRequest {
                     else if (statuses.every((status) => status.status == OperationStatusType.SUCCESSFUL)) {
                         statusSummary = OperationStatusType.SUCCESSFUL;
                     }
-                    const primaryOperation = statuses?.find((status) => status.type == OperationType.FINAL_TRANSACTION);
+                    primaryOperation = statuses?.find((status) => status.type == OperationType.FINAL_TRANSACTION);
                     if (primaryOperation?.status == OperationStatusType.PENDING) {
                         statusSummary = OperationStatusType.PENDING;
                     }
@@ -290,7 +292,7 @@ export class OperationActions extends LibraryRequest {
                         clearInterval(intervalId);
                         intervalId = null;
                     }
-                    else if (intervalId && totalWaitTime >= 60_000) {
+                    else if (intervalId && totalWaitTime >= timeoutOrDefault) {
                         // we cant wait for more than 2 ETH blocks
                         clearInterval(intervalId);
                         intervalId = null;

package/dist/cjs/actions/account_cluster.d.ts

@@ -0,0 +1,32 @@
+import { Account } from "../entities/account.js";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
+import { ChainSupportStatus, LIBRARY_TYPE, Order } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class AccountClusterActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    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/cjs/actions/account_cluster.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountClusterActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const library_request_js_1 = require("../entities/library_request.js");
+const utils_js_1 = require("../utils/utils.js");
+class AccountClusterActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async createAccountCluster(accounts) {
+        const formattedAccounts = accounts.map((account) => account.toAccountModel());
+        const accountCluster = await this.sendRequest("orby_createAccountCluster", [
+            {
+                accounts: formattedAccounts,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractAccountCluster)(accountCluster);
+    }
+    async addToAccountCluster(accounts, accountClusterId) {
+        const formattedAccounts = accounts.map((account) => account.toAccountModel());
+        const accountCluster = await this.sendRequest("orby_addToAccountCluster", [
+            {
+                accounts: formattedAccounts,
+                accountClusterId,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractAccountCluster)(accountCluster);
+    }
+    async removeFromAccountCluster(accounts, accountClusterId) {
+        const formattedAccounts = accounts.map((account) => account.toAccountModel());
+        const accountCluster = await this.sendRequest("orby_removeFromAccountCluster", [
+            {
+                accounts: formattedAccounts,
+                accountClusterId,
+            },
+        ]);
+        return (0, action_helpers_js_1.extractAccountCluster)(accountCluster);
+    }
+    async getVirtualNodeRpcUrlsForSupportedChains(accountClusterId) {
+        const { virtualNodeRpcUrlsForSupportedChains, message, code } = await this.sendRequest("orby_getVirtualNodeRpcUrlsForSupportedChains", [
+            {
+                accountClusterId,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getVirtualNodeRpcUrlsForSupportedChains]", code, message);
+            return undefined;
+        }
+        return virtualNodeRpcUrlsForSupportedChains.map((info) => {
+            return {
+                chainId: (0, utils_js_1.getChainIdFromOrbyChainId)(info.chainId),
+                virtualNodeRpcUrl: info.virtualNodeRpcUrl,
+                entrypointAccountAddress: info?.entrypointAccountAddress?.toLowerCase(),
+            };
+        });
+    }
+    async enableChainAbstractionForAccountCluster(accountClusterId, enable) {
+        const { success, message, code } = await this.sendRequest("orby_enableChainAbstractionForAccountCluster", [
+            {
+                accountClusterId,
+                enable,
+            },
+        ]);
+        if (code && message) {
+            console.error("[enableChainAbstractionForAccountCluster]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async setCustomChainEndpointsForAccountCluster(accountClusterId, chainEndpoints) {
+        const formattedEndpoints = chainEndpoints.map((endpoint) => {
+            return {
+                chainId: (0, utils_js_1.getOrbyChainId)(endpoint.chainId),
+                customRpcUrls: endpoint.customRpcUrls,
+                customIndexerUrls: endpoint.customIndexerUrls,
+            };
+        });
+        const { success, message, code } = await this.sendRequest("orby_setCustomChainEndpointsForAccountCluster", [
+            {
+                accountClusterId,
+                chainEndpoints: formattedEndpoints,
+            },
+        ]);
+        if (code && message) {
+            console.error("[setCustomChainEndpointsForAccountCluster]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async removeCustomChainEndpointsForAccountCluster(accountClusterId, chainIds) {
+        const formattedChainIds = chainIds.map((chainId) => (0, utils_js_1.getOrbyChainId)(chainId));
+        const { success, message, code } = await this.sendRequest("orby_removeCustomChainEndpointsForAccountCluster", [
+            {
+                accountClusterId,
+                chainIds: formattedChainIds,
+            },
+        ]);
+        if (code && message) {
+            console.error("[removeCustomChainEndpointsForAccountCluster]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async getCustomChainEndpointsForAccountCluster(accountClusterId, returnChainIdsOnly) {
+        const { chainEndpoints, message, code } = await this.sendRequest("orby_getCustomChainEndpointsForAccountCluster", [
+            {
+                accountClusterId,
+                returnChainIdsOnly,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getCustomChainEndpointsForAccountCluster]", code, message);
+            return undefined;
+        }
+        return chainEndpoints.map((endpoint) => {
+            return {
+                chainId: (0, utils_js_1.getChainIdFromOrbyChainId)(endpoint.chainId),
+                customRpcUrls: endpoint.customRpcUrls,
+                customIndexerUrls: endpoint.customIndexerUrls,
+            };
+        });
+    }
+    async isChainSupportedOnAccountCluster(accountClusterId, chainId) {
+        const { supportStatus, message, code } = await this.sendRequest("orby_isChainSupportedOnAccountCluster", [
+            {
+                accountClusterId,
+                chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+            },
+        ]);
+        if (code && message) {
+            console.error("[isChainSupportedOnAccountCluster]", code, message);
+            return undefined;
+        }
+        return supportStatus;
+    }
+    async getNodeRpcUrl(accountClusterId, chainId) {
+        const { nodeRpcUrl, code, message } = await this.sendRequest("orby_getNodeRpcUrl", [
+            {
+                accountClusterId,
+                chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+            },
+        ]);
+        if (code && message) {
+            console.error("[getNodeRpcUrl]", code, message);
+            return undefined;
+        }
+        return nodeRpcUrl;
+    }
+    async getVirtualNodeRpcUrl(accountClusterId, chainId, entrypointAccountAddress) {
+        const { virtualNodeRpcUrl, message, code } = await this.sendRequest("orby_getVirtualNodeRpcUrl", [
+            {
+                accountClusterId,
+                chainId: (0, utils_js_1.getOrbyChainId)(chainId),
+                entrypointAccountAddress,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getVirtualNodeRpcUrl]", code, message);
+            return undefined;
+        }
+        return virtualNodeRpcUrl;
+    }
+    async getActivity(accountClusterId, limit, offset, order, startDate, endDate, filters) {
+        const { pageInfo, edges, code, message } = await this.sendRequest("orby_getActivity", [
+            {
+                accountClusterId,
+                limit,
+                offset,
+                order,
+                startDate,
+                endDate,
+                filters,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getActivity]", code, message);
+            return undefined;
+        }
+        return { activities: (0, action_helpers_js_1.extractActivities)(edges), pageInfo };
+    }
+    async getPortfolioOverview(accountClusterId) {
+        const fungibleTokenOverview = await this.sendRequest("orby_getPortfolioOverview", [{ accountClusterId }]);
+        return (0, action_helpers_js_1.extractFungibleTokenOverview)(fungibleTokenOverview);
+    }
+    async getFungibleTokenPortfolio(accountClusterId) {
+        const { fungibleTokenBalances, code, message } = await this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId }]);
+        if (code && message) {
+            console.error("[getFungibleTokenPortfolio]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractStandardizedBalances)(fungibleTokenBalances);
+    }
+    async getFungibleTokenBalances(accountClusterId, offset, limit, chainId, tokensToOmit) {
+        const { fungibleTokenBalances, code, message } = await this.sendRequest("orby_getFungibleTokenBalances", [
+            {
+                accountClusterId,
+                offset,
+                limit,
+                chainId: chainId ? (0, utils_js_1.getOrbyChainId)(chainId) : undefined,
+                tokensToOmit,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getFungibleTokenBalances]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractStandardizedBalances)(fungibleTokenBalances);
+    }
+}
+exports.AccountClusterActions = AccountClusterActions;

package/dist/cjs/actions/admin.d.ts

@@ -0,0 +1,17 @@
+import { GasSpendForInstance, GasSponsorshipData } from "../types.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class AdminActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    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/actions/admin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const library_request_js_1 = require("../entities/library_request.js");
+class AdminActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async createInstance(name) {
+        const result = await this.sendRequest("orby_createInstance", [{ name }]);
+        if (result.code && result.message) {
+            console.error("[createInstance]", result.code, result.message);
+            return undefined;
+        }
+        return result;
+    }
+    async getInstanceUrls(name) {
+        const result = await this.sendRequest("orby_getInstanceUrls", [{ name }]);
+        if (result.code && result.message) {
+            console.error("[getInstanceUrls]", result.code, result.message);
+            return undefined;
+        }
+        return result;
+    }
+    async getGasSpentForCustomer(month, year) {
+        const { totalGasSpentForCustomer, code, message } = await this.sendRequest("orby_getGasSpentForCustomer", [{ month, year }]);
+        if (code && message) {
+            console.error("[getGasSpentForCustomer]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractGasSponsorshipData)(totalGasSpentForCustomer);
+    }
+    async getGasSpentForInstances(month, year, instanceNames) {
+        const { totalGasSpendForInstances, code, message } = await this.sendRequest("orby_getGasSpentForInstances", [{ month, year, instanceNames }]);
+        if (code && message) {
+            console.error("[getGasSpentForInstances]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractGasSpendForInstances)(totalGasSpendForInstances);
+    }
+}
+exports.AdminActions = AdminActions;

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

@@ -0,0 +1,6 @@
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class ApplicationActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    isChainAbstractionCompatible(appDomainUrl: string): Promise<boolean>;
+}

package/dist/cjs/actions/application.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationActions = void 0;
+const library_request_js_1 = require("../entities/library_request.js");
+class ApplicationActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async isChainAbstractionCompatible(appDomainUrl) {
+        const { isChainAbstractionCompatible, code, message } = await this.sendRequest("orby_isChainAbstractionCompatible", [
+            { appDomainUrl },
+        ]);
+        if (code && message) {
+            console.error("[isChainAbstractionCompatible]", code, message);
+            return undefined;
+        }
+        return isChainAbstractionCompatible;
+    }
+}
+exports.ApplicationActions = ApplicationActions;

package/dist/cjs/actions/blockchain.d.ts

@@ -0,0 +1,16 @@
+import { BlockchainInformation } from "../types.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { LIBRARY_TYPE } from "../enums.js";
+export declare class BlockchainActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getBlockchainInformation(chainId: bigint): Promise<BlockchainInformation>;
+    listBlockchainsInformation(offset?: number, limit?: number): Promise<{
+        blockchains: BlockchainInformation[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getChainsSupportedByDefault(): Promise<BlockchainInformation[]>;
+}

package/dist/cjs/actions/blockchain.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const library_request_js_1 = require("../entities/library_request.js");
+const utils_js_1 = require("../utils/utils.js");
+class BlockchainActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getBlockchainInformation(chainId) {
+        const { blockchain, code, message } = await this.sendRequest("orby_getBlockchainInformation", [{ chainId: (0, utils_js_1.getOrbyChainId)(chainId) }]);
+        if (code && message) {
+            console.error("[getBlockchainInformation]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractBlockchainInformation)(blockchain);
+    }
+    async listBlockchainsInformation(offset, limit) {
+        const { pageInfo, edges, code, message } = await this.sendRequest("orby_listBlockchainsInformation", [{ offset, limit }]);
+        if (code && message) {
+            console.error("[listBlockchainsInformation]", code, message);
+            return undefined;
+        }
+        return {
+            blockchains: (0, action_helpers_js_1.extractBlockchainInformations)(edges),
+            pageInfo,
+        };
+    }
+    async getChainsSupportedByDefault() {
+        const { blockchains, code, message } = await this.sendRequest("orby_getChainsSupportedByDefault", []);
+        if (code && message) {
+            console.error("[getChainsSupportedByDefault]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractBlockchainInformations)(blockchains);
+    }
+}
+exports.BlockchainActions = BlockchainActions;

package/dist/cjs/actions/instance.d.ts

@@ -0,0 +1,15 @@
+import { ChainEndpoint, GasSponsorshipPolicy } from "../types.js";
+import { LIBRARY_TYPE } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class InstanceActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    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/actions/instance.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceActions = void 0;
+const action_helpers_js_1 = require("../utils/action_helpers.js");
+const library_request_js_1 = require("../entities/library_request.js");
+const utils_js_1 = require("../utils/utils.js");
+class InstanceActions extends library_request_js_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async setCustomChainEndpointsForInstance(chainEndpoints) {
+        const formattedEndpoints = chainEndpoints.map((endpoint) => {
+            return {
+                chainId: (0, utils_js_1.getOrbyChainId)(endpoint.chainId),
+                customRpcUrls: endpoint.customRpcUrls,
+                customIndexerUrls: endpoint.customIndexerUrls,
+            };
+        });
+        const { success, code, message } = await this.sendRequest("orby_setCustomChainEndpointsForInstance", [{ chainEndpoints: formattedEndpoints }]);
+        if (code && message) {
+            console.error("[setCustomChainEndpointsForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async removeCustomChainEndpointForInstance(chainIds) {
+        const formattedChainIds = chainIds.map((chainId) => (0, utils_js_1.getOrbyChainId)(chainId));
+        const { success, code, message } = await this.sendRequest("orby_removeCustomChainEndpointForInstance", [{ chainIds: formattedChainIds }]);
+        if (code && message) {
+            console.error("[removeCustomChainEndpointForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async getCustomChainEndpointsForInstance(returnChainIdsOnly) {
+        const { chainEndpoints, code, message } = await this.sendRequest("orby_getCustomChainEndpointsForInstance", [{ returnChainIdsOnly }]);
+        if (code && message) {
+            console.error("[getCustomChainEndpointsForInstance]", code, message);
+            return undefined;
+        }
+        return chainEndpoints.map((endpoint) => {
+            return {
+                chainId: (0, utils_js_1.getChainIdFromOrbyChainId)(endpoint.chainId),
+                customRpcUrls: endpoint.customRpcUrls,
+                customIndexerUrls: endpoint.customIndexerUrls,
+            };
+        });
+    }
+    async enableChainAbstractionForInstance(enable) {
+        const { success, code, message } = await this.sendRequest("orby_enableChainAbstractionForInstance", [{ enable }]);
+        if (code && message) {
+            console.error("[enableChainAbstractionForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async enableGasSponsorshipForInstance(enable) {
+        const { success, code, message } = await this.sendRequest("orby_enableGasSponsorshipForInstance", [{ enable }]);
+        if (code && message) {
+            console.error("[enableGasSponsorshipForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async getGasSponsorForInstance() {
+        const { gasSponsor, code, message } = await this.sendRequest("orby_getGasSponsorForInstance", []);
+        if (code && message) {
+            console.error("[getGasSponsorForInstance]", code, message);
+            return undefined;
+        }
+        return gasSponsor;
+    }
+    async getOrbyGasSponsorPolicyForInstance() {
+        const { gasSponsorshipPolicy, message, code } = await this.sendRequest("orby_getOrbyGasSponsorPolicyForInstance", []);
+        if (code && message) {
+            console.error("[getOrbyGasSponsorPolicyForInstance]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractGasSponsorshipPolicy)(gasSponsorshipPolicy);
+    }
+    async setOrbyGasSponsorPolicyForInstance(gasSponsorshipPolicy) {
+        const { success, code, message } = await this.sendRequest("orby_setOrbyGasSponsorPolicyForInstance", [{ ...gasSponsorshipPolicy }]);
+        if (code && message) {
+            console.error("[setOrbyGasSponsorPolicyForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+    async removeOrbyGasSponsorPolicyForInstance() {
+        const { success, code, message } = await this.sendRequest("orby_removeOrbyGasSponsorPolicyForInstance", []);
+        if (code && message) {
+            console.error("[removeOrbyGasSponsorPolicyForInstance]", code, message);
+            return undefined;
+        }
+        return success;
+    }
+}
+exports.InstanceActions = InstanceActions;

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

@@ -0,0 +1,99 @@
+import { OnchainOperation, OperationSet, OperationStatus, SignedOperation } from "../types.js";
+import { CurrencyAmount } from "../entities/financial/currency_amount.js";
+import { LIBRARY_TYPE, OperationStatusType, QuoteType } from "../enums.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export declare class OperationActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: bigint, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToSignTypedData(accountClusterId: string, data: string, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<OperationSet>;
+    isTransactionPreconditionSatisfied(accountClusterId: string, to: string, data: string, value?: bigint): Promise<boolean>;
+    isTypedDataPreconditionSatisfied(accountClusterId: string, data: string): Promise<boolean>;
+    sendSignedOperations(accountClusterId: string, signedOperations: SignedOperation[]): Promise<{
+        operationSetId: string;
+        operationResponses: OperationStatus[];
+    }>;
+    getOperationStatuses(operationIds: string[]): Promise<OperationStatus[]>;
+    estimateFiatCostToExecuteTransaction(to: string, data: string, value?: bigint): Promise<CurrencyAmount>;
+    estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
+    getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: bigint, recipient: {
+        chainId: bigint;
+        recipientAddress: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToSwap(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenDestination?: {
+            chainId: bigint;
+            address?: string;
+        };
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getQuote(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: bigint;
+        tokenDestination?: {
+            chainId: bigint;
+            address?: string;
+        };
+    }): Promise<OperationSet>;
+    getOperationsToBridge(accountClusterId: string, standardizedTokenId: string, amount: bigint, tokenSources?: {
+        chainId: bigint;
+        address?: string;
+    }[], tokenDestination?: {
+        chainId: bigint;
+        address?: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void, timout?: number): {
+        intervalId: NodeJS.Timeout | null;
+    };
+    sendOperationSet(accountClusterId: string, operationSet: OperationSet, signOperation: (operation: OnchainOperation) => Promise<SignedOperation | undefined>): Promise<{
+        success: boolean;
+        operationSetId?: string;
+        primaryOperationStatus?: OperationStatus;
+        operationResponses?: OperationStatus[];
+    }>;
+}