@orb-labs/orby-core 0.0.31 → 0.0.34

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";
@@ -24,9 +24,24 @@ export declare class OperationActions extends LibraryRequest {
             chainId: bigint;
             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/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, 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();
@@ -33,7 +35,7 @@ export class OperationActions extends LibraryRequest {
         ]);
         return extractOperationSet(operationSet);
     }
-    async getOperationsToSignTransactionOrSignTypedData(accountClusterId, data, to, value, gasToken) {
+    async getOperationsToSignTransactionOrSignTypedData(accountClusterId, data, to, value, gasToken, options) {
         const operationSet = await this.sendRequest("orby_getOperationsToSignTransactionOrSignTypedData", [
             {
                 accountClusterId,
@@ -41,6 +43,21 @@ export class OperationActions extends LibraryRequest {
                 data,
                 value,
                 gasToken: await this.formatGasToken(gasToken),
+                options: options ? Object.fromEntries(options) : undefined,
+            },
+        ]);
+        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);
@@ -54,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;
@@ -82,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) {
@@ -275,7 +299,10 @@ export class OperationActions extends LibraryRequest {
         let intervalId = null;
         let totalWaitTime = 0;
         const timeoutOrDefault = timout ?? 300_000;
-        if (ids && ids?.length > 0) {
+        if (!ids || ids?.length == 0) {
+            onOperationStatusesUpdateCallback?.(OperationStatusType.SUCCESSFUL, undefined, []);
+        }
+        else if (ids && ids?.length > 0) {
             const waitTime = 500;
             intervalId = setInterval(async () => {
                 let statusSummary = OperationStatusType.WAITING_PRECONDITION;
@@ -335,7 +362,8 @@ export class OperationActions extends LibraryRequest {
             ?.map((intent) => intent.intentOperations)
             .flat()
             ?.concat(operationSet.primaryOperation)
-            .filter((value) => value != undefined && value != null);
+            .filter((value) => (value != undefined && value != null) ||
+            value?.origin == OperationOrigin.EXTERNAL);
         if (operations?.length == 0) {
             return { success: true, operationResponses: [] };
         }
@@ -392,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
@@ -422,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);
@@ -436,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/enums.d.ts

@@ -29,6 +29,10 @@ export declare enum OperationDataFormat {
     TRANSACTION = "TRANSACTION",
     TYPED_DATA = "TYPED_DATA"
 }
+export declare enum OperationOrigin {
+    EXTERNAL = "external",
+    ORBY = "orby"
+}
 export declare enum OperationType {
     APPROVE_ERC20_TOKEN = "APPROVE_ERC20_TOKEN",
     CANCEL_OPERATION = "CANCEL_OPERATION",

package/dist/esm/enums.js

@@ -35,6 +35,11 @@ export var OperationDataFormat;
     OperationDataFormat["TRANSACTION"] = "TRANSACTION";
     OperationDataFormat["TYPED_DATA"] = "TYPED_DATA";
 })(OperationDataFormat || (OperationDataFormat = {}));
+export var OperationOrigin;
+(function (OperationOrigin) {
+    OperationOrigin["EXTERNAL"] = "external";
+    OperationOrigin["ORBY"] = "orby";
+})(OperationOrigin || (OperationOrigin = {}));
 export var OperationType;
 (function (OperationType) {
     OperationType["APPROVE_ERC20_TOKEN"] = "APPROVE_ERC20_TOKEN";

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 {
@@ -22,9 +22,24 @@ export interface IOperationActions {
             chainId: bigint;
             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

@@ -4,10 +4,11 @@ import { CurrencyAmount } from "./entities/financial/currency_amount.js";
 import { FungibleToken } from "./entities/financial/fungible_token.js";
 import { FungibleTokenAmount } from "./entities/financial/fungible_token_amount.js";
 import { State } from "./entities/state.js";
-import { ActivityStatus, BlockchainEnvironment, Category, CreateOperationsStatus, OperationDataFormat, OperationStatusType, OperationType, TimeIntervalUnits, TokenAllowlistType, VMType } from "./enums.js";
+import { ActivityStatus, BlockchainEnvironment, Category, CreateOperationsStatus, OperationDataFormat, OperationOrigin, OperationStatusType, OperationType, TimeIntervalUnits, TokenAllowlistType, VMType } from "./enums.js";
 export type AccountCluster = {
     accountClusterId: string;
     accounts: Account[];
+    isChainAbstractionEnabled: boolean;
 };
 export type ChainEndpoint = {
     chainId: bigint;
@@ -70,6 +71,7 @@ export interface OnchainOperation {
     txRpcUrl: string;
     type: OperationType;
     value?: bigint;
+    origin: OperationOrigin;
 }
 export type SignedOperation = {
     type: OperationType;
@@ -77,7 +79,7 @@ export type SignedOperation = {
     category?: Category;
     data?: string;
     from?: string;
-    chainId?: string;
+    chainId?: bigint;
 };
 export type OperationStatus = {
     blockHash?: string;
@@ -171,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

@@ -16,6 +16,7 @@ export const extractAccountCluster = (accountCluster) => {
     }
     return {
         accountClusterId: accountCluster?.accountClusterId,
+        isChainAbstractionEnabled: accountCluster?.isChainAbstractionEnabled,
         accounts: accountCluster?.accounts?.map((account) => Account.toAccount(account)),
     };
 };
@@ -73,6 +74,7 @@ export const extractOnchainOperation = (onchainOperation) => {
         txRpcUrl: onchainOperation.txRpcUrl,
         type: onchainOperation.type,
         value: onchainOperation.value ? BigInt(onchainOperation.value) : undefined,
+        origin: onchainOperation.origin,
     };
 };
 export const extractIntent = (intent) => {
@@ -245,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,
+    };
+};