@charterlabs/rhinestone-sdk 0.0.3 → 0.0.4

package/dist/src/accounts/utils.d.ts

@@ -1,6 +1,10 @@
 import type { Address, Client, Hex } from 'viem';
 import type { RhinestoneAccountConfig } from '../types';
 type CallType = 'call' | 'delegatecall' | 'batchcall';
+interface ValidatorConfig {
+    address: Address;
+    isRoot: boolean;
+}
 interface ExecutionMode<callType extends CallType> {
     type: callType;
     revertOnError?: boolean;
@@ -24,4 +28,5 @@ declare function encode7579Calls<callType extends CallType>({ mode, callData, }:
 declare function getAccountNonce(client: Client, args: GetAccountNonceParams): Promise<bigint>;
 declare function getBundlerClient(config: RhinestoneAccountConfig, client: Client): import("viem/account-abstraction").BundlerClient<import("viem").HttpTransport<undefined, false>, undefined, undefined, Client, undefined>;
 export { encode7579Calls, getAccountNonce, getBundlerClient };
+export type { ValidatorConfig };
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/accounts/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../accounts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAchD,OAAO,KAAK,EAAiB,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEtE,KAAK,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAErD,UAAU,aAAa,CAAC,QAAQ,SAAS,QAAQ;IAC/C,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,UAAU,oBAAoB,CAAC,QAAQ,SAAS,QAAQ;IACtD,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IAC7B,QAAQ,EAAE,SAAS;QACjB,EAAE,EAAE,OAAO,CAAA;QACX,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;KACvB,EAAE,CAAA;CACJ;AAED,UAAU,qBAAqB;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAkDD,iBAAS,eAAe,CAAC,QAAQ,SAAS,QAAQ,EAAE,EAClD,IAAI,EACJ,QAAQ,GACT,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAuFtC;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAmCjB;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,6IAyBxE;AAyBD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../accounts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAchD,OAAO,KAAK,EAAiB,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEtE,KAAK,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAErD,UAAU,eAAe;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,UAAU,aAAa,CAAC,QAAQ,SAAS,QAAQ;IAC/C,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,UAAU,oBAAoB,CAAC,QAAQ,SAAS,QAAQ;IACtD,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IAC7B,QAAQ,EAAE,SAAS;QACjB,EAAE,EAAE,OAAO,CAAA;QACX,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;KACvB,EAAE,CAAA;CACJ;AAED,UAAU,qBAAqB;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAkDD,iBAAS,eAAe,CAAC,QAAQ,SAAS,QAAQ,EAAE,EAClD,IAAI,EACJ,QAAQ,GACT,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAuFtC;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAmCjB;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,6IAyBxE;AAyBD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAA;AAC7D,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/dist/src/actions/index.d.ts

@@ -0,0 +1,12 @@
+import { Address, Chain } from 'viem';
+import { RhinestoneAccount } from '..';
+import { Call, OwnerSet, Recovery } from '../types';
+declare function setUpRecovery({ rhinestoneAccount, guardians, threshold, }: {
+    rhinestoneAccount: RhinestoneAccount;
+} & Recovery): Call[];
+declare function recover(address: Address, newOwners: OwnerSet, chain: Chain): Promise<Call[]>;
+declare function addOwner(owner: Address): Call;
+declare function removeOwner(prevOwner: Address, ownerToRemove: Address): Call;
+declare function setThreshold(newThreshold: bigint): Call;
+export { addOwner, removeOwner, setThreshold, recover, setUpRecovery };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EAIN,MAAM,MAAM,CAAA;AACb,OAAO,EAAE,iBAAiB,EAAE,MAAM,IAAI,CAAA;AAMtC,OAAO,EAAE,IAAI,EAA0B,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAE3E,iBAAS,aAAa,CAAC,EACrB,iBAAiB,EACjB,SAAS,EACT,SAAa,GACd,EAAE;IACD,iBAAiB,EAAE,iBAAiB,CAAA;CACrC,GAAG,QAAQ,UAIX;AAED,iBAAe,OAAO,CACpB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,QAAQ,EACnB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,IAAI,EAAE,CAAC,CASjB;AAED,iBAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAiBtC;AAED,iBAAS,WAAW,CAAC,SAAS,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,GAAG,IAAI,CAoBrE;AAED,iBAAS,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAmBhD;AAqGD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/src/actions/index.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOwner = addOwner;
+exports.removeOwner = removeOwner;
+exports.setThreshold = setThreshold;
+exports.recover = recover;
+exports.setUpRecovery = setUpRecovery;
+const viem_1 = require("viem");
+const accounts_1 = require("../accounts");
+const core_1 = require("../modules/validators/core");
+function setUpRecovery({ rhinestoneAccount, guardians, threshold = 1, }) {
+    const module = (0, core_1.getSocialRecoveryValidator)(guardians, threshold);
+    const calls = (0, accounts_1.getModuleInstallationCalls)(rhinestoneAccount.config, module);
+    return calls;
+}
+async function recover(address, newOwners, chain) {
+    switch (newOwners.type) {
+        case 'ecdsa': {
+            return recoverEcdsaOwnership(address, newOwners, chain);
+        }
+        case 'passkey': {
+            throw new Error('Passkey ownership recovery is not yet supported');
+        }
+    }
+}
+function addOwner(owner) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [{ internalType: 'address', name: 'owner', type: 'address' }],
+                    name: 'addOwner',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'addOwner',
+            args: [owner],
+        }),
+    };
+}
+function removeOwner(prevOwner, ownerToRemove) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'address', name: 'prevOwner', type: 'address' },
+                        { internalType: 'address', name: 'owner', type: 'address' },
+                    ],
+                    name: 'removeOwner',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'removeOwner',
+            args: [prevOwner, ownerToRemove],
+        }),
+    };
+}
+function setThreshold(newThreshold) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'uint256', name: '_threshold', type: 'uint256' },
+                    ],
+                    name: 'setThreshold',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'setThreshold',
+            args: [newThreshold],
+        }),
+    };
+}
+async function recoverEcdsaOwnership(address, newOwners, chain) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    // Read the existing config
+    const [existingOwners, existingThreshold] = await Promise.all([
+        publicClient.readContract({
+            address: core_1.OWNABLE_VALIDATOR_ADDRESS,
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'address', name: 'account', type: 'address' },
+                    ],
+                    name: 'getOwners',
+                    outputs: [
+                        {
+                            internalType: 'address[]',
+                            name: 'ownersArray',
+                            type: 'address[]',
+                        },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
+            ],
+            functionName: 'getOwners',
+            args: [address],
+        }),
+        publicClient.readContract({
+            address: core_1.OWNABLE_VALIDATOR_ADDRESS,
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'address', name: 'account', type: 'address' },
+                    ],
+                    name: 'threshold',
+                    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
+            ],
+            functionName: 'threshold',
+            args: [address],
+        }),
+    ]);
+    const normalizedExistingOwners = existingOwners.map((owner) => owner.toLowerCase());
+    const calls = [];
+    // Convert new owners config to addresses and threshold
+    const newOwnerAddresses = newOwners.accounts
+        .map((account) => account.address.toLowerCase())
+        .sort();
+    const newThreshold = BigInt(newOwners.threshold ?? 1);
+    // Check if threshold needs to be updated
+    if (existingThreshold !== newThreshold) {
+        calls.push(setThreshold(newThreshold));
+    }
+    const ownersToAdd = newOwnerAddresses.filter((owner) => !normalizedExistingOwners.includes(owner));
+    const ownersToRemove = normalizedExistingOwners.filter((owner) => !newOwnerAddresses.includes(owner));
+    // Maintain the list as making changes to keep track of the previous owner for removals
+    // Note: new owners are added to the START of the linked list
+    let currentOwners = [...normalizedExistingOwners];
+    for (const owner of ownersToAdd) {
+        calls.push(addOwner(owner));
+        currentOwners.unshift(owner);
+    }
+    for (const ownerToRemove of ownersToRemove) {
+        const ownerIndex = currentOwners.indexOf(ownerToRemove);
+        let prevOwner;
+        if (ownerIndex === 0) {
+            // If it's the first owner, use the sentinel address
+            prevOwner = '0x0000000000000000000000000000000000000001';
+        }
+        else {
+            prevOwner = currentOwners[ownerIndex - 1];
+        }
+        calls.push(removeOwner(prevOwner, ownerToRemove));
+        currentOwners = currentOwners.filter((owner) => owner !== ownerToRemove);
+    }
+    return calls;
+}

package/dist/src/actions/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/src/actions/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../actions/index.test.ts"],"names":[],"mappings":""}

package/dist/src/actions/index.test.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const __1 = require("..");
+const _1 = require(".");
+const MOCK_OWNER_A = '0xd1aefebdceefc094f1805b241fa5e6db63a9181a';
+const MOCK_OWNER_B = '0xeddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817';
+const MOCK_ACCOUNT_ADDRESS = '0x1234567890123456789012345678901234567890';
+// Mock viem
+vitest_1.vi.mock('viem', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        // @ts-ignore
+        ...actual,
+        createPublicClient: vitest_1.vi.fn(),
+    };
+});
+(0, vitest_1.describe)('Actions', () => {
+    (0, vitest_1.describe)('Add Owner', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, _1.addOwner)(MOCK_OWNER_A)).toEqual({
+                to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                data: '0x7065cb48000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Remove Owner', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, _1.removeOwner)(MOCK_OWNER_A, MOCK_OWNER_B)).toEqual({
+                to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                data: '0xfbe5ce0a000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a000000000000000000000000eddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Set Threshold', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, _1.setThreshold)(1n)).toEqual({
+                to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                data: '0x960bfe040000000000000000000000000000000000000000000000000000000000000001',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Set Up Recovery', async () => {
+        const rhinestoneAccount = await (0, __1.createRhinestoneAccount)({
+            owners: {
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            },
+            rhinestoneApiKey: consts_1.MOCK_API_KEY,
+        });
+        (0, vitest_1.test)('Single Guardian', () => {
+            (0, vitest_1.expect)((0, _1.setUpRecovery)({
+                rhinestoneAccount,
+                guardians: [consts_1.accountB],
+                threshold: 1,
+            })).toEqual([
+                {
+                    to: '0x27d66c2e6b33579ee108206c4bc8f66bb655e69f',
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a04d053b3c8021e8d5bf641816c42daa75d8b597000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('Guardian Multi-Sig', () => {
+            (0, vitest_1.expect)((0, _1.setUpRecovery)({
+                rhinestoneAccount,
+                guardians: [consts_1.accountB, consts_1.accountC, consts_1.accountD],
+                threshold: 2,
+            })).toEqual([
+                {
+                    to: '0x27d66c2e6b33579ee108206c4bc8f66bb655e69f',
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a04d053b3c8021e8d5bf641816c42daa75d8b597000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000030000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000c27b7578151c5ef713c62c65db09763d57ac3596000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Recover', () => {
+        const mockPublicClient = {
+            readContract: vitest_1.vi.fn(),
+        };
+        (0, vitest_1.beforeEach)(() => {
+            const createPublicClientMock = viem_1.createPublicClient;
+            createPublicClientMock.mockReturnValue(mockPublicClient);
+            vitest_1.vi.clearAllMocks();
+        });
+        (0, vitest_1.test)('1/1 Owners - Single owner to different single owner', async () => {
+            // Initial state
+            mockPublicClient.readContract
+                .mockResolvedValueOnce([consts_1.accountA.address.toLowerCase()])
+                .mockResolvedValueOnce(1n);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB],
+                threshold: 1,
+            };
+            const result = await (0, _1.recover)(MOCK_ACCOUNT_ADDRESS, newOwners, chains_1.base);
+            (0, vitest_1.expect)(mockPublicClient.readContract).toHaveBeenCalledTimes(2);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0x7065cb480000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7',
+                },
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0xfbe5ce0a0000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('1/N Owners - Single owner to multiple owners', async () => {
+            // Initial state
+            mockPublicClient.readContract
+                .mockResolvedValueOnce([
+                consts_1.accountA.address.toLowerCase(),
+                consts_1.accountB.address.toLowerCase(),
+                consts_1.accountC.address.toLowerCase(),
+            ])
+                .mockResolvedValueOnce(1n);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB, consts_1.accountC, consts_1.accountD],
+                threshold: 1,
+            };
+            const result = await (0, _1.recover)(MOCK_ACCOUNT_ADDRESS, newOwners, chains_1.base);
+            (0, vitest_1.expect)(mockPublicClient.readContract).toHaveBeenCalledTimes(2);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0x7065cb48000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0xfbe5ce0a000000000000000000000000c5587d912c862252599b61926adaef316ba06da0000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('M/N Owners - Multiple owners to different multiple owners', async () => {
+            // Initial state
+            mockPublicClient.readContract
+                .mockResolvedValueOnce([
+                consts_1.accountA.address.toLowerCase(),
+                consts_1.accountB.address.toLowerCase(),
+                consts_1.accountC.address.toLowerCase(),
+            ])
+                .mockResolvedValueOnce(2n);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB, consts_1.accountD],
+                threshold: 2,
+            };
+            const result = await (0, _1.recover)(MOCK_ACCOUNT_ADDRESS, newOwners, chains_1.base);
+            (0, vitest_1.expect)(mockPublicClient.readContract).toHaveBeenCalledTimes(2);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0x7065cb48000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0xfbe5ce0a000000000000000000000000c5587d912c862252599b61926adaef316ba06da0000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+                {
+                    to: '0x2483DA3A338895199E5e538530213157e931Bf06',
+                    data: '0xfbe5ce0a0000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000c27b7578151c5ef713c62c65db09763d57ac3596',
+                },
+            ]);
+        });
+    });
+});

package/dist/src/execution/index.d.ts

@@ -1,19 +1,9 @@
-import { type Address, type Chain, type Hex } from 'viem';
+import { type Address, type Chain } from 'viem';
 import type { BundleResult } from '../orchestrator';
 import type { RhinestoneAccountConfig, Transaction } from '../types';
-type TransactionResult = {
-    type: 'userop';
-    hash: Hex;
-    sourceChain: number;
-    targetChain: number;
-} | {
-    type: 'bundle';
-    id: bigint;
-    sourceChain?: number;
-    targetChain: number;
-};
+import type { BundleData, TransactionResult } from './utils';
 declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
-declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<BundleResult | {
+declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<{
     actualGasCost: bigint;
     actualGasUsed: bigint;
     entryPoint: Address;
@@ -25,9 +15,9 @@ declare function waitForExecution(config: RhinestoneAccountConfig, result: Trans
     sender: Address;
     success: boolean;
     userOpHash: import("viem").Hash;
-}>;
+} | BundleResult>;
 declare function getMaxSpendableAmount(config: RhinestoneAccountConfig, chain: Chain, tokenAddress: Address, gasUnits: bigint): Promise<bigint>;
 declare function getPortfolio(config: RhinestoneAccountConfig, onTestnets: boolean): Promise<import("../orchestrator").UserTokenBalance[]>;
 export { sendTransaction, waitForExecution, getMaxSpendableAmount, getPortfolio, };
-export type { TransactionResult };
+export type { BundleData, TransactionResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/execution/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIV,KAAK,GAAG,EAMT,MAAM,MAAM,CAAA;AAmBb,OAAO,KAAK,EACV,YAAY,EAGb,MAAM,iBAAiB,CAAA;AAqBxB,OAAO,KAAK,EAEV,uBAAuB,EAIvB,WAAW,EACZ,MAAM,UAAU,CAAA;AASjB,KAAK,iBAAiB,GAClB;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,IAAI,EAAE,GAAG,CAAA;IACT,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,GACD;IACE,IAAI,EAAE,QAAQ,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAEL,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AAsSD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GAwCjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,yDAMpB;AASD,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIX,MAAM,MAAM,CAAA;AAKb,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAYnD,OAAO,KAAK,EAEV,uBAAuB,EAGvB,WAAW,EACZ,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAe5D,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAyBzB;AAsLD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;kBAwCjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,yDAMpB;AAED,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,GACb,CAAA;AACD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}