@orb-labs/orby-core 0.0.32 → 0.0.34

package/dist/esm/actions/operation.js

@@ -1,8 +1,10 @@
 import { extractActivity, extractOperationSet, extractOperationStatuses, } from "../utils/action_helpers.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
-import { AccountType, ActivityStatus, OperationDataFormat, OperationOrigin, OperationStatusType, OperationType, } from "../enums.js";
+import { AccountType, ActivityStatus, LIBRARY_TYPE, OperationDataFormat, OperationOrigin, OperationStatusType, OperationType, } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
 import { Account } from "../entities/account.js";
+import { createClient, http } from "viem";
+import { ethers } from "ethers";
 // from here: https://stackoverflow.com/questions/65152373/typescript-serialize-bigint-in-json
 BigInt.prototype.toJSON = function () {
     return this.toString();
@@ -46,6 +48,20 @@ export class OperationActions extends LibraryRequest {
         ]);
         return extractOperationSet(operationSet);
     }
+    async getOperationsForStablecoinAutoDepositSettings(accountClusterId, settings, gasToken) {
+        const formattedSettings = await Promise.all(settings.map(async (setting) => ({
+            ...setting,
+            chainId: await this.getOrbyChainId(setting.chainId),
+        })));
+        const operationSet = await this.sendRequest("orby_getOperationsForStablecoinAutoDepositSettings", [
+            {
+                accountClusterId,
+                settings: formattedSettings,
+                gasToken: await this.formatGasToken(gasToken),
+            },
+        ]);
+        return extractOperationSet(operationSet);
+    }
     async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
         const operationSet = await this.sendRequest("orby_getOperationsToCancelTransaction", [
             {
@@ -55,13 +71,17 @@ export class OperationActions extends LibraryRequest {
         ]);
         return extractOperationSet(operationSet);
     }
-    async isTransactionPreconditionSatisfied(accountClusterId, data, to, value) {
+    async isTransactionPreconditionSatisfied(accountClusterId, data, to, value, gasLimit, maxFeePerGas, maxPriorityFeePerGas, gasPrice) {
         const { satisfied } = await this.sendRequest("orby_isTransactionPreconditionSatisfied", [
             {
                 accountClusterId,
                 to,
                 data,
                 value,
+                gasLimit,
+                maxFeePerGas,
+                maxPriorityFeePerGas,
+                gasPrice,
             },
         ]);
         return satisfied;
@@ -83,7 +103,10 @@ export class OperationActions extends LibraryRequest {
         const { operationSetId, operationResponses, code, message } = await this.sendRequest("orby_sendSignedOperations", [
             {
                 accountClusterId,
-                signedOperations,
+                signedOperations: await Promise.all(signedOperations.map(async (signedOperation) => ({
+                    ...signedOperation,
+                    chainId: await this.getOrbyChainId(signedOperation.chainId),
+                }))),
             },
         ]);
         if (code && message) {
@@ -397,7 +420,7 @@ export class OperationActions extends LibraryRequest {
                 signature: signature,
                 data: operation.data,
                 from: operation.from,
-                chainId: await this.getOrbyChainId(operation.chainId),
+                chainId: operation.chainId,
             });
         }
         // batch sign all the smart contract transactions
@@ -427,7 +450,7 @@ export class OperationActions extends LibraryRequest {
                 signature: userOperation.signature,
                 data: JSON.stringify(userOperation),
                 from: transactions[0].from,
-                chainId: await this.getOrbyChainId(transactions[0].chainId),
+                chainId: transactions[0].chainId,
             });
         }
         const { operationSetId, operationResponses } = await this.sendSignedOperations(accountCluster.accountClusterId, signedOperations);
@@ -441,4 +464,162 @@ export class OperationActions extends LibraryRequest {
             },
         };
     }
+    async sendOperationSetWithLocalOrchestration(accountCluster, operationSet, sendTransaction, sendUserOperation, signTypedData, onCompletionCallback, onOperationSubmissionCallback, timeout) {
+        // 1. filter out all the operations that are not orby operations
+        const orbyOperations = operationSet.intents
+            ?.map((intent) => intent.intentOperations)
+            .flat()
+            ?.concat(operationSet.primaryOperation)
+            .filter((value) => (value != undefined && value != null) ||
+            value?.origin == OperationOrigin.EXTERNAL);
+        if (orbyOperations?.length == 0) {
+            onCompletionCallback?.([], OperationStatusType.SUCCESSFUL);
+            return;
+        }
+        else if (!orbyOperations) {
+            onCompletionCallback?.([], OperationStatusType.FAILED);
+            return;
+        }
+        // 2. group operations that can be sent in a single transaction together
+        const accountsMap = accountCluster.accounts.reduce((acc, account) => {
+            acc.set(account.key, account);
+            return acc;
+        }, new Map());
+        const smartAccountTransactions = orbyOperations.reduce((acc, operation) => {
+            const accountKey = Account.key(operation.from, operation.chainId);
+            const account = accountsMap.get(accountKey);
+            if (account?.type == AccountType.SCA &&
+                operation.format == OperationDataFormat.TRANSACTION) {
+                if (!acc.has(accountKey)) {
+                    acc.set(accountKey, []);
+                }
+                acc.get(accountKey).push(operation);
+            }
+            return acc;
+        }, new Map());
+        const groupedOperations = [];
+        for (let i = 0; i < orbyOperations.length; i++) {
+            const operation = orbyOperations[i];
+            if (operation.format == OperationDataFormat.TRANSACTION) {
+                const accountKey = Account.key(operation.from, operation.chainId);
+                const account = accountsMap.get(accountKey);
+                if (account?.type == AccountType.SCA) {
+                    continue;
+                }
+                else {
+                    groupedOperations.push([operation]);
+                }
+            }
+            else if (operation.format == OperationDataFormat.TYPED_DATA) {
+                groupedOperations.push([operation]);
+            }
+        }
+        // 3. group the operations that can be sent in a single transaction together
+        for (const accountKey of smartAccountTransactions.keys()) {
+            const transactions = smartAccountTransactions.get(accountKey);
+            transactions.sort((operationA, _) => {
+                if (operationA.type == OperationType.APPROVE_ERC20_TOKEN) {
+                    return -1;
+                }
+                return 0;
+            });
+            groupedOperations.push(transactions);
+        }
+        const timeoutOrDefault = timeout ?? 300_000;
+        const waitTime = 2000;
+        let intervalId = null;
+        let totalWaitTime = 0;
+        let isProcessing = false;
+        const hashedOperations = new Array(groupedOperations.length).fill(undefined);
+        // 3. send the operations in batches
+        intervalId = setInterval(async () => {
+            if (isProcessing) {
+                return;
+            }
+            try {
+                isProcessing = true;
+                const promises = groupedOperations.map(async (operations, index) => {
+                    if (hashedOperations[index]) {
+                        return;
+                    }
+                    const operation = operations[0];
+                    // create a new operation actions client for each operation
+                    let opsActions;
+                    if (this.library == LIBRARY_TYPE.VIEM) {
+                        opsActions = new OperationActions(LIBRARY_TYPE.VIEM, createClient({
+                            transport: http(operation.txRpcUrl),
+                        }), undefined);
+                    }
+                    else if (this.library == LIBRARY_TYPE.ETHERS) {
+                        opsActions = new OperationActions(LIBRARY_TYPE.ETHERS, undefined, new ethers.providers.JsonRpcProvider(operation.txRpcUrl));
+                    }
+                    if (operation.format === OperationDataFormat.TRANSACTION) {
+                        const isPreconditionSatisfied = await opsActions.isTransactionPreconditionSatisfied(accountCluster.accountClusterId, operation.data, operation.to, operation.value, operation.gasLimit, operation.maxFeePerGas, operation.maxPriorityFeePerGas, operation.gasPrice);
+                        if (isPreconditionSatisfied) {
+                            const accountKey = Account.key(operation.from, operation.chainId);
+                            const account = accountsMap.get(accountKey);
+                            if (account?.type == AccountType.SCA) {
+                                const hash = await sendUserOperation?.(operations, operation.from, operation.chainId, operation.txRpcUrl);
+                                onOperationSubmissionCallback?.(hash, OperationStatusType.PENDING, operations);
+                                hashedOperations[index] = {
+                                    operationId: hash,
+                                    status: OperationStatusType.SUCCESSFUL,
+                                    operations,
+                                };
+                            }
+                            else {
+                                const hash = await sendTransaction?.(operation);
+                                onOperationSubmissionCallback?.(hash, OperationStatusType.PENDING, operations);
+                                hashedOperations[index] = {
+                                    operationId: hash,
+                                    status: OperationStatusType.SUCCESSFUL,
+                                    operations,
+                                };
+                            }
+                        }
+                    }
+                    else if (operation.format === OperationDataFormat.TYPED_DATA) {
+                        const isPreconditionSatisfied = await opsActions.isTypedDataPreconditionSatisfied(accountCluster.accountClusterId, operation.data);
+                        if (isPreconditionSatisfied) {
+                            const signature = await signTypedData?.(operation);
+                            const sendOperation = await opsActions.sendSignedOperations(accountCluster.accountClusterId, [
+                                {
+                                    type: operation.type,
+                                    signature,
+                                    data: operation.data,
+                                    from: operation.from,
+                                    chainId: operation.chainId,
+                                },
+                            ]);
+                            onOperationSubmissionCallback?.(sendOperation.operationResponses[0].hash, OperationStatusType.SUCCESSFUL, operations);
+                            hashedOperations[index] = {
+                                operationId: sendOperation.operationResponses[0].hash,
+                                status: OperationStatusType.SUCCESSFUL,
+                                operations,
+                            };
+                        }
+                    }
+                });
+                await Promise.all(promises);
+                if (hashedOperations.every((result) => result)) {
+                    onCompletionCallback?.(hashedOperations, OperationStatusType.SUCCESSFUL);
+                    clearInterval(intervalId);
+                    intervalId = null;
+                }
+            }
+            catch (error) {
+                console.error("[sendOperationSetWithLocalOrchestration]", error);
+            }
+            finally {
+                isProcessing = false; // Reset processing flag
+                totalWaitTime += waitTime;
+                if (intervalId && totalWaitTime >= timeoutOrDefault) {
+                    onCompletionCallback?.(hashedOperations, OperationStatusType.WAITING_PRECONDITION);
+                    // we cant wait for more than 2 ETH blocks
+                    clearInterval(intervalId);
+                    intervalId = null;
+                }
+            }
+        }, waitTime);
+    }
 }

package/dist/esm/actions/token.d.ts

@@ -12,4 +12,5 @@ export declare class TokenActions extends LibraryRequest {
         chainId: bigint;
     }[]): Promise<StandardizedToken[]>;
     getFungibleTokenData(standardizedTokenIds: string[]): Promise<StandardizedToken[]>;
+    listAbstractableStablecoins(chainId?: bigint): Promise<StandardizedToken[]>;
 }

package/dist/esm/actions/token.js

@@ -44,4 +44,15 @@ export class TokenActions extends LibraryRequest {
         }
         return extractStandardizedTokens(data);
     }
+    async listAbstractableStablecoins(chainId) {
+        const orbyChainId = chainId
+            ? await this.getOrbyChainId(chainId)
+            : undefined;
+        const { stablecoins, message, code } = await this.sendRequest("orby_listAbstractableStablecoins", [{ chainId: orbyChainId }]);
+        if (code && message) {
+            console.error("[listAbstractableStablecoins]", code, message);
+            return undefined;
+        }
+        return extractStandardizedTokens(stablecoins);
+    }
 }

package/dist/esm/interfaces/account_cluster.d.ts

@@ -1,5 +1,5 @@
 import { Account } from "../entities/account.js";
-import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
+import { AccountCluster, Activity, ChainEndpoint, FungibleTokenOverview, StablecoinAutoDepositSettingsForAccount, StandardizedBalance, VirtualNodeRpcUrlForSupportedChain } from "../types.js";
 import { ChainSupportStatus, Order } from "../enums.js";
 export interface IAccountClusterActions {
     createAccountCluster(accounts: Account[]): Promise<AccountCluster>;
@@ -27,4 +27,5 @@ export interface IAccountClusterActions {
     getPortfolioOverview(accountClusterId: string): Promise<FungibleTokenOverview>;
     getFungibleTokenPortfolio(accountClusterId: string): Promise<StandardizedBalance[]>;
     getFungibleTokenBalances(accountClusterId: string, offset?: number, limit?: number, chainId?: bigint, tokensToOmit?: string[], standardizedTokenIds?: string[]): Promise<StandardizedBalance[]>;
+    getStablecoinAutoDepositSettingsForAccount(accountClusterId: string, account?: Account): Promise<StablecoinAutoDepositSettingsForAccount[]>;
 }

package/dist/esm/interfaces/operation.d.ts

@@ -1,4 +1,4 @@
-import { AccountCluster, Activity, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
+import { AccountCluster, Activity, MiniProgram, OnchainOperation, OperationSet, OperationStatus, SignedOperation, UserOperation } from "../types.js";
 import { CurrencyAmount } from "../entities/financial/currency_amount.js";
 import { OperationStatusType, QuoteType } from "../enums.js";
 export interface IOperationActions {
@@ -23,8 +23,23 @@ export interface IOperationActions {
             address?: string;
         }[];
     }, options?: Map<string, any>): Promise<OperationSet>;
+    getOperationsForStablecoinAutoDepositSettings(accountClusterId: string, settings: {
+        userStablecoins: {
+            stablecoinAddress: string;
+            targetPercentage: number;
+        }[];
+        chainId: bigint;
+        miniProgramHash: string;
+        miniProgram: MiniProgram;
+    }[], gasToken?: {
+        standardizedTokenId: string;
+        tokenSources?: {
+            chainId: bigint;
+            address?: string;
+        }[];
+    }): Promise<OperationSet>;
     getOperationsToCancelTransaction(accountClusterId: string, operationSetId: string): Promise<OperationSet>;
-    isTransactionPreconditionSatisfied(accountClusterId: string, data: string, to?: string, value?: bigint): Promise<boolean>;
+    isTransactionPreconditionSatisfied(accountClusterId: string, data: string, to?: string, value?: bigint, gasLimit?: bigint, maxFeePerGas?: bigint, maxPriorityFeePerGas?: bigint, gasPrice?: bigint): Promise<boolean>;
     isTypedDataPreconditionSatisfied(accountClusterId: string, data: string): Promise<boolean>;
     sendSignedOperations(accountClusterId: string, signedOperations: SignedOperation[]): Promise<{
         operationSetId: string;
@@ -105,4 +120,9 @@ export interface IOperationActions {
         primaryOperationStatus?: OperationStatus;
         operationResponses?: OperationStatus[];
     }>;
+    sendOperationSetWithLocalOrchestration(accountCluster: AccountCluster, operationSet: OperationSet, sendTransaction?: (operation: OnchainOperation) => Promise<string | undefined>, sendUserOperation?: (operations: OnchainOperation[], accountAddress: string, chainId: bigint, txRpcUrl: string) => Promise<string | undefined>, signTypedData?: (operation: OnchainOperation) => Promise<string | undefined>, onCompletionCallback?: (operationStatuses?: {
+        operationId: string;
+        status: OperationStatusType;
+        operations: OnchainOperation[];
+    }[], statusSummary?: OperationStatusType) => void, onOperationSubmissionCallback?: (operationId: string, status: OperationStatusType, operations: OnchainOperation[]) => void, timeout?: number): Promise<void>;
 }

package/dist/esm/interfaces/token.d.ts

@@ -9,4 +9,5 @@ export interface ITokenActions {
         chainId: bigint;
     }[]): Promise<StandardizedToken[]>;
     getFungibleTokenData(standardizedTokenIds: string[]): Promise<StandardizedToken[]>;
+    listAbstractableStablecoins(chainId?: bigint): Promise<StandardizedToken[]>;
 }

package/dist/esm/types.d.ts

@@ -79,7 +79,7 @@ export type SignedOperation = {
     category?: Category;
     data?: string;
     from?: string;
-    chainId?: string;
+    chainId?: bigint;
 };
 export type OperationStatus = {
     blockHash?: string;
@@ -173,3 +173,21 @@ export type VirtualNodeRpcUrlForSupportedChain = {
     entrypointAccountAddress: string;
     virtualNodeRpcUrl: string;
 };
+export type MiniProgram = {
+    verificationContract: string;
+    miniProgram: string;
+};
+export type StablecoinAutoDepositProportion = {
+    token: FungibleToken;
+    targetPercentage: number;
+};
+export type StablecoinAutoDepositPerChainUserStablecoinsSettings = {
+    userStablecoins: StablecoinAutoDepositProportion[];
+    chainId: bigint;
+    miniProgram: MiniProgram;
+    miniProgramHash: string;
+};
+export type StablecoinAutoDepositSettingsForAccount = {
+    account: Account;
+    settings: StablecoinAutoDepositPerChainUserStablecoinsSettings[];
+};

package/dist/esm/utils/action_helpers.d.ts

@@ -1,4 +1,4 @@
-import { AccountCluster, Activity, AllowlistWithOpenFallback, BlockchainInformation, FungibleTokenOverview, GasSpendForInstance, GasSponsorshipData, GasSponsorshipPolicy, Intent, MaxAmountPerInterval, OnchainOperation, OperationSet, OperationStatus, StandardizedBalance, StandardizedToken } from "../types.js";
+import { AccountCluster, Activity, AllowlistWithOpenFallback, BlockchainInformation, FungibleTokenOverview, GasSpendForInstance, GasSponsorshipData, GasSponsorshipPolicy, Intent, MaxAmountPerInterval, OnchainOperation, OperationSet, OperationStatus, StablecoinAutoDepositPerChainUserStablecoinsSettings, StablecoinAutoDepositProportion, StablecoinAutoDepositSettingsForAccount, StandardizedBalance, StandardizedToken } from "../types.js";
 export declare const extractAccountCluster: (accountCluster?: any) => AccountCluster;
 export declare const extractOperationSet: (operationSet?: any) => OperationSet;
 export declare const extractOnchainOperation: (onchainOperation?: any) => OnchainOperation;
@@ -20,3 +20,9 @@ export declare const extractGasSpendForInstances: (gasSpendForInstances?: any[])
 export declare const extractGasSpendForInstance: (gasSpendForInstance?: any) => GasSpendForInstance;
 export declare const extractGasSponsorshipInformation: (gasSponsorshipData?: any[]) => GasSponsorshipData[];
 export declare const extractGasSponsorshipData: (gasSponsorshipData?: any) => GasSponsorshipData;
+export declare const extractStablecoinAutoDepositSettingsForAccount: (settings?: any[]) => StablecoinAutoDepositSettingsForAccount[];
+export declare const extractStablecoinAutoDepositSettingsForAccountItem: (setting?: any) => StablecoinAutoDepositSettingsForAccount;
+export declare const extractStablecoinAutoDepositPerChainUserStablecoinsSettings: (settings?: any[]) => StablecoinAutoDepositPerChainUserStablecoinsSettings[];
+export declare const extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem: (setting?: any) => StablecoinAutoDepositPerChainUserStablecoinsSettings;
+export declare const extractStablecoinAutoDepositProportions: (proportions?: any[]) => StablecoinAutoDepositProportion[];
+export declare const extractStablecoinAutoDepositProportion: (proportion?: any) => StablecoinAutoDepositProportion;

package/dist/esm/utils/action_helpers.js

@@ -247,3 +247,56 @@ export const extractGasSponsorshipData = (gasSponsorshipData) => {
         totalTransactionCount: gasSponsorshipData.totalTransactionCount,
     };
 };
+export const extractStablecoinAutoDepositSettingsForAccount = (settings) => {
+    if (!settings) {
+        return undefined;
+    }
+    return settings
+        .map((setting) => extractStablecoinAutoDepositSettingsForAccountItem(setting))
+        .filter(notEmpty);
+};
+export const extractStablecoinAutoDepositSettingsForAccountItem = (setting) => {
+    if (!setting) {
+        return undefined;
+    }
+    return {
+        account: Account.toAccount(setting.account),
+        settings: extractStablecoinAutoDepositPerChainUserStablecoinsSettings(setting.settings),
+    };
+};
+export const extractStablecoinAutoDepositPerChainUserStablecoinsSettings = (settings) => {
+    if (!settings) {
+        return undefined;
+    }
+    return settings
+        .map((setting) => extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem(setting))
+        .filter(notEmpty);
+};
+export const extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem = (setting) => {
+    if (!setting) {
+        return undefined;
+    }
+    return {
+        userStablecoins: extractStablecoinAutoDepositProportions(setting.userStablecoins),
+        chainId: getChainIdFromOrbyChainId(setting.chainId),
+        miniProgram: setting.miniProgram,
+        miniProgramHash: setting.miniProgramHash,
+    };
+};
+export const extractStablecoinAutoDepositProportions = (proportions) => {
+    if (!proportions) {
+        return undefined;
+    }
+    return proportions
+        .map((proportion) => extractStablecoinAutoDepositProportion(proportion))
+        .filter(notEmpty);
+};
+export const extractStablecoinAutoDepositProportion = (proportion) => {
+    if (!proportion) {
+        return undefined;
+    }
+    return {
+        token: FungibleToken.toFungibleToken(proportion.token),
+        targetPercentage: proportion.targetPercentage,
+    };
+};