@orb-labs/orby-core 0.0.15 → 0.0.16

package/dist/actions/admin.js

@@ -1,39 +0,0 @@
-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/actions/application.d.ts

@@ -1,6 +0,0 @@
-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/actions/application.js

@@ -1,16 +0,0 @@
-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/actions/blockchain.d.ts

@@ -1,16 +0,0 @@
-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/actions/blockchain.js

@@ -1,35 +0,0 @@
-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/actions/instance.d.ts

@@ -1,15 +0,0 @@
-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/actions/instance.js

@@ -1,94 +0,0 @@
-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;
-    }
-}

package/dist/actions/operation.d.ts

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

package/dist/actions/operation.js

@@ -1,341 +0,0 @@
-import { extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
-import { CurrencyAmount } from "../entities/financial/currency_amount.js";
-import { OperationStatusType, OperationType, } from "../enums.js";
-import { LibraryRequest } from "../entities/library_request.js";
-import { getOrbyChainId } from "../utils/utils.js";
-export class OperationActions extends LibraryRequest {
-    constructor(library, client, provider) {
-        super(library, client, provider);
-    }
-    async getOperationsToExecuteTransaction(accountClusterId, to, data, value, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const operationSet = await this.sendRequest("orby_getOperationsToExecuteTransaction", [
-            {
-                accountClusterId,
-                to,
-                data,
-                value,
-                gasToken: formattedGasToken,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async getOperationsToSignTypedData(accountClusterId, data, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [
-            {
-                accountClusterId,
-                data,
-                gasToken: formattedGasToken,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
-        const operationSet = await this.sendRequest("orby_getOperationsToCancelTransaction", [
-            {
-                accountClusterId,
-                operationSetId,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async isTransactionPreconditionSatisfied(accountClusterId, to, data, value) {
-        const { satisfied } = await this.sendRequest("orby_isTransactionPreconditionSatisfied", [
-            {
-                accountClusterId,
-                to,
-                data,
-                value,
-            },
-        ]);
-        return satisfied;
-    }
-    async isTypedDataPreconditionSatisfied(accountClusterId, data) {
-        const { satisfied, code, message } = await this.sendRequest("orby_isTypedDataPreconditionSatisfied", [
-            {
-                accountClusterId,
-                data,
-            },
-        ]);
-        if (code && message) {
-            console.error("[isTypedDataPreconditionSatisfied]", code, message);
-            return undefined;
-        }
-        return satisfied;
-    }
-    async sendSignedOperations(accountClusterId, signedOperations) {
-        const { operationSetId, operationResponses, code, message } = await this.sendRequest("orby_sendSignedOperations", [
-            {
-                accountClusterId,
-                signedOperations,
-            },
-        ]);
-        if (code && message) {
-            console.error("[sendSignedOperations]", code, message);
-            return undefined;
-        }
-        return {
-            operationSetId,
-            operationResponses: extractOperationStatuses(operationResponses),
-        };
-    }
-    async getOperationStatuses(operationIds) {
-        const { operationStatuses } = await this.sendRequest("orby_getOperationStatuses", [{ operationIds }]);
-        return extractOperationStatuses(operationStatuses);
-    }
-    async estimateFiatCostToExecuteTransaction(to, data, value) {
-        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToExecuteTransaction", [
-            {
-                to,
-                data,
-                value,
-            },
-        ]);
-        if (code && message) {
-            console.error("[estimateFiatCostToExecuteTransaction]", code, message);
-            return undefined;
-        }
-        return CurrencyAmount.toCurrencyAmount(estimatedCost);
-    }
-    async estimateFiatCostToSignTypedData(data) {
-        const { estimatedCost, code, message } = await this.sendRequest("orby_estimateFiatCostToSignTypedData", [{ data }]);
-        if (code && message) {
-            console.error("[estimateFiatCostToSignTypedData]", code, message);
-            return undefined;
-        }
-        return CurrencyAmount.toCurrencyAmount(estimatedCost);
-    }
-    async getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const formattedRecepient = {
-            chainId: getOrbyChainId(recipient.chainId),
-            recipientAddress: recipient.recipientAddress,
-        };
-        const operationSet = await this.sendRequest("orby_getOperationsToTransferToken", [
-            {
-                accountClusterId,
-                standardizedTokenId,
-                amount,
-                recipient: formattedRecepient,
-                gasToken: formattedGasToken,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async getOperationsToSwap(accountClusterId, swapType, input, output, gasToken) {
-        const formattedInput = input
-            ? {
-                ...input,
-                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const formattedOutput = output
-            ? {
-                ...output,
-                tokenDestination: output?.tokenDestination
-                    ? {
-                        chainId: getOrbyChainId(output.tokenDestination.chainId),
-                        address: output.tokenDestination.address,
-                    }
-                    : undefined,
-            }
-            : undefined;
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const operationSet = await this.sendRequest("orby_getOperationsToSwap", [
-            {
-                accountClusterId,
-                swapType,
-                input: formattedInput,
-                output: formattedOutput,
-                gasToken: formattedGasToken,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async getQuote(accountClusterId, swapType, input, output) {
-        const formattedInput = input
-            ? {
-                ...input,
-                tokenSources: input?.tokenSources.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const formattedOutput = output
-            ? {
-                ...output,
-                tokenDestination: output?.tokenDestination
-                    ? {
-                        chainId: getOrbyChainId(output.tokenDestination.chainId),
-                        address: output.tokenDestination.address,
-                    }
-                    : undefined,
-            }
-            : undefined;
-        const operationSet = await this.sendRequest("orby_getQuote", [
-            {
-                accountClusterId,
-                swapType,
-                input: formattedInput,
-                output: formattedOutput,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    async getOperationsToBridge(accountClusterId, standardizedTokenId, amount, tokenSources, tokenDestination, gasToken) {
-        const formattedTokenSources = tokenSources.map(({ chainId, address }) => ({
-            chainId: getOrbyChainId(chainId),
-            address,
-        }));
-        const formattedDestination = tokenDestination
-            ? {
-                chainId: getOrbyChainId(tokenDestination.chainId),
-                address: tokenDestination.address,
-            }
-            : undefined;
-        const formattedGasToken = gasToken
-            ? {
-                ...gasToken,
-                tokenSources: gasToken.tokenSources?.map(({ chainId, address }) => ({
-                    chainId: getOrbyChainId(chainId),
-                    address,
-                })),
-            }
-            : undefined;
-        const operationSet = await this.sendRequest("orby_getOperationsToBridge", [
-            {
-                accountClusterId,
-                standardizedTokenId,
-                amount,
-                tokenSources: formattedTokenSources,
-                tokenDestination: formattedDestination,
-                gasToken: formattedGasToken,
-            },
-        ]);
-        return extractOperationSet(operationSet);
-    }
-    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback, timout) {
-        let intervalId = null;
-        let totalWaitTime = 0;
-        const timeoutOrDefault = timout ?? 300_000;
-        if (ids && ids?.length > 0) {
-            const waitTime = 500;
-            intervalId = setInterval(async () => {
-                let statusSummary = OperationStatusType.WAITING_PRECONDITION;
-                let primaryOperation;
-                try {
-                    const statuses = ids && ids?.length > 0
-                        ? await this?.getOperationStatuses(ids)
-                        : undefined;
-                    if (!ids || ids?.length == 0) {
-                        statusSummary = OperationStatusType.NOT_FOUND;
-                    }
-                    else if (!statuses) {
-                        statusSummary = OperationStatusType.NOT_FOUND;
-                    }
-                    else if (statuses.some((status) => status.status == OperationStatusType.FAILED)) {
-                        statusSummary = OperationStatusType.FAILED;
-                    }
-                    else if (statuses.every((status) => status.status == OperationStatusType.SUCCESSFUL)) {
-                        statusSummary = OperationStatusType.SUCCESSFUL;
-                    }
-                    primaryOperation = statuses?.find((status) => status.type == OperationType.FINAL_TRANSACTION);
-                    if (primaryOperation?.status == OperationStatusType.PENDING) {
-                        statusSummary = OperationStatusType.PENDING;
-                    }
-                    onOperationStatusesUpdateCallback?.(statusSummary, primaryOperation, statuses);
-                }
-                catch (error) {
-                    console.error("[useWaitForStatusCompletion]", error);
-                }
-                finally {
-                    totalWaitTime += waitTime;
-                    if (intervalId &&
-                        OperationStatusType.WAITING_PRECONDITION != statusSummary) {
-                        clearInterval(intervalId);
-                        intervalId = null;
-                    }
-                    else if (intervalId && totalWaitTime >= timeoutOrDefault) {
-                        // we cant wait for more than 2 ETH blocks
-                        clearInterval(intervalId);
-                        intervalId = null;
-                    }
-                }
-            }, waitTime);
-        }
-        return { intervalId };
-    }
-    async sendOperationSet(accountClusterId, operationSet, signOperation) {
-        const signedOperations = [];
-        const operations = operationSet.intents
-            ?.map((intent) => intent.intentOperations)
-            .flat()
-            ?.concat(operationSet.primaryOperation)
-            .filter((value) => value != undefined && value != null);
-        if (operations?.length == 0) {
-            return { success: true, operationResponses: [] };
-        }
-        else if (!operations) {
-            return { success: false };
-        }
-        const hasPrimaryOperation = operations.find((operation) => operation.type == OperationType.FINAL_TRANSACTION);
-        if (!hasPrimaryOperation) {
-            return { success: false };
-        }
-        // Loop through all the operations and sign them
-        for (let i = 0; i < operations.length; i++) {
-            const signature = await signOperation(operations[i]);
-            if (!signature) {
-                return { success: false };
-            }
-            signedOperations.push(signature);
-        }
-        const { operationSetId, operationResponses } = await this.sendSignedOperations(accountClusterId, signedOperations);
-        return {
-            operationSetId,
-            operationResponses,
-            success: true,
-            primaryOperationStatus: {
-                type: OperationType.FINAL_TRANSACTION,
-                status: OperationStatusType.WAITING_PRECONDITION,
-            },
-        };
-    }
-}