@orb-labs/orby-core 0.0.2 → 0.0.4

package/README.md

@@ -1 +1,42 @@
-# rpc-core
+# Orby RPC SDK
+
+A generic library for the Custom RPC functions on the Orby. The library can be used with either the ethers library or with extensions to the viem library. It us used by our @orb-labs/orby-viem-extension, @orb-labs/orby-ethers5 and @orb-labs/orby-ethers6 libraries.
+
+Orby is an RPC-proxy that wraps around standard RPCs and extends their functionality to enable gas abstraction, gas sponsorship, and chain abstraction for any account (including EOAs) with just a few lines of code. Additionally, it allows wallets to monetize on any transaction from their users.
+
+## Development
+
+Run `yarn run dev`
+
+## Publishing to npm
+
+1. Bump the package.json version
+
+```
+// package.json
+version: "0.0.1" // change to "0.0.2"
+```
+
+2. Run yarn at the root of orby folder
+
+```
+yarn
+```
+
+3. Build
+
+```
+yarn workspace @orb-labs/orby-core build
+```
+
+4. Login to npm
+
+```
+yarn npm login
+```
+
+4. Publish @orb-labs/orby-core to npm
+
+```
+yarn workspace @orb-labs/orby-core npm publish --access public
+```

package/dist/actions/account_cluster.d.ts

@@ -19,6 +19,6 @@ export declare class AccountClusterActions extends LibraryRequest {
         address?: string;
     }[]): Promise<Activity[]>;
     getPortfolioOverview(accountClusterId: string): Promise<FungibleTokenOverview>;
-    getFungibleTokenPortfolio(accountClusterId: string): Promise<FungibleTokenOverview>;
+    getFungibleTokenPortfolio(accountClusterId: string): Promise<StandardizedBalance[]>;
     getFungibleTokenBalances(accountClusterId: string, offset?: number, limit?: number, tokensToOmit?: string[]): Promise<StandardizedBalance[]>;
 }

package/dist/actions/account_cluster.js

@@ -10,8 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AccountClusterActions = void 0;
-const utils_1 = require("../utils/utils");
+const action_helpers_1 = require("../utils/action_helpers");
 const library_request_1 = require("../entities/library_request");
+const utils_1 = require("../utils/utils");
 class AccountClusterActions extends library_request_1.LibraryRequest {
     constructor(library, client, provider) {
         super(library, client, provider);
@@ -22,7 +23,7 @@ class AccountClusterActions extends library_request_1.LibraryRequest {
             const accountCluster = yield this.sendRequest("orby_createAccountCluster", [
                 { accounts: formattedAccounts },
             ]);
-            return (0, utils_1.extractAccountCluster)(accountCluster);
+            return (0, action_helpers_1.extractAccountCluster)(accountCluster);
         });
     }
     addToAccountCluster(accounts, accountClusterId) {
@@ -31,19 +32,23 @@ class AccountClusterActions extends library_request_1.LibraryRequest {
             const accountCluster = yield this.sendRequest("orby_addToAccountCluster", [
                 { accounts: formattedAccounts, accountClusterId },
             ]);
-            return (0, utils_1.extractAccountCluster)(accountCluster);
+            return (0, action_helpers_1.extractAccountCluster)(accountCluster);
         });
     }
     removeFromAccountCluster(accounts, accountClusterId) {
         return __awaiter(this, void 0, void 0, function* () {
             const formattedAccounts = accounts.map((account) => account.toAccountModel());
             const accountCluster = yield this.sendRequest("orby_removeFromAccountCluster", [{ accounts: formattedAccounts, accountClusterId }]);
-            return (0, utils_1.extractAccountCluster)(accountCluster);
+            return (0, action_helpers_1.extractAccountCluster)(accountCluster);
         });
     }
     enableChainAbstractionForAccountCluster(accountClusterId, enable) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_enableChainAbstractionForAccountCluster", [{ accountClusterId, enable }]);
+            const { success, message, code } = yield this.sendRequest("orby_enableChainAbstractionForAccountCluster", [{ accountClusterId, enable }]);
+            if (code && message) {
+                console.error("[enableChainAbstractionForAccountCluster]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
@@ -56,20 +61,32 @@ class AccountClusterActions extends library_request_1.LibraryRequest {
                     customIndexerUrls: endpoint.customIndexerUrls,
                 };
             });
-            const { success } = yield this.sendRequest("orby_setCustomChainEndpointsForAccountCluster", [{ accountClusterId, chainEndpoints: formattedEndpoints }]);
+            const { success, message, code } = yield this.sendRequest("orby_setCustomChainEndpointsForAccountCluster", [{ accountClusterId, chainEndpoints: formattedEndpoints }]);
+            if (code && message) {
+                console.error("[setCustomChainEndpointsForAccountCluster]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     removeCustomChainEndpointsForAccountCluster(accountClusterId, chainIds) {
         return __awaiter(this, void 0, void 0, function* () {
             const formattedChainIds = chainIds.map((chainId) => `EIP155-${chainId}`);
-            const { success } = yield this.sendRequest("orby_removeCustomChainEndpointsForAccountCluster", [{ accountClusterId, chainIds: formattedChainIds }]);
+            const { success, message, code } = yield this.sendRequest("orby_removeCustomChainEndpointsForAccountCluster", [{ accountClusterId, chainIds: formattedChainIds }]);
+            if (code && message) {
+                console.error("[removeCustomChainEndpointsForAccountCluster]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     getCustomChainEndpointsForAccountCluster(accountClusterId, returnChainIdsOnly) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { chainEndpoints } = yield this.sendRequest("orby_getCustomChainEndpointsForAccountCluster", [{ accountClusterId, returnChainIdsOnly }]);
+            const { chainEndpoints, message, code } = yield this.sendRequest("orby_getCustomChainEndpointsForAccountCluster", [{ accountClusterId, returnChainIdsOnly }]);
+            if (code && message) {
+                console.error("[getCustomChainEndpointsForAccountCluster]", code, message);
+                return undefined;
+            }
             return chainEndpoints.map((endpoint) => {
                 return {
                     chainId: (0, utils_1.getChainIdFromOrbyChainId)(endpoint.chainId),
@@ -81,35 +98,43 @@ class AccountClusterActions extends library_request_1.LibraryRequest {
     }
     isChainSupportedOnAccountCluster(accountClusterId, chainId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { supportStatus } = yield this.sendRequest("orby_isChainSupportedOnAccountCluster", [{ accountClusterId, chainId: `EIP155-${chainId}` }]);
+            const { supportStatus, message, code } = yield this.sendRequest("orby_isChainSupportedOnAccountCluster", [{ accountClusterId, chainId: `EIP155-${chainId}` }]);
+            if (code && message) {
+                console.error("[isChainSupportedOnAccountCluster]", code, message);
+                return undefined;
+            }
             return supportStatus;
         });
     }
     getNodeRpcUrl(accountClusterId, chainId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { nodeRpcUrl } = yield this.sendRequest("orby_getNodeRpcUrl", [
-                [{ accountClusterId, chainId: `EIP155-${chainId}` }],
-            ]);
+            const { nodeRpcUrl, code, message } = yield this.sendRequest("orby_getNodeRpcUrl", [[{ accountClusterId, chainId: `EIP155-${chainId}` }]]);
+            if (code && message) {
+                console.error("[getNodeRpcUrl]", code, message);
+                return undefined;
+            }
             return nodeRpcUrl;
         });
     }
     getVirtualNodeRpcUrl(accountClusterId, chainId, entrypointAccountAddress) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { virtualNodeRpcUrl } = yield this.sendRequest("orby_getVirtualNodeRpcUrl", [
-                [
-                    {
-                        accountClusterId,
-                        chainId: `EIP155-${chainId}`,
-                        entrypointAccountAddress,
-                    },
-                ],
+            const { virtualNodeRpcUrl, message, code } = yield this.sendRequest("orby_getVirtualNodeRpcUrl", [
+                {
+                    accountClusterId,
+                    chainId: `EIP155-${chainId}`,
+                    entrypointAccountAddress,
+                },
             ]);
+            if (code && message) {
+                console.error("[getVirtualNodeRpcUrl]", code, message);
+                return undefined;
+            }
             return virtualNodeRpcUrl;
         });
     }
     getActivity(accountClusterId, limit, offset, order, startDate, endDate, filters) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { virtualNodeRpcUrl } = yield this.sendRequest("orby_getActivity", [
+            const { virtualNodeRpcUrl, code, message } = yield this.sendRequest("orby_getActivity", [
                 [
                     {
                         accountClusterId,
@@ -122,25 +147,37 @@ class AccountClusterActions extends library_request_1.LibraryRequest {
                     },
                 ],
             ]);
+            if (code && message) {
+                console.error("[getActivity]", code, message);
+                return undefined;
+            }
             return virtualNodeRpcUrl;
         });
     }
     getPortfolioOverview(accountClusterId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { fungibleTokenOverview } = yield this.sendRequest("orby_getPortfolioOverview", [{ accountClusterId }]);
-            return (0, utils_1.extractFungibleTokenOverview)(fungibleTokenOverview);
+            const fungibleTokenOverview = yield this.sendRequest("orby_getPortfolioOverview", [{ accountClusterId }]);
+            return (0, action_helpers_1.extractFungibleTokenOverview)(fungibleTokenOverview);
         });
     }
     getFungibleTokenPortfolio(accountClusterId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { fungibleTokenOverview } = yield this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId }]);
-            return (0, utils_1.extractFungibleTokenOverview)(fungibleTokenOverview);
+            const { fungibleTokenBalances, code, message } = yield this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId }]);
+            if (code && message) {
+                console.error("[getFungibleTokenPortfolio]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractStandardizedBalances)(fungibleTokenBalances);
         });
     }
     getFungibleTokenBalances(accountClusterId, offset, limit, tokensToOmit) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { fungibleTokenBalances } = yield this.sendRequest("orby_getFungibleTokenBalances", [{ accountClusterId, offset, limit, tokensToOmit }]);
-            return (0, utils_1.extractStandardizedBalances)(fungibleTokenBalances);
+            const { fungibleTokenBalances, code, message } = yield this.sendRequest("orby_getFungibleTokenBalances", [{ accountClusterId, offset, limit, tokensToOmit }]);
+            if (code && message) {
+                console.error("[getFungibleTokenBalances]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractStandardizedBalances)(fungibleTokenBalances);
         });
     }
 }

package/dist/actions/admin.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminActions = void 0;
-const utils_1 = require("../utils/utils");
+const action_helpers_1 = require("../utils/action_helpers");
 const library_request_1 = require("../entities/library_request");
 class AdminActions extends library_request_1.LibraryRequest {
     constructor(library, client, provider) {
@@ -18,24 +18,42 @@ class AdminActions extends library_request_1.LibraryRequest {
     }
     createInstance(name) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.sendRequest("orby_createInstance", [{ name }]);
+            const result = yield this.sendRequest("orby_createInstance", [{ name }]);
+            if (result.code && result.message) {
+                console.error("[createInstance]", result.code, result.message);
+                return undefined;
+            }
+            return result;
         });
     }
     getInstanceUrls(name) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.sendRequest("orby_getInstanceUrls", [{ name }]);
+            const result = yield this.sendRequest("orby_getInstanceUrls", [{ name }]);
+            if (result.code && result.message) {
+                console.error("[getInstanceUrls]", result.code, result.message);
+                return undefined;
+            }
+            return result;
         });
     }
     getGasSpentForCustomer(month, year) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { totalGasSpentForCustomer } = yield this.sendRequest("orby_getGasSpentForCustomer", [{ month, year }]);
-            return (0, utils_1.extractGasSponsorshipData)(totalGasSpentForCustomer);
+            const { totalGasSpentForCustomer, code, message } = yield this.sendRequest("orby_getGasSpentForCustomer", [{ month, year }]);
+            if (code && message) {
+                console.error("[getGasSpentForCustomer]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractGasSponsorshipData)(totalGasSpentForCustomer);
         });
     }
     getGasSpentForInstances(month, year, instanceNames) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { totalGasSpendForInstances } = yield this.sendRequest("orby_getGasSpentForInstances", [{ month, year, instanceNames }]);
-            return (0, utils_1.extractGasSpendForInstances)(totalGasSpendForInstances);
+            const { totalGasSpendForInstances, code, message } = yield this.sendRequest("orby_getGasSpentForInstances", [{ month, year, instanceNames }]);
+            if (code && message) {
+                console.error("[getGasSpentForInstances]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractGasSpendForInstances)(totalGasSpendForInstances);
         });
     }
 }

package/dist/actions/application.js

@@ -17,7 +17,13 @@ class ApplicationActions extends library_request_1.LibraryRequest {
     }
     isChainAbstractionCompatible(appDomainUrl) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { isChainAbstractionCompatible } = yield this.sendRequest("orby_isChainAbstractionCompatible", [{ appDomainUrl }]);
+            const { isChainAbstractionCompatible, code, message } = yield this.sendRequest("orby_isChainAbstractionCompatible", [
+                { appDomainUrl },
+            ]);
+            if (code && message) {
+                console.error("[isChainAbstractionCompatible]", code, message);
+                return undefined;
+            }
             return isChainAbstractionCompatible;
         });
     }

package/dist/actions/instance.js

@@ -10,8 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceActions = void 0;
-const utils_1 = require("../utils/utils");
+const action_helpers_1 = require("../utils/action_helpers");
 const library_request_1 = require("../entities/library_request");
+const utils_1 = require("../utils/utils");
 class InstanceActions extends library_request_1.LibraryRequest {
     constructor(library, client, provider) {
         super(library, client, provider);
@@ -25,20 +26,32 @@ class InstanceActions extends library_request_1.LibraryRequest {
                     customIndexerUrls: endpoint.customIndexerUrls,
                 };
             });
-            const { success } = yield this.sendRequest("orby_setCustomChainEndpointsForInstance", [{ chainEndpoints: formattedEndpoints }]);
+            const { success, code, message } = yield this.sendRequest("orby_setCustomChainEndpointsForInstance", [{ chainEndpoints: formattedEndpoints }]);
+            if (code && message) {
+                console.error("[setCustomChainEndpointsForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     removeCustomChainEndpointForInstance(chainIds) {
         return __awaiter(this, void 0, void 0, function* () {
             const formattedChainIds = chainIds.map((chainId) => `EIP155-${chainId}`);
-            const { success } = yield this.sendRequest("orby_removeCustomChainEndpointForInstance", [{ chainIds: formattedChainIds }]);
+            const { success, code, message } = yield this.sendRequest("orby_removeCustomChainEndpointForInstance", [{ chainIds: formattedChainIds }]);
+            if (code && message) {
+                console.error("[removeCustomChainEndpointForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     getCustomChainEndpointsForInstance(returnChainIdsOnly) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { chainEndpoints } = yield this.sendRequest("orby_getCustomChainEndpointsForInstance", [{ returnChainIdsOnly }]);
+            const { chainEndpoints, code, message } = yield this.sendRequest("orby_getCustomChainEndpointsForInstance", [{ returnChainIdsOnly }]);
+            if (code && message) {
+                console.error("[getCustomChainEndpointsForInstance]", code, message);
+                return undefined;
+            }
             return chainEndpoints.map((endpoint) => {
                 return {
                     chainId: (0, utils_1.getChainIdFromOrbyChainId)(endpoint.chainId),
@@ -50,43 +63,71 @@ class InstanceActions extends library_request_1.LibraryRequest {
     }
     getChainsSupportedByDefault() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { supportedChains } = yield this.sendRequest("orby_getChainsSupportedByDefault", [{}]);
-            return (0, utils_1.extractBlockchainInformations)(supportedChains);
+            const { supportedChains, code, message } = yield this.sendRequest("orby_getChainsSupportedByDefault", [{}]);
+            if (code && message) {
+                console.error("[getChainsSupportedByDefault]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractBlockchainInformations)(supportedChains);
         });
     }
     enabledChainAbstractionForInstance(enable) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_enabledChainAbstractionForInstance", [{ enable }]);
+            const { success, code, message } = yield this.sendRequest("orby_enabledChainAbstractionForInstance", [{ enable }]);
+            if (code && message) {
+                console.error("[enabledChainAbstractionForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     enableGasSponsorshipForInstance(enable) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_enableGasSponsorshipForInstance", [{ enable }]);
+            const { success, code, message } = yield this.sendRequest("orby_enableGasSponsorshipForInstance", [{ enable }]);
+            if (code && message) {
+                console.error("[enableGasSponsorshipForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     getGasSponsorForInstance() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { gasSponsor } = yield this.sendRequest("orby_getGasSponsorForInstance", [{}]);
+            const { gasSponsor, code, message } = yield this.sendRequest("orby_getGasSponsorForInstance", [{}]);
+            if (code && message) {
+                console.error("[getGasSponsorForInstance]", code, message);
+                return undefined;
+            }
             return gasSponsor;
         });
     }
     getOrbyGasSponsorPolicyForInstance() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { gasSponsorshipPolicy } = yield this.sendRequest("orby_getOrbyGasSponsorPolicyForInstance", [{}]);
-            return (0, utils_1.extractGasSponsorshipPolicy)(gasSponsorshipPolicy);
+            const { gasSponsorshipPolicy, message, code } = yield this.sendRequest("orby_getOrbyGasSponsorPolicyForInstance", [{}]);
+            if (code && message) {
+                console.error("[getOrbyGasSponsorPolicyForInstance]", code, message);
+                return undefined;
+            }
+            return (0, action_helpers_1.extractGasSponsorshipPolicy)(gasSponsorshipPolicy);
         });
     }
     setOrbyGasSponsorPolicyForInstance(gasSponsorshipPolicy) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_setOrbyGasSponsorPolicyForInstance", [Object.assign({}, gasSponsorshipPolicy)]);
+            const { success, code, message } = yield this.sendRequest("orby_setOrbyGasSponsorPolicyForInstance", [Object.assign({}, gasSponsorshipPolicy)]);
+            if (code && message) {
+                console.error("[setOrbyGasSponsorPolicyForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }
     removeOrbyGasSponsorPolicyForInstance() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_removeOrbyGasSponsorPolicyForInstance", [{}]);
+            const { success, code, message } = yield this.sendRequest("orby_removeOrbyGasSponsorPolicyForInstance", [{}]);
+            if (code && message) {
+                console.error("[removeOrbyGasSponsorPolicyForInstance]", code, message);
+                return undefined;
+            }
             return success;
         });
     }

package/dist/actions/operation.d.ts

@@ -1,12 +1,18 @@
-import { Operation, OperationStatus, SignedOperation } from "../types";
+import { OperationSet, OperationStatus, SignedOperation } from "../types";
 import { CurrencyAmount } from "../entities/financial/currency_amount";
 import { LIBRARY_TYPE, QuoteType } from "../enums";
 import { LibraryRequest } from "../entities/library_request";
 export declare class OperationActions extends LibraryRequest {
     constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
-    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: string): Promise<Operation[]>;
-    getOperationsToSignTypedData(accountClusterId: string, data: string): Promise<Operation[]>;
-    getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<Operation[]>;
+    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: bigint, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
+    getOperationsToSignTypedData(accountClusterId: string, data: string): Promise<OperationSet>;
+    getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<OperationSet>;
     isTransactionPreconditionSatisfied(accountClusterId: string, to: string, data: string, value?: string): Promise<boolean>;
     isTypedDataPreconditionSatisfied(accountClusterId: string, data: string): Promise<boolean>;
     sendSignedOperations(accountClusterId: string, signedOperations: SignedOperation[]): Promise<{
@@ -16,7 +22,7 @@ export declare class OperationActions extends LibraryRequest {
     getOperationStatuses(operationIds: string[]): Promise<OperationStatus[]>;
     estimateFiatCostToExecuteTransaction(to: string, data: string, value?: string): Promise<CurrencyAmount>;
     estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
-    getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: number, recipient: {
+    getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: bigint, recipient: {
         chainId: bigint;
         recipientAddress: string;
     }, gasToken?: {
@@ -25,17 +31,17 @@ export declare class OperationActions extends LibraryRequest {
             chainId: bigint;
             address?: string;
         }[];
-    }): Promise<Operation[]>;
+    }): Promise<OperationSet>;
     getOperationsToSwap(accountClusterId: string, swapType: QuoteType, input: {
         standardizedTokenId: string;
-        amount?: number;
+        amount?: bigint;
         tokenSources?: {
             chainId: string;
             address?: string;
         }[];
     }, output: {
         standardizedTokenId: string;
-        amount?: number;
+        amount?: bigint;
         tokenDestination?: {
             chainId: string;
             address?: string;
@@ -46,22 +52,22 @@ export declare class OperationActions extends LibraryRequest {
             chainId: bigint;
             address?: string;
         }[];
-    }): Promise<Operation[]>;
+    }): Promise<OperationSet>;
     getQuote(accountClusterId: string, swapType: QuoteType, input: {
         standardizedTokenId: string;
-        amount?: number;
+        amount?: bigint;
         tokenSources?: {
             chainId: string;
             address?: string;
         }[];
     }, output: {
         standardizedTokenId: string;
-        amount?: number;
+        amount?: bigint;
         tokenDestination?: {
             chainId: string;
             address?: string;
         };
-    }): Promise<Operation[]>;
+    }): Promise<OperationSet>;
     getOperationsToBridge(accountClusterId: string, standardizedTokenId: string, amount: bigint, tokenSources?: {
         chainId: string;
         address?: string;
@@ -74,5 +80,5 @@ export declare class OperationActions extends LibraryRequest {
             chainId: bigint;
             address?: string;
         }[];
-    }): Promise<Operation[]>;
+    }): Promise<OperationSet>;
 }