@orb-labs/orby-core 0.0.13 → 0.0.15

package/dist/cjs/utils/utils.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMainnet = exports.getBlockchainFromName = exports.hasError = exports.getBlockchainIdFromBlockchain = exports.getOrbyChainId = exports.getChainIdFromOrbyChainId = void 0;
+const enums_js_1 = require("../enums.js");
+const constants_js_1 = require("../constants.js");
+const getChainIdFromOrbyChainId = (value) => {
+    let chainId = undefined;
+    const formattedValue = value?.trim()?.toLowerCase();
+    if (formattedValue?.includes("eip155")) {
+        const publicIdElements = formattedValue.split("eip155-");
+        const potentialId = publicIdElements?.length > 1 ? publicIdElements[1] : undefined;
+        chainId = !Number.isNaN(Number(potentialId))
+            ? BigInt(potentialId)
+            : undefined;
+    }
+    else {
+        const blockchain = (0, exports.getBlockchainFromName)(formattedValue);
+        const potentialId = blockchain
+            ? (0, exports.getBlockchainIdFromBlockchain)(blockchain)
+            : undefined;
+        chainId = potentialId ? BigInt(potentialId) : undefined;
+    }
+    return chainId;
+};
+exports.getChainIdFromOrbyChainId = getChainIdFromOrbyChainId;
+const getOrbyChainId = (chainId) => {
+    if (!chainId) {
+        return undefined;
+    }
+    return `EIP155-${chainId.toString()}`;
+};
+exports.getOrbyChainId = getOrbyChainId;
+const getBlockchainIdFromBlockchain = (blockchain) => {
+    return constants_js_1.BLOCKCHAIN_ID[blockchain];
+};
+exports.getBlockchainIdFromBlockchain = getBlockchainIdFromBlockchain;
+const hasError = (data) => {
+    if (data?.code && data?.message) {
+        return { code: data.code, message: data.message };
+    }
+    return undefined;
+};
+exports.hasError = hasError;
+const getBlockchainFromName = (chainName) => {
+    const formattedChainName = chainName?.toLowerCase()?.replace("-", "_");
+    switch (formattedChainName) {
+        case "bnbt": {
+            return enums_js_1.Blockchain.BINANCE_TESTNET;
+        }
+        case "matic_amoy": {
+            return enums_js_1.Blockchain.POLYGON_AMOY;
+        }
+        case "matic": {
+            return enums_js_1.Blockchain.POLYGON;
+        }
+        case "mainnet": {
+            return enums_js_1.Blockchain.ETHEREUM;
+        }
+        case "holesky": {
+            return enums_js_1.Blockchain.ETHEREUM_HOLESKY;
+        }
+        case "sepolia": {
+            return enums_js_1.Blockchain.ETHEREUM_SEPOLIA;
+        }
+        case "unknown": {
+            return undefined;
+        }
+        default: {
+            //statements;
+            return formattedChainName;
+        }
+    }
+};
+exports.getBlockchainFromName = getBlockchainFromName;
+const isMainnet = (chainId) => {
+    const blockchain = constants_js_1.BLOCKCHAIN_ID_TO_BLOCKCHAIN[Number(chainId)];
+    return constants_js_1.CHAIN_CONFIGS[blockchain].environment == enums_js_1.BlockchainEnvironment.MAINNET;
+};
+exports.isMainnet = isMainnet;

package/dist/cjs/utils/validateAndParseAddress.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validates an address and returns the parsed (checksummed) version of that address
+ * @param address the unchecksummed hex address
+ */
+export declare function validateAndParseAddress(address: string): string;
+/**
+ * Checks if an address is valid by checking 0x prefix, length === 42 and hex encoding.
+ * @param address the unchecksummed hex address
+ */
+export declare function checkValidAddress(address: string): string;

package/dist/cjs/utils/validateAndParseAddress.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndParseAddress = validateAndParseAddress;
+exports.checkValidAddress = checkValidAddress;
+const address_1 = require("@ethersproject/address");
+/**
+ * Validates an address and returns the parsed (checksummed) version of that address
+ * @param address the unchecksummed hex address
+ */
+function validateAndParseAddress(address) {
+    try {
+        return (0, address_1.getAddress)(address);
+    }
+    catch (error) {
+        throw new Error(`${address} is not a valid address.`);
+    }
+}
+// Checks a string starts with 0x, is 42 characters long and contains only hex characters after 0x
+const startsWith0xLen42HexRegex = /^0x[0-9a-fA-F]{40}$/;
+/**
+ * Checks if an address is valid by checking 0x prefix, length === 42 and hex encoding.
+ * @param address the unchecksummed hex address
+ */
+function checkValidAddress(address) {
+    if (startsWith0xLen42HexRegex.test(address)) {
+        return address;
+    }
+    throw new Error(`${address} is not a valid address.`);
+}

package/dist/esm/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/esm/actions/account_cluster.js

@@ -0,0 +1,207 @@
+import { extractAccountCluster, extractActivities, extractFungibleTokenOverview, extractStandardizedBalances, } from "../utils/action_helpers.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { getChainIdFromOrbyChainId, getOrbyChainId } from "../utils/utils.js";
+export class AccountClusterActions extends 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 extractAccountCluster(accountCluster);
+    }
+    async addToAccountCluster(accounts, accountClusterId) {
+        const formattedAccounts = accounts.map((account) => account.toAccountModel());
+        const accountCluster = await this.sendRequest("orby_addToAccountCluster", [
+            {
+                accounts: formattedAccounts,
+                accountClusterId,
+            },
+        ]);
+        return extractAccountCluster(accountCluster);
+    }
+    async removeFromAccountCluster(accounts, accountClusterId) {
+        const formattedAccounts = accounts.map((account) => account.toAccountModel());
+        const accountCluster = await this.sendRequest("orby_removeFromAccountCluster", [
+            {
+                accounts: formattedAccounts,
+                accountClusterId,
+            },
+        ]);
+        return 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: 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: 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) => 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: getChainIdFromOrbyChainId(endpoint.chainId),
+                customRpcUrls: endpoint.customRpcUrls,
+                customIndexerUrls: endpoint.customIndexerUrls,
+            };
+        });
+    }
+    async isChainSupportedOnAccountCluster(accountClusterId, chainId) {
+        const { supportStatus, message, code } = await this.sendRequest("orby_isChainSupportedOnAccountCluster", [
+            {
+                accountClusterId,
+                chainId: 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: 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: 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: extractActivities(edges), pageInfo };
+    }
+    async getPortfolioOverview(accountClusterId) {
+        const fungibleTokenOverview = await this.sendRequest("orby_getPortfolioOverview", [{ accountClusterId }]);
+        return 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 extractStandardizedBalances(fungibleTokenBalances);
+    }
+    async getFungibleTokenBalances(accountClusterId, offset, limit, chainId, tokensToOmit) {
+        const { fungibleTokenBalances, code, message } = await this.sendRequest("orby_getFungibleTokenBalances", [
+            {
+                accountClusterId,
+                offset,
+                limit,
+                chainId: chainId ? getOrbyChainId(chainId) : undefined,
+                tokensToOmit,
+            },
+        ]);
+        if (code && message) {
+            console.error("[getFungibleTokenBalances]", code, message);
+            return undefined;
+        }
+        return extractStandardizedBalances(fungibleTokenBalances);
+    }
+}

package/dist/esm/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/esm/actions/admin.js

@@ -0,0 +1,39 @@
+import { extractGasSpendForInstances, extractGasSponsorshipData, } from "../utils/action_helpers.js";
+import { LibraryRequest } from "../entities/library_request.js";
+export class AdminActions extends 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 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 extractGasSpendForInstances(totalGasSpendForInstances);
+    }
+}

package/dist/esm/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/esm/actions/application.js

@@ -0,0 +1,16 @@
+import { LibraryRequest } from "../entities/library_request.js";
+export class ApplicationActions extends 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;
+    }
+}

package/dist/esm/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/esm/actions/blockchain.js

@@ -0,0 +1,35 @@
+import { extractBlockchainInformation, extractBlockchainInformations, } from "../utils/action_helpers.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { getOrbyChainId } from "../utils/utils.js";
+export class BlockchainActions extends LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async getBlockchainInformation(chainId) {
+        const { blockchain, code, message } = await this.sendRequest("orby_getBlockchainInformation", [{ chainId: getOrbyChainId(chainId) }]);
+        if (code && message) {
+            console.error("[getBlockchainInformation]", code, message);
+            return undefined;
+        }
+        return 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: 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 extractBlockchainInformations(blockchains);
+    }
+}

package/dist/esm/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/esm/actions/instance.js

@@ -0,0 +1,94 @@
+import { extractGasSponsorshipPolicy } from "../utils/action_helpers.js";
+import { LibraryRequest } from "../entities/library_request.js";
+import { getChainIdFromOrbyChainId, getOrbyChainId } from "../utils/utils.js";
+export class InstanceActions extends LibraryRequest {
+    constructor(library, client, provider) {
+        super(library, client, provider);
+    }
+    async setCustomChainEndpointsForInstance(chainEndpoints) {
+        const formattedEndpoints = chainEndpoints.map((endpoint) => {
+            return {
+                chainId: 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) => 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: 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 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;
+    }
+}