@orb-labs/orby-core 0.0.32 → 0.0.34

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ### Unreleased
 
+### 0.0.34
+
+- fix listAbstractableStablecoins interface to return StandardizedToken[] directly instead of wrapped object
+- add listAbstractableStablecoins function to TokenActions for fetching abstractable stablecoins
+- add getStablecoinAutoDepositSettingsForAccount function to AccountClusterActions for fetching stablecoin auto deposit settings
+- add getOperationsForStablecoinAutoDepositSettings function to OperationActions for getting operations for stablecoin auto deposit settings
+
+### 0.0.33
+
+- add support for sending and orchestrating writes locally
+- update calls to isTransactionPreconditionSatisfied
+
 ### 0.0.32
 
 - make getOperationsToSignTransactionOrSignTypedData support evm transactions as well

package/dist/cjs/actions/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, LIBRARY_TYPE, Order } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
 export declare class AccountClusterActions extends LibraryRequest {
@@ -29,4 +29,5 @@ export declare class AccountClusterActions extends LibraryRequest {
     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/cjs/actions/account_cluster.js

@@ -215,5 +215,13 @@ class AccountClusterActions extends library_request_js_1.LibraryRequest {
         }
         return (0, action_helpers_js_1.extractStandardizedBalances)(fungibleTokenBalances);
     }
+    async getStablecoinAutoDepositSettingsForAccount(accountClusterId, account) {
+        const { settings, message, code } = await this.sendRequest("orby_getStablecoinAutoDepositSettingsForAccount", [{ accountClusterId, account: account?.toAccountModel() }]);
+        if (code && message) {
+            console.error("[getStablecoinAutoDepositSettingsForAccountCluster]", code, message);
+            return undefined;
+        }
+        return (0, action_helpers_js_1.extractStablecoinAutoDepositSettingsForAccount)(settings);
+    }
 }
 exports.AccountClusterActions = AccountClusterActions;

package/dist/cjs/actions/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 { LIBRARY_TYPE, OperationStatusType, QuoteType } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
@@ -25,8 +25,23 @@ export declare class OperationActions extends LibraryRequest {
             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;
@@ -107,4 +122,9 @@ export declare class OperationActions extends LibraryRequest {
         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/cjs/actions/operation.js

@@ -6,6 +6,8 @@ const currency_amount_js_1 = require("../entities/financial/currency_amount.js")
 const enums_js_1 = require("../enums.js");
 const library_request_js_1 = require("../entities/library_request.js");
 const account_js_1 = require("../entities/account.js");
+const viem_1 = require("viem");
+const ethers_1 = require("ethers");
 // from here: https://stackoverflow.com/questions/65152373/typescript-serialize-bigint-in-json
 BigInt.prototype.toJSON = function () {
     return this.toString();
@@ -49,6 +51,20 @@ class OperationActions extends library_request_js_1.LibraryRequest {
         ]);
         return (0, action_helpers_js_1.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 (0, action_helpers_js_1.extractOperationSet)(operationSet);
+    }
     async getOperationsToCancelTransaction(accountClusterId, operationSetId) {
         const operationSet = await this.sendRequest("orby_getOperationsToCancelTransaction", [
             {
@@ -58,13 +74,17 @@ class OperationActions extends library_request_js_1.LibraryRequest {
         ]);
         return (0, action_helpers_js_1.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;
@@ -86,7 +106,10 @@ class OperationActions extends library_request_js_1.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) {
@@ -400,7 +423,7 @@ class OperationActions extends library_request_js_1.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
@@ -430,7 +453,7 @@ class OperationActions extends library_request_js_1.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);
@@ -444,5 +467,163 @@ class OperationActions extends library_request_js_1.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 == enums_js_1.OperationOrigin.EXTERNAL);
+        if (orbyOperations?.length == 0) {
+            onCompletionCallback?.([], enums_js_1.OperationStatusType.SUCCESSFUL);
+            return;
+        }
+        else if (!orbyOperations) {
+            onCompletionCallback?.([], enums_js_1.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_js_1.Account.key(operation.from, operation.chainId);
+            const account = accountsMap.get(accountKey);
+            if (account?.type == enums_js_1.AccountType.SCA &&
+                operation.format == enums_js_1.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 == enums_js_1.OperationDataFormat.TRANSACTION) {
+                const accountKey = account_js_1.Account.key(operation.from, operation.chainId);
+                const account = accountsMap.get(accountKey);
+                if (account?.type == enums_js_1.AccountType.SCA) {
+                    continue;
+                }
+                else {
+                    groupedOperations.push([operation]);
+                }
+            }
+            else if (operation.format == enums_js_1.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 == enums_js_1.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 == enums_js_1.LIBRARY_TYPE.VIEM) {
+                        opsActions = new OperationActions(enums_js_1.LIBRARY_TYPE.VIEM, (0, viem_1.createClient)({
+                            transport: (0, viem_1.http)(operation.txRpcUrl),
+                        }), undefined);
+                    }
+                    else if (this.library == enums_js_1.LIBRARY_TYPE.ETHERS) {
+                        opsActions = new OperationActions(enums_js_1.LIBRARY_TYPE.ETHERS, undefined, new ethers_1.ethers.providers.JsonRpcProvider(operation.txRpcUrl));
+                    }
+                    if (operation.format === enums_js_1.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_js_1.Account.key(operation.from, operation.chainId);
+                            const account = accountsMap.get(accountKey);
+                            if (account?.type == enums_js_1.AccountType.SCA) {
+                                const hash = await sendUserOperation?.(operations, operation.from, operation.chainId, operation.txRpcUrl);
+                                onOperationSubmissionCallback?.(hash, enums_js_1.OperationStatusType.PENDING, operations);
+                                hashedOperations[index] = {
+                                    operationId: hash,
+                                    status: enums_js_1.OperationStatusType.SUCCESSFUL,
+                                    operations,
+                                };
+                            }
+                            else {
+                                const hash = await sendTransaction?.(operation);
+                                onOperationSubmissionCallback?.(hash, enums_js_1.OperationStatusType.PENDING, operations);
+                                hashedOperations[index] = {
+                                    operationId: hash,
+                                    status: enums_js_1.OperationStatusType.SUCCESSFUL,
+                                    operations,
+                                };
+                            }
+                        }
+                    }
+                    else if (operation.format === enums_js_1.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, enums_js_1.OperationStatusType.SUCCESSFUL, operations);
+                            hashedOperations[index] = {
+                                operationId: sendOperation.operationResponses[0].hash,
+                                status: enums_js_1.OperationStatusType.SUCCESSFUL,
+                                operations,
+                            };
+                        }
+                    }
+                });
+                await Promise.all(promises);
+                if (hashedOperations.every((result) => result)) {
+                    onCompletionCallback?.(hashedOperations, enums_js_1.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, enums_js_1.OperationStatusType.WAITING_PRECONDITION);
+                    // we cant wait for more than 2 ETH blocks
+                    clearInterval(intervalId);
+                    intervalId = null;
+                }
+            }
+        }, waitTime);
+    }
 }
 exports.OperationActions = OperationActions;

package/dist/cjs/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/cjs/actions/token.js

@@ -47,5 +47,16 @@ class TokenActions extends library_request_js_1.LibraryRequest {
         }
         return (0, action_helpers_js_1.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 (0, action_helpers_js_1.extractStandardizedTokens)(stablecoins);
+    }
 }
 exports.TokenActions = TokenActions;

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/utils/action_helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractGasSponsorshipData = exports.extractGasSponsorshipInformation = exports.extractGasSpendForInstance = exports.extractGasSpendForInstances = exports.extractGasSponsorshipPolicy = exports.extractAllowlistWithOpenFallback = exports.extractMaxAmountPerInterval = exports.extractBlockchainInformations = exports.extractStandardizedToken = exports.extractStandardizedTokens = exports.extractStandardizedBalance = exports.extractStandardizedBalances = exports.extractFungibleTokenOverview = exports.extractActivity = exports.extractActivities = exports.extractOperationStatus = exports.extractOperationStatuses = exports.extractIntent = exports.extractOnchainOperation = exports.extractOperationSet = exports.extractAccountCluster = void 0;
+exports.extractStablecoinAutoDepositProportion = exports.extractStablecoinAutoDepositProportions = exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem = exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettings = exports.extractStablecoinAutoDepositSettingsForAccountItem = exports.extractStablecoinAutoDepositSettingsForAccount = exports.extractGasSponsorshipData = exports.extractGasSponsorshipInformation = exports.extractGasSpendForInstance = exports.extractGasSpendForInstances = exports.extractGasSponsorshipPolicy = exports.extractAllowlistWithOpenFallback = exports.extractMaxAmountPerInterval = exports.extractBlockchainInformations = exports.extractStandardizedToken = exports.extractStandardizedTokens = exports.extractStandardizedBalance = exports.extractStandardizedBalances = exports.extractFungibleTokenOverview = exports.extractActivity = exports.extractActivities = exports.extractOperationStatus = exports.extractOperationStatuses = exports.extractIntent = exports.extractOnchainOperation = exports.extractOperationSet = exports.extractAccountCluster = void 0;
 const enums_js_1 = require("../enums.js");
 const currency_amount_js_1 = require("../entities/financial/currency_amount.js");
 const state_js_1 = require("../entities/state.js");
@@ -271,3 +271,62 @@ const extractGasSponsorshipData = (gasSponsorshipData) => {
     };
 };
 exports.extractGasSponsorshipData = extractGasSponsorshipData;
+const extractStablecoinAutoDepositSettingsForAccount = (settings) => {
+    if (!settings) {
+        return undefined;
+    }
+    return settings
+        .map((setting) => (0, exports.extractStablecoinAutoDepositSettingsForAccountItem)(setting))
+        .filter(utils_js_1.notEmpty);
+};
+exports.extractStablecoinAutoDepositSettingsForAccount = extractStablecoinAutoDepositSettingsForAccount;
+const extractStablecoinAutoDepositSettingsForAccountItem = (setting) => {
+    if (!setting) {
+        return undefined;
+    }
+    return {
+        account: account_js_1.Account.toAccount(setting.account),
+        settings: (0, exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettings)(setting.settings),
+    };
+};
+exports.extractStablecoinAutoDepositSettingsForAccountItem = extractStablecoinAutoDepositSettingsForAccountItem;
+const extractStablecoinAutoDepositPerChainUserStablecoinsSettings = (settings) => {
+    if (!settings) {
+        return undefined;
+    }
+    return settings
+        .map((setting) => (0, exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem)(setting))
+        .filter(utils_js_1.notEmpty);
+};
+exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettings = extractStablecoinAutoDepositPerChainUserStablecoinsSettings;
+const extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem = (setting) => {
+    if (!setting) {
+        return undefined;
+    }
+    return {
+        userStablecoins: (0, exports.extractStablecoinAutoDepositProportions)(setting.userStablecoins),
+        chainId: (0, utils_js_1.getChainIdFromOrbyChainId)(setting.chainId),
+        miniProgram: setting.miniProgram,
+        miniProgramHash: setting.miniProgramHash,
+    };
+};
+exports.extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem = extractStablecoinAutoDepositPerChainUserStablecoinsSettingsItem;
+const extractStablecoinAutoDepositProportions = (proportions) => {
+    if (!proportions) {
+        return undefined;
+    }
+    return proportions
+        .map((proportion) => (0, exports.extractStablecoinAutoDepositProportion)(proportion))
+        .filter(utils_js_1.notEmpty);
+};
+exports.extractStablecoinAutoDepositProportions = extractStablecoinAutoDepositProportions;
+const extractStablecoinAutoDepositProportion = (proportion) => {
+    if (!proportion) {
+        return undefined;
+    }
+    return {
+        token: fungible_token_js_1.FungibleToken.toFungibleToken(proportion.token),
+        targetPercentage: proportion.targetPercentage,
+    };
+};
+exports.extractStablecoinAutoDepositProportion = extractStablecoinAutoDepositProportion;

package/dist/esm/actions/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, LIBRARY_TYPE, Order } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
 export declare class AccountClusterActions extends LibraryRequest {
@@ -29,4 +29,5 @@ export declare class AccountClusterActions extends LibraryRequest {
     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/actions/account_cluster.js

@@ -1,4 +1,4 @@
-import { extractAccountCluster, extractActivities, extractFungibleTokenOverview, extractStandardizedBalances, } from "../utils/action_helpers.js";
+import { extractAccountCluster, extractActivities, extractFungibleTokenOverview, extractStablecoinAutoDepositSettingsForAccount, extractStandardizedBalances, } from "../utils/action_helpers.js";
 import { LibraryRequest } from "../entities/library_request.js";
 import { getChainIdFromOrbyChainId } from "../utils/utils.js";
 import { validateAndFormatAddress } from "../utils/validateAndParseAddress.js";
@@ -212,4 +212,12 @@ export class AccountClusterActions extends LibraryRequest {
         }
         return extractStandardizedBalances(fungibleTokenBalances);
     }
+    async getStablecoinAutoDepositSettingsForAccount(accountClusterId, account) {
+        const { settings, message, code } = await this.sendRequest("orby_getStablecoinAutoDepositSettingsForAccount", [{ accountClusterId, account: account?.toAccountModel() }]);
+        if (code && message) {
+            console.error("[getStablecoinAutoDepositSettingsForAccountCluster]", code, message);
+            return undefined;
+        }
+        return extractStablecoinAutoDepositSettingsForAccount(settings);
+    }
 }

package/dist/esm/actions/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 { LIBRARY_TYPE, OperationStatusType, QuoteType } from "../enums.js";
 import { LibraryRequest } from "../entities/library_request.js";
@@ -25,8 +25,23 @@ export declare class OperationActions extends LibraryRequest {
             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;
@@ -107,4 +122,9 @@ export declare class OperationActions extends LibraryRequest {
         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>;
 }