@orb-labs/orby-core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Orb Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# rpc-core

package/dist/actions/account_cluster.d.ts

@@ -0,0 +1,24 @@
+import { Account } from "../entities/account";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance } from "../types";
+import { ChainSupportStatus, LIBRARY_TYPE, Order } from "../enums";
+import { LibraryRequest } from "../entities/library_request";
+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>;
+    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<boolean>;
+    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<Activity[]>;
+    getPortfolioOverview(accountClusterId: string): Promise<FungibleTokenOverview>;
+    getFungibleTokenPortfolio(accountClusterId: string): Promise<FungibleTokenOverview>;
+    getFungibleTokenBalances(accountClusterId: string, offset?: number, limit?: number, tokensToOmit?: string[]): Promise<StandardizedBalance[]>;
+}

package/dist/actions/account_cluster.js

@@ -0,0 +1,147 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountClusterActions = void 0;
+const utils_1 = require("../utils/utils");
+const library_request_1 = require("../entities/library_request");
+class AccountClusterActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    createAccountCluster(accounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedAccounts = accounts.map((account) => account.toAccountModel());
+            const accountCluster = yield this.sendRequest("orby_createAccountCluster", [
+                { accounts: formattedAccounts },
+            ]);
+            return (0, utils_1.extractAccountCluster)(accountCluster);
+        });
+    }
+    addToAccountCluster(accounts, accountClusterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedAccounts = accounts.map((account) => account.toAccountModel());
+            const accountCluster = yield this.sendRequest("orby_addToAccountCluster", [
+                { accounts: formattedAccounts, accountClusterId },
+            ]);
+            return (0, utils_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);
+        });
+    }
+    enableChainAbstractionForAccountCluster(accountClusterId, enable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { success } = yield this.sendRequest("orby_enableChainAbstractionForAccountCluster", [{ accountClusterId, enable }]);
+            return success;
+        });
+    }
+    setCustomChainEndpointsForAccountCluster(accountClusterId, chainEndpoints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedEndpoints = chainEndpoints.map((endpoint) => {
+                return {
+                    chainId: `EIP155-${endpoint.chainId}`,
+                    customRpcUrls: endpoint.customRpcUrls,
+                    customIndexerUrls: endpoint.customIndexerUrls,
+                };
+            });
+            const { success } = yield this.sendRequest("orby_setCustomChainEndpointsForAccountCluster", [{ accountClusterId, chainEndpoints: formattedEndpoints }]);
+            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 }]);
+            return success;
+        });
+    }
+    getCustomChainEndpointsForAccountCluster(accountClusterId, returnChainIdsOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainEndpoints } = yield this.sendRequest("orby_getCustomChainEndpointsForAccountCluster", [{ accountClusterId, returnChainIdsOnly }]);
+            return chainEndpoints.map((endpoint) => {
+                return {
+                    chainId: (0, utils_1.getChainIdFromOrbyChainId)(endpoint.chainId),
+                    customRpcUrls: endpoint.customRpcUrls,
+                    customIndexerUrls: endpoint.customIndexerUrls,
+                };
+            });
+        });
+    }
+    isChainSupportedOnAccountCluster(accountClusterId, chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { supportStatus } = yield this.sendRequest("orby_isChainSupportedOnAccountCluster", [{ accountClusterId, chainId: `EIP155-${chainId}` }]);
+            return supportStatus;
+        });
+    }
+    getNodeRpcUrl(accountClusterId, chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { nodeRpcUrl } = yield this.sendRequest("orby_getNodeRpcUrl", [
+                [{ accountClusterId, chainId: `EIP155-${chainId}` }],
+            ]);
+            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,
+                    },
+                ],
+            ]);
+            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", [
+                [
+                    {
+                        accountClusterId,
+                        limit,
+                        offset,
+                        order,
+                        startDate,
+                        endDate,
+                        filters,
+                    },
+                ],
+            ]);
+            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);
+        });
+    }
+    getFungibleTokenPortfolio(accountClusterId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fungibleTokenOverview } = yield this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId }]);
+            return (0, utils_1.extractFungibleTokenOverview)(fungibleTokenOverview);
+        });
+    }
+    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);
+        });
+    }
+}
+exports.AccountClusterActions = AccountClusterActions;

package/dist/actions/admin.d.ts

@@ -0,0 +1,17 @@
+import { GasSpendForInstance, GasSponsorshipData } from "../types";
+import { LibraryRequest } from "../entities/library_request";
+import { LIBRARY_TYPE } from "../enums";
+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/actions/admin.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminActions = void 0;
+const utils_1 = require("../utils/utils");
+const library_request_1 = require("../entities/library_request");
+class AdminActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    createInstance(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sendRequest("orby_createInstance", [{ name }]);
+        });
+    }
+    getInstanceUrls(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.sendRequest("orby_getInstanceUrls", [{ name }]);
+        });
+    }
+    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);
+        });
+    }
+    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);
+        });
+    }
+}
+exports.AdminActions = AdminActions;

package/dist/actions/application.d.ts

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

package/dist/actions/application.js

@@ -0,0 +1,25 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationActions = void 0;
+const library_request_1 = require("../entities/library_request");
+class ApplicationActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    isChainAbstractionCompatible(appDomainUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { isChainAbstractionCompatible } = yield this.sendRequest("orby_isChainAbstractionCompatible", [{ appDomainUrl }]);
+            return isChainAbstractionCompatible;
+        });
+    }
+}
+exports.ApplicationActions = ApplicationActions;

package/dist/actions/instance.d.ts

@@ -0,0 +1,16 @@
+import { BlockchainInformation, ChainEndpoint, GasSponsorshipPolicy } from "../types";
+import { LIBRARY_TYPE } from "../enums";
+import { LibraryRequest } from "../entities/library_request";
+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>;
+    getChainsSupportedByDefault(): Promise<BlockchainInformation[]>;
+    enabledChainAbstractionForInstance(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/actions/instance.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceActions = void 0;
+const utils_1 = require("../utils/utils");
+const library_request_1 = require("../entities/library_request");
+class InstanceActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    setCustomChainEndpointsForInstance(chainEndpoints) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedEndpoints = chainEndpoints.map((endpoint) => {
+                return {
+                    chainId: `EIP155-${endpoint.chainId}`,
+                    customRpcUrls: endpoint.customRpcUrls,
+                    customIndexerUrls: endpoint.customIndexerUrls,
+                };
+            });
+            const { success } = yield this.sendRequest("orby_setCustomChainEndpointsForInstance", [{ chainEndpoints: formattedEndpoints }]);
+            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 }]);
+            return success;
+        });
+    }
+    getCustomChainEndpointsForInstance(returnChainIdsOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { chainEndpoints } = yield this.sendRequest("orby_getCustomChainEndpointsForInstance", [{ returnChainIdsOnly }]);
+            return chainEndpoints.map((endpoint) => {
+                return {
+                    chainId: (0, utils_1.getChainIdFromOrbyChainId)(endpoint.chainId),
+                    customRpcUrls: endpoint.customRpcUrls,
+                    customIndexerUrls: endpoint.customIndexerUrls,
+                };
+            });
+        });
+    }
+    getChainsSupportedByDefault() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { supportedChains } = yield this.sendRequest("orby_getChainsSupportedByDefault", [{}]);
+            return (0, utils_1.extractBlockchainInformations)(supportedChains);
+        });
+    }
+    enabledChainAbstractionForInstance(enable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { success } = yield this.sendRequest("orby_enabledChainAbstractionForInstance", [{ enable }]);
+            return success;
+        });
+    }
+    enableGasSponsorshipForInstance(enable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { success } = yield this.sendRequest("orby_enableGasSponsorshipForInstance", [{ enable }]);
+            return success;
+        });
+    }
+    getGasSponsorForInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { gasSponsor } = yield this.sendRequest("orby_getGasSponsorForInstance", [{}]);
+            return gasSponsor;
+        });
+    }
+    getOrbyGasSponsorPolicyForInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { gasSponsorshipPolicy } = yield this.sendRequest("orby_getOrbyGasSponsorPolicyForInstance", [{}]);
+            return (0, utils_1.extractGasSponsorshipPolicy)(gasSponsorshipPolicy);
+        });
+    }
+    setOrbyGasSponsorPolicyForInstance(gasSponsorshipPolicy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { success } = yield this.sendRequest("orby_setOrbyGasSponsorPolicyForInstance", [Object.assign({}, gasSponsorshipPolicy)]);
+            return success;
+        });
+    }
+    removeOrbyGasSponsorPolicyForInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { success } = yield this.sendRequest("orby_removeOrbyGasSponsorPolicyForInstance", [{}]);
+            return success;
+        });
+    }
+}
+exports.InstanceActions = InstanceActions;

package/dist/actions/operation.d.ts

@@ -0,0 +1,78 @@
+import { Operation, 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[]>;
+    isTransactionPreconditionSatisfied(accountClusterId: string, to: string, data: string, value?: string): 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?: string): Promise<CurrencyAmount>;
+    estimateFiatCostToSignTypedData(data: string): Promise<CurrencyAmount>;
+    getOperationsToTransferToken(accountClusterId: string, standardizedTokenId: string, amount: number, recipient: {
+        chainId: bigint;
+        recipientAddress: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<Operation[]>;
+    getOperationsToSwap(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: number;
+        tokenSources?: {
+            chainId: string;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: number;
+        tokenDestination?: {
+            chainId: string;
+            address?: string;
+        };
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<Operation[]>;
+    getQuote(accountClusterId: string, swapType: QuoteType, input: {
+        standardizedTokenId: string;
+        amount?: number;
+        tokenSources?: {
+            chainId: string;
+            address?: string;
+        }[];
+    }, output: {
+        standardizedTokenId: string;
+        amount?: number;
+        tokenDestination?: {
+            chainId: string;
+            address?: string;
+        };
+    }): Promise<Operation[]>;
+    getOperationsToBridge(accountClusterId: string, standardizedTokenId: string, amount: bigint, tokenSources?: {
+        chainId: string;
+        address?: string;
+    }[], tokenDestination?: {
+        chainId: string;
+        address?: string;
+    }, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<Operation[]>;
+}

package/dist/actions/operation.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationActions = void 0;
+const utils_1 = require("../utils/utils");
+const currency_amount_1 = require("../entities/financial/currency_amount");
+const library_request_1 = require("../entities/library_request");
+class OperationActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    getOperationsToExecuteTransaction(accountClusterId, to, data, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getOperationsToExecuteTransaction", [{ accountClusterId, to, data, value }]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+    getOperationsToSignTypedData(accountClusterId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getOperationsToSignTypedData", [{ accountClusterId, data }]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+    getOperationsToCancelTransaction(accountClusterId, operationSetId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { cancellationOperationSet } = yield this.sendRequest("orby_getOperationsToCancelTransaction", [{ accountClusterId, operationSetId }]);
+            return (0, utils_1.extractOperationSet)(cancellationOperationSet);
+        });
+    }
+    isTransactionPreconditionSatisfied(accountClusterId, to, data, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { satisfied } = yield this.sendRequest("orby_isTransactionPreconditionSatisfied", [{ accountClusterId, to, data, value }]);
+            return satisfied;
+        });
+    }
+    isTypedDataPreconditionSatisfied(accountClusterId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { satisfied } = yield this.sendRequest("orby_isTypedDataPreconditionSatisfied", [{ accountClusterId, data }]);
+            return satisfied;
+        });
+    }
+    sendSignedOperations(accountClusterId, signedOperations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSetId, operationResponses } = yield this.sendRequest("orby_sendSignedOperations", [{ accountClusterId, signedOperations }]);
+            return {
+                operationSetId,
+                operationResponses: (0, utils_1.extractOperationStatuses)(operationResponses),
+            };
+        });
+    }
+    getOperationStatuses(operationIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationStatuses } = yield this.sendRequest("orby_getOperationStatuses", [{ operationIds }]);
+            return (0, utils_1.extractOperationStatuses)(operationStatuses);
+        });
+    }
+    estimateFiatCostToExecuteTransaction(to, data, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { estimatedCost } = yield this.sendRequest("orby_estimateFiatCostToExecuteTransaction", [{ to, data, value }]);
+            return currency_amount_1.CurrencyAmount.toCurrencyAmount(estimatedCost);
+        });
+    }
+    estimateFiatCostToSignTypedData(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { estimatedCost } = yield this.sendRequest("orby_estimateFiatCostToSignTypedData", [{ data }]);
+            return currency_amount_1.CurrencyAmount.toCurrencyAmount(estimatedCost);
+        });
+    }
+    getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getOperationsToTransferToken", [{ accountClusterId, standardizedTokenId, amount, recipient, gasToken }]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+    getOperationsToSwap(accountClusterId, swapType, input, output, gasToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getOperationsToSwap", [{ accountClusterId, swapType, input, output, gasToken }]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+    getQuote(accountClusterId, swapType, input, output) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getQuote", [
+                { accountClusterId, swapType, input, output },
+            ]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+    getOperationsToBridge(accountClusterId, standardizedTokenId, amount, tokenSources, tokenDestination, gasToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { operationSet } = yield this.sendRequest("orby_getOperationsToBridge", [
+                {
+                    accountClusterId,
+                    standardizedTokenId,
+                    amount,
+                    tokenSources,
+                    tokenDestination,
+                    gasToken,
+                },
+            ]);
+            return (0, utils_1.extractOperationSet)(operationSet);
+        });
+    }
+}
+exports.OperationActions = OperationActions;

package/dist/actions/token.d.ts

@@ -0,0 +1,15 @@
+import { StandardizedToken } from "../types";
+import { LibraryRequest } from "../entities/library_request";
+import { LIBRARY_TYPE } from "../enums";
+export declare class TokenActions extends LibraryRequest {
+    constructor(library: LIBRARY_TYPE, client?: any, provider?: any);
+    getStandardizedTokenIds(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<string[]>;
+    getStandardizedTokens(tokens: {
+        tokenAddress: string;
+        chainId: bigint;
+    }[]): Promise<StandardizedToken[]>;
+    getFungibleTokenData(standardizedTokenIds: string[]): Promise<StandardizedToken>;
+}

package/dist/actions/token.js

@@ -0,0 +1,46 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenActions = void 0;
+const utils_1 = require("../utils/utils");
+const library_request_1 = require("../entities/library_request");
+class TokenActions extends library_request_1.LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    getStandardizedTokenIds(tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+                return { chainId: `EIP155-${chainId}`, tokenAddress };
+            });
+            const { standardizedTokenIds } = yield this.sendRequest("orby_getStandardizedTokenIds", [{ tokens: formattedTokensInfo }]);
+            return standardizedTokenIds;
+        });
+    }
+    getStandardizedTokens(tokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
+                return { chainId: `EIP155-${chainId}`, tokenAddress };
+            });
+            const { standardizedTokens } = yield this.sendRequest("orby_getStandardizedTokens", [{ tokens: formattedTokensInfo }]);
+            return (0, utils_1.extractStandardizedTokens)(standardizedTokens);
+        });
+    }
+    getFungibleTokenData(standardizedTokenIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.sendRequest("orby_getFungibleTokenData", [
+                { standardizedTokenIds },
+            ]);
+            return (0, utils_1.extractStandardizedToken)(data);
+        });
+    }
+}
+exports.TokenActions = TokenActions;