@orb-labs/orby-core 0.0.7 → 0.0.8

package/dist/actions/operation.js

@@ -1,28 +1,69 @@
 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 operationSet = await this.sendRequest("orby_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) {
-        const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [{ accountClusterId, data }]);
+        const operationSet = await this.sendRequest("orby_getOperationsToSignTypedData", [
+            {
+                accountClusterId,
+                data,
+            },
+        ]);
         return extractOperationSet(operationSet);
     }
     async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
-        const operationSet = await this.sendRequest("orby_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 }]);
+        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 }]);
+        const { satisfied, code, message } = await this.sendRequest("orby_isTypedDataPreconditionSatisfied", [
+            {
+                accountClusterId,
+                data,
+            },
+        ]);
         if (code && message) {
             console.error("[isTypedDataPreconditionSatisfied]", code, message);
             return undefined;
@@ -31,7 +72,10 @@ export class OperationActions extends LibraryRequest {
     }
     async sendSignedOperations(accountClusterId, signedOperations) {
         const { operationSetId, operationResponses, code, message } = await this.sendRequest("orby_sendSignedOperations", [
-            { accountClusterId, signedOperations },
+            {
+                accountClusterId,
+                signedOperations,
+            },
         ]);
         if (code && message) {
             console.error("[sendSignedOperations]", code, message);
@@ -47,7 +91,13 @@ export class OperationActions extends LibraryRequest {
         return extractOperationStatuses(operationStatuses);
     }
     async estimateFiatCostToExecuteTransaction(to, data, value) {
-        const { estimatedCost, code, message } = await this.sendRequest("orby_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;
@@ -63,32 +113,217 @@ export class OperationActions extends LibraryRequest {
         return CurrencyAmount.toCurrencyAmount(estimatedCost);
     }
     async getOperationsToTransferToken(accountClusterId, standardizedTokenId, amount, recipient, gasToken) {
-        const operationSet = await this.sendRequest("orby_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, output, gasToken },
+            {
+                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, output },
+            {
+                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,
-                tokenDestination,
-                gasToken,
+                tokenSources: formattedTokenSources,
+                tokenDestination: formattedDestination,
+                gasToken: formattedGasToken,
             },
         ]);
         return extractOperationSet(operationSet);
     }
+    subscribeToOperationStatuses(ids, onOperationStatusesUpdateCallback) {
+        let intervalId = null;
+        let totalWaitTime = 0;
+        if (ids && ids?.length > 0) {
+            const waitTime = 500;
+            intervalId = setInterval(async () => {
+                let statusSummary = OperationStatusType.WAITING_PRECONDITION;
+                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;
+                    }
+                    const 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 >= 60_000) {
+                        // 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,
+            },
+        };
+    }
 }

package/dist/actions/token.js

@@ -1,14 +1,19 @@
 import { extractStandardizedToken, extractStandardizedTokens, } from "../utils/action_helpers.js";
 import { LibraryRequest } from "../entities/library_request.js";
+import { getOrbyChainId } from "../utils/utils.js";
 export class TokenActions extends LibraryRequest {
     constructor(library, client, provider) {
         super(library, client, provider);
     }
     async getStandardizedTokenIds(tokens) {
         const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
-            return { chainId: `EIP155-${chainId}`, tokenAddress };
+            return { chainId: getOrbyChainId(chainId), tokenAddress };
         });
-        const { standardizedTokenIds, message, code } = await this.sendRequest("orby_getStandardizedTokenIds", [{ tokens: formattedTokensInfo }]);
+        const { standardizedTokenIds, message, code } = await this.sendRequest("orby_getStandardizedTokenIds", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
         if (code && message) {
             console.error("[getStandardizedTokenIds]", code, message);
             return undefined;
@@ -17,9 +22,13 @@ export class TokenActions extends LibraryRequest {
     }
     async getStandardizedTokens(tokens) {
         const formattedTokensInfo = tokens.map(({ tokenAddress, chainId }) => {
-            return { chainId: `EIP155-${chainId}`, tokenAddress };
+            return { chainId: getOrbyChainId(chainId), tokenAddress };
         });
-        const { standardizedTokens, message, code } = await this.sendRequest("orby_getStandardizedTokens", [{ tokens: formattedTokensInfo }]);
+        const { standardizedTokens, message, code } = await this.sendRequest("orby_getStandardizedTokens", [
+            {
+                tokens: formattedTokensInfo,
+            },
+        ]);
         if (code && message) {
             console.error("[getStandardizedTokens]", code, message);
             return undefined;

package/dist/entities/financial/fungible_token.d.ts

@@ -26,7 +26,7 @@ export declare class FungibleToken extends Currency {
      * @param name {@link Currency#name}
      * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
      */
-    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, bypassChecksum?: boolean, isNative?: boolean, coinGeckoId?: string);
+    constructor(chainId: bigint, address: string, decimals: number, symbol: string, name: string, bypassChecksum?: boolean, isNative?: boolean, coinGeckoId?: string, logoUrl?: string);
     /**
      * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
      * @param other other token to compare

package/dist/entities/financial/fungible_token.js

@@ -20,10 +20,10 @@ export class FungibleToken extends Currency {
      * @param name {@link Currency#name}
      * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
      */
-    constructor(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId) {
+    constructor(chainId, address, decimals, symbol, name, bypassChecksum, isNative, coinGeckoId, logoUrl) {
         // TODO(felix): add this back
         // invariant(!_.isUndefined(getBlockchainFromBlockchainId(chainId)), "CHAIN_ID");
-        super(decimals, symbol, name, undefined, isNative, true, coinGeckoId);
+        super(decimals, symbol, name, logoUrl, isNative, true, coinGeckoId);
         this.isToken = true;
         // TODO(felix): bypassChecksum is a little confusing since when bypassChecksum is true, we still validate the address
         // bypassChecksum is derived from the isNative parameter, so we should remove it and just check if isNative here

package/dist/index.d.ts

@@ -5,12 +5,14 @@ export * from "./interfaces/instance.js";
 export * from "./interfaces/operation.js";
 export * from "./interfaces/token.js";
 export * from "./interfaces/orby.js";
+export * from "./interfaces/blockchain.js";
 export * from "./actions/account_cluster.js";
 export * from "./actions/admin.js";
 export * from "./actions/application.js";
 export * from "./actions/instance.js";
 export * from "./actions/operation.js";
 export * from "./actions/token.js";
+export * from "./actions/blockchain.js";
 export * from "./entities/financial/account_balance.js";
 export * from "./entities/financial/asset.js";
 export * from "./entities/financial/currency_amount.js";

package/dist/index.js

@@ -6,6 +6,7 @@ export * from "./interfaces/instance.js";
 export * from "./interfaces/operation.js";
 export * from "./interfaces/token.js";
 export * from "./interfaces/orby.js";
+export * from "./interfaces/blockchain.js";
 // actions
 export * from "./actions/account_cluster.js";
 export * from "./actions/admin.js";
@@ -13,6 +14,7 @@ export * from "./actions/application.js";
 export * from "./actions/instance.js";
 export * from "./actions/operation.js";
 export * from "./actions/token.js";
+export * from "./actions/blockchain.js";
 // entities
 export * from "./entities/financial/account_balance.js";
 export * from "./entities/financial/asset.js";

package/dist/interfaces/account_cluster.d.ts

@@ -15,7 +15,14 @@ export interface IAccountClusterActions {
     getActivity(accountClusterId: string, limit?: number, offset?: number, order?: Order, startDate?: number, endDate?: number, filters?: {
         transactionHash?: string;
         address?: string;
-    }[]): Promise<Activity[]>;
+    }[]): 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/interfaces/blockchain.d.ts

@@ -0,0 +1,13 @@
+import { BlockchainInformation } from "../types.js";
+export interface IBlockchainActions {
+    getBlockchainInformation(chainId: bigint): Promise<BlockchainInformation>;
+    listBlockchainsInformation(offset?: number, limit?: number): Promise<{
+        blockchains: BlockchainInformation[];
+        pageInfo: {
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            totalCount: number;
+        };
+    }>;
+    getChainsSupportedByDefault(chainId: bigint): Promise<BlockchainInformation[]>;
+}

package/dist/interfaces/blockchain.js

@@ -0,0 +1 @@
+export {};

package/dist/interfaces/instance.d.ts

@@ -1,9 +1,8 @@
-import { BlockchainInformation, ChainEndpoint, GasSponsorshipPolicy } from "../types.js";
+import { ChainEndpoint, GasSponsorshipPolicy } from "../types.js";
 export interface IInstanceActions {
     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>;

package/dist/interfaces/operation.d.ts

@@ -1,8 +1,14 @@
-import { OperationSet, OperationStatus, SignedOperation } from "../types.js";
+import { OnchainOperation, OperationSet, OperationStatus, SignedOperation } from "../types.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
-import { QuoteType } from "../enums.js";
+import { OperationStatusType, QuoteType } from "../enums.js";
 export interface IOperationActions {
-    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: bigint): Promise<OperationSet>;
+    getOperationsToExecuteTransaction(accountClusterId: string, to: string, data: string, value?: bigint, gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
     getOperationsToSignTypedData(accountClusterId: string, data: string): Promise<OperationSet>;
     getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<OperationSet>;
     isTransactionPreconditionSatisfied(accountClusterId: string, to: string, data: string, value?: string): Promise<boolean>;
@@ -28,14 +34,14 @@ export interface IOperationActions {
         standardizedTokenId: string;
         amount?: bigint;
         tokenSources?: {
-            chainId: string;
+            chainId: bigint;
             address?: string;
         }[];
     }, output: {
         standardizedTokenId: string;
         amount?: bigint;
         tokenDestination?: {
-            chainId: string;
+            chainId: bigint;
             address?: string;
         };
     }, gasToken?: {
@@ -49,22 +55,22 @@ export interface IOperationActions {
         standardizedTokenId: string;
         amount?: bigint;
         tokenSources?: {
-            chainId: string;
+            chainId: bigint;
             address?: string;
         }[];
     }, output: {
         standardizedTokenId: string;
         amount?: bigint;
         tokenDestination?: {
-            chainId: string;
+            chainId: bigint;
             address?: string;
         };
     }): Promise<OperationSet>;
     getOperationsToBridge(accountClusterId: string, standardizedTokenId: string, amount: bigint, tokenSources?: {
-        chainId: string;
+        chainId: bigint;
         address?: string;
     }[], tokenDestination?: {
-        chainId: string;
+        chainId: bigint;
         address?: string;
     }, gasToken?: {
         standardizedTokenId: string;
@@ -73,4 +79,13 @@ export interface IOperationActions {
             address?: string;
         }[];
     }): Promise<OperationSet>;
+    subscribeToOperationStatuses(ids?: string[], onOperationStatusesUpdateCallback?: (statusSummary: OperationStatusType, primaryOperationStatus?: OperationStatus, allOperationStatuses?: OperationStatus[]) => void): {
+        intervalId: number | null;
+    };
+    sendOperationSet(accountClusterId: string, operationSet: OperationSet, signOperation: (operation: OnchainOperation) => Promise<SignedOperation | undefined>): Promise<{
+        success: boolean;
+        operationSetId?: string;
+        primaryOperationStatus?: OperationStatus;
+        operationResponses?: OperationStatus[];
+    }>;
 }

package/dist/interfaces/orby.d.ts

@@ -1,8 +1,9 @@
 import { IAccountClusterActions } from "./account_cluster.js";
 import { IAdminActions } from "./admin.js";
 import { IApplicationActions } from "./application.js";
+import { IBlockchainActions } from "./blockchain.js";
 import { IInstanceActions } from "./instance.js";
 import { IOperationActions } from "./operation.js";
 import { ITokenActions } from "./token.js";
-export interface Orby extends IAccountClusterActions, IAdminActions, IApplicationActions, IInstanceActions, IOperationActions, ITokenActions {
+export interface Orby extends IAccountClusterActions, IAdminActions, IApplicationActions, IInstanceActions, IOperationActions, ITokenActions, IBlockchainActions {
 }