@orb-labs/orby-core 0.0.3 → 0.0.5

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

@@ -1,4 +1,18 @@
-"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 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) {
@@ -8,140 +22,313 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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);
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
-    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);
-        });
+};
+import { extractAccountCluster, extractFungibleTokenOverview, extractStandardizedBalances, } from "../utils/action_helpers";
+import { LibraryRequest } from "../entities/library_request";
+import { getChainIdFromOrbyChainId } from "../utils/utils";
+var AccountClusterActions = /** @class */ (function (_super) {
+    __extends(AccountClusterActions, _super);
+    function AccountClusterActions(library, client, provider) {
+        return _super.call(this, library, client, provider) || this;
     }
-    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);
+    AccountClusterActions.prototype.createAccountCluster = function (accounts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedAccounts, accountCluster;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        formattedAccounts = accounts.map(function (account) {
+                            return account.toAccountModel();
+                        });
+                        return [4 /*yield*/, this.sendRequest("orby_createAccountCluster", [
+                                { accounts: formattedAccounts },
+                            ])];
+                    case 1:
+                        accountCluster = _a.sent();
+                        return [2 /*return*/, 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);
+    };
+    AccountClusterActions.prototype.addToAccountCluster = function (accounts, accountClusterId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedAccounts, accountCluster;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        formattedAccounts = accounts.map(function (account) {
+                            return account.toAccountModel();
+                        });
+                        return [4 /*yield*/, this.sendRequest("orby_addToAccountCluster", [
+                                { accounts: formattedAccounts, accountClusterId: accountClusterId },
+                            ])];
+                    case 1:
+                        accountCluster = _a.sent();
+                        return [2 /*return*/, extractAccountCluster(accountCluster)];
+                }
+            });
         });
-    }
-    enableChainAbstractionForAccountCluster(accountClusterId, enable) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { success } = yield this.sendRequest("orby_enableChainAbstractionForAccountCluster", [{ accountClusterId, enable }]);
-            return success;
+    };
+    AccountClusterActions.prototype.removeFromAccountCluster = function (accounts, accountClusterId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedAccounts, accountCluster;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        formattedAccounts = accounts.map(function (account) {
+                            return account.toAccountModel();
+                        });
+                        return [4 /*yield*/, this.sendRequest("orby_removeFromAccountCluster", [{ accounts: formattedAccounts, accountClusterId: accountClusterId }])];
+                    case 1:
+                        accountCluster = _a.sent();
+                        return [2 /*return*/, extractAccountCluster(accountCluster)];
+                }
+            });
         });
-    }
-    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,
-                };
+    };
+    AccountClusterActions.prototype.enableChainAbstractionForAccountCluster = function (accountClusterId, enable) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, success, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_enableChainAbstractionForAccountCluster", [{ accountClusterId: accountClusterId, enable: enable }])];
+                    case 1:
+                        _a = _b.sent(), success = _a.success, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[enableChainAbstractionForAccountCluster]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, success];
+                }
             });
-            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;
+    };
+    AccountClusterActions.prototype.setCustomChainEndpointsForAccountCluster = function (accountClusterId, chainEndpoints) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedEndpoints, _a, success, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        formattedEndpoints = chainEndpoints.map(function (endpoint) {
+                            return {
+                                chainId: "EIP155-".concat(endpoint.chainId),
+                                customRpcUrls: endpoint.customRpcUrls,
+                                customIndexerUrls: endpoint.customIndexerUrls,
+                            };
+                        });
+                        return [4 /*yield*/, this.sendRequest("orby_setCustomChainEndpointsForAccountCluster", [{ accountClusterId: accountClusterId, chainEndpoints: formattedEndpoints }])];
+                    case 1:
+                        _a = _b.sent(), success = _a.success, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[setCustomChainEndpointsForAccountCluster]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*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,
-                };
+    };
+    AccountClusterActions.prototype.removeCustomChainEndpointsForAccountCluster = function (accountClusterId, chainIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formattedChainIds, _a, success, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        formattedChainIds = chainIds.map(function (chainId) { return "EIP155-".concat(chainId); });
+                        return [4 /*yield*/, this.sendRequest("orby_removeCustomChainEndpointsForAccountCluster", [{ accountClusterId: accountClusterId, chainIds: formattedChainIds }])];
+                    case 1:
+                        _a = _b.sent(), success = _a.success, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[removeCustomChainEndpointsForAccountCluster]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, success];
+                }
             });
         });
-    }
-    isChainSupportedOnAccountCluster(accountClusterId, chainId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { supportStatus } = yield this.sendRequest("orby_isChainSupportedOnAccountCluster", [{ accountClusterId, chainId: `EIP155-${chainId}` }]);
-            return supportStatus;
+    };
+    AccountClusterActions.prototype.getCustomChainEndpointsForAccountCluster = function (accountClusterId, returnChainIdsOnly) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, chainEndpoints, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getCustomChainEndpointsForAccountCluster", [{ accountClusterId: accountClusterId, returnChainIdsOnly: returnChainIdsOnly }])];
+                    case 1:
+                        _a = _b.sent(), chainEndpoints = _a.chainEndpoints, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[getCustomChainEndpointsForAccountCluster]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, chainEndpoints.map(function (endpoint) {
+                                return {
+                                    chainId: getChainIdFromOrbyChainId(endpoint.chainId),
+                                    customRpcUrls: endpoint.customRpcUrls,
+                                    customIndexerUrls: endpoint.customIndexerUrls,
+                                };
+                            })];
+                }
+            });
         });
-    }
-    getNodeRpcUrl(accountClusterId, chainId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { nodeRpcUrl } = yield this.sendRequest("orby_getNodeRpcUrl", [
-                [{ accountClusterId, chainId: `EIP155-${chainId}` }],
-            ]);
-            return nodeRpcUrl;
+    };
+    AccountClusterActions.prototype.isChainSupportedOnAccountCluster = function (accountClusterId, chainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, supportStatus, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_isChainSupportedOnAccountCluster", [{ accountClusterId: accountClusterId, chainId: "EIP155-".concat(chainId) }])];
+                    case 1:
+                        _a = _b.sent(), supportStatus = _a.supportStatus, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[isChainSupportedOnAccountCluster]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, supportStatus];
+                }
+            });
         });
-    }
-    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;
+    };
+    AccountClusterActions.prototype.getNodeRpcUrl = function (accountClusterId, chainId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, nodeRpcUrl, code, message;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getNodeRpcUrl", [[{ accountClusterId: accountClusterId, chainId: "EIP155-".concat(chainId) }]])];
+                    case 1:
+                        _a = _b.sent(), nodeRpcUrl = _a.nodeRpcUrl, code = _a.code, message = _a.message;
+                        if (code && message) {
+                            console.error("[getNodeRpcUrl]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, nodeRpcUrl];
+                }
+            });
         });
-    }
-    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;
+    };
+    AccountClusterActions.prototype.getVirtualNodeRpcUrl = function (accountClusterId, chainId, entrypointAccountAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, virtualNodeRpcUrl, message, code;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getVirtualNodeRpcUrl", [
+                            {
+                                accountClusterId: accountClusterId,
+                                chainId: "EIP155-".concat(chainId),
+                                entrypointAccountAddress: entrypointAccountAddress,
+                            },
+                        ])];
+                    case 1:
+                        _a = _b.sent(), virtualNodeRpcUrl = _a.virtualNodeRpcUrl, message = _a.message, code = _a.code;
+                        if (code && message) {
+                            console.error("[getVirtualNodeRpcUrl]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*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);
+    };
+    AccountClusterActions.prototype.getActivity = function (accountClusterId, limit, offset, order, startDate, endDate, filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, virtualNodeRpcUrl, code, message;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getActivity", [
+                            [
+                                {
+                                    accountClusterId: accountClusterId,
+                                    limit: limit,
+                                    offset: offset,
+                                    order: order,
+                                    startDate: startDate,
+                                    endDate: endDate,
+                                    filters: filters,
+                                },
+                            ],
+                        ])];
+                    case 1:
+                        _a = _b.sent(), virtualNodeRpcUrl = _a.virtualNodeRpcUrl, code = _a.code, message = _a.message;
+                        if (code && message) {
+                            console.error("[getActivity]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, virtualNodeRpcUrl];
+                }
+            });
         });
-    }
-    getFungibleTokenPortfolio(accountClusterId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { fungibleTokenOverview } = yield this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId }]);
-            return (0, utils_1.extractFungibleTokenOverview)(fungibleTokenOverview);
+    };
+    AccountClusterActions.prototype.getPortfolioOverview = function (accountClusterId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fungibleTokenOverview;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getPortfolioOverview", [{ accountClusterId: accountClusterId }])];
+                    case 1:
+                        fungibleTokenOverview = _a.sent();
+                        return [2 /*return*/, 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);
+    };
+    AccountClusterActions.prototype.getFungibleTokenPortfolio = function (accountClusterId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, fungibleTokenBalances, code, message;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getFungibleTokenPortfolio", [{ accountClusterId: accountClusterId }])];
+                    case 1:
+                        _a = _b.sent(), fungibleTokenBalances = _a.fungibleTokenBalances, code = _a.code, message = _a.message;
+                        if (code && message) {
+                            console.error("[getFungibleTokenPortfolio]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, extractStandardizedBalances(fungibleTokenBalances)];
+                }
+            });
         });
-    }
-}
-exports.AccountClusterActions = AccountClusterActions;
+    };
+    AccountClusterActions.prototype.getFungibleTokenBalances = function (accountClusterId, offset, limit, tokensToOmit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, fungibleTokenBalances, code, message;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.sendRequest("orby_getFungibleTokenBalances", [{ accountClusterId: accountClusterId, offset: offset, limit: limit, tokensToOmit: tokensToOmit }])];
+                    case 1:
+                        _a = _b.sent(), fungibleTokenBalances = _a.fungibleTokenBalances, code = _a.code, message = _a.message;
+                        if (code && message) {
+                            console.error("[getFungibleTokenBalances]", code, message);
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/, extractStandardizedBalances(fungibleTokenBalances)];
+                }
+            });
+        });
+    };
+    return AccountClusterActions;
+}(LibraryRequest));
+export { AccountClusterActions };