@charterlabs/rhinestone-sdk 0.0.1

package/dist/execution/index.d.ts

@@ -0,0 +1,33 @@
+import { type Address, type Chain, type Hex } 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;
+};
+declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
+declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<BundleResult | {
+    actualGasCost: bigint;
+    actualGasUsed: bigint;
+    entryPoint: Address;
+    logs: import("viem").Log<bigint, number, false>[];
+    nonce: bigint;
+    paymaster?: `0x${string}` | undefined;
+    reason?: string | undefined | undefined;
+    receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
+    sender: Address;
+    success: boolean;
+    userOpHash: import("viem").Hash;
+}>;
+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 };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;AAiBxB,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;AA8RD,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"}

package/dist/execution/index.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTransaction = sendTransaction;
+exports.waitForExecution = waitForExecution;
+exports.getMaxSpendableAmount = getMaxSpendableAmount;
+exports.getPortfolio = getPortfolio;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const chains_1 = require("viem/chains");
+const accounts_1 = require("../accounts");
+const utils_1 = require("../accounts/utils");
+const modules_1 = require("../modules");
+const validators_1 = require("../modules/validators");
+const orchestrator_1 = require("../orchestrator");
+const consts_1 = require("../orchestrator/consts");
+const registry_1 = require("../orchestrator/registry");
+const smart_session_1 = require("./smart-session");
+const POLLING_INTERVAL = 500;
+async function sendTransaction(config, transaction) {
+    if ('chain' in transaction) {
+        // Same-chain transaction
+        return await sendTransactionInternal(config, transaction.chain, transaction.chain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers);
+    }
+    else {
+        // Cross-chain transaction
+        return await sendTransactionInternal(config, transaction.sourceChain, transaction.targetChain, transaction.calls, transaction.gasLimit, transaction.tokenRequests, transaction.signers);
+    }
+}
+async function sendTransactionInternal(config, sourceChain, targetChain, calls, gasLimit, initialTokenRequests, signers) {
+    if (sourceChain) {
+        const isAccountDeployed = await (0, accounts_1.isDeployed)(sourceChain, config);
+        if (!isAccountDeployed) {
+            await (0, accounts_1.deploySource)(sourceChain, config);
+        }
+    }
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    const withSession = signers?.type === 'session' ? signers.session : null;
+    // Across requires passing some value to repay the solvers
+    const tokenRequests = initialTokenRequests.length === 0
+        ? [
+            {
+                address: viem_1.zeroAddress,
+                amount: 1n,
+            },
+        ]
+        : initialTokenRequests;
+    if (withSession) {
+        if (!sourceChain) {
+            throw new Error(`Specifying source chain is required when using smart sessions`);
+        }
+        await (0, smart_session_1.enableSmartSession)(sourceChain, config, withSession);
+        // Smart sessions require a UserOp flow
+        return await sendTransactionAsUserOp(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress, withSession);
+    }
+    else {
+        return await sendTransactionAsIntent(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress);
+    }
+}
+async function sendTransactionAsUserOp(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress, withSession) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: sourceChain,
+        transport: (0, viem_1.http)(),
+    });
+    const sessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, publicClient, sourceChain, withSession);
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const targetPublicClient = (0, viem_1.createPublicClient)({
+        chain: targetChain,
+        transport: (0, viem_1.http)(),
+    });
+    const targetSessionAccount = await (0, accounts_1.getSmartSessionSmartAccount)(config, targetPublicClient, targetChain, withSession);
+    const targetBundlerClient = (0, utils_1.getBundlerClient)(config, targetPublicClient);
+    if (sourceChain.id === targetChain.id) {
+        await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
+        const hash = await bundlerClient.sendUserOperation({
+            account: sessionAccount,
+            calls,
+        });
+        return {
+            type: 'userop',
+            hash,
+            sourceChain: sourceChain.id,
+            targetChain: targetChain.id,
+        };
+    }
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        targetGasUnits: gasLimit,
+        userOp: (0, orchestrator_1.getEmptyUserOp)(),
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    // Deploy the account on the target chain
+    await (0, accounts_1.deployTarget)(targetChain, config, true);
+    await (0, smart_session_1.enableSmartSession)(targetChain, config, withSession);
+    const userOp = await targetBundlerClient.prepareUserOperation({
+        account: targetSessionAccount,
+        calls: [...orderPath[0].injectedExecutions, ...calls],
+        stateOverride: [
+            ...tokenRequests.map((request) => {
+                const rootBalanceSlot = (0, orchestrator_1.getTokenRootBalanceSlot)(targetChain, request.address);
+                const balanceSlot = rootBalanceSlot
+                    ? (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'uint256' }], [accountAddress, rootBalanceSlot]))
+                    : '0x';
+                return {
+                    address: request.address,
+                    stateDiff: [
+                        {
+                            slot: balanceSlot,
+                            value: (0, viem_1.pad)((0, viem_1.toHex)(request.amount)),
+                        },
+                    ],
+                };
+            }),
+        ],
+    });
+    userOp.signature = await targetSessionAccount.signUserOperation(userOp);
+    const userOpHash = (0, account_abstraction_1.getUserOperationHash)({
+        userOperation: userOp,
+        chainId: targetChain.id,
+        entryPointAddress: account_abstraction_1.entryPoint07Address,
+        entryPointVersion: '0.7',
+    });
+    orderPath[0].orderBundle.segments[0].witness.userOpHash = userOpHash;
+    const { hash, appDomainSeparator, contentsType, structHash } = await (0, smart_session_1.hashErc7739)(sourceChain, orderPath, accountAddress);
+    const signature = await (0, accounts_1.sign)(withSession.owners, targetChain, hash);
+    const sessionSignature = (0, smart_session_1.getSessionSignature)(signature, appDomainSeparator, structHash, contentsType, withSession);
+    const smartSessionValidator = (0, validators_1.getSmartSessionValidator)(config);
+    if (!smartSessionValidator) {
+        throw new Error('Smart session validator not available');
+    }
+    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [smartSessionValidator.address, sessionSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            userOp,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain: sourceChain.id,
+        targetChain: targetChain.id,
+    };
+}
+async function sendTransactionAsIntent(config, sourceChain, targetChain, calls, gasLimit, tokenRequests, accountAddress) {
+    const accountAccessList = sourceChain
+        ? {
+            chainIds: [sourceChain.id],
+        }
+        : undefined;
+    const metaIntent = {
+        targetChainId: targetChain.id,
+        tokenTransfers: tokenRequests.map((tokenRequest) => ({
+            tokenAddress: tokenRequest.address,
+            amount: tokenRequest.amount,
+        })),
+        targetAccount: accountAddress,
+        targetExecutions: calls.map((call) => ({
+            value: call.value ?? 0n,
+            to: call.to,
+            data: call.data ?? '0x',
+        })),
+        targetGasUnits: gasLimit,
+        accountAccessList,
+    };
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const orderPath = await orchestrator.getOrderPath(metaIntent, accountAddress);
+    orderPath[0].orderBundle.segments[0].witness.execs = [
+        ...orderPath[0].injectedExecutions,
+        ...metaIntent.targetExecutions,
+    ];
+    const orderBundleHash = (0, orchestrator_1.getOrderBundleHash)(orderPath[0].orderBundle);
+    const bundleSignature = await (0, accounts_1.sign)(config.owners, sourceChain || targetChain, orderBundleHash);
+    const validatorModule = (0, modules_1.getOwnerValidator)(config);
+    const packedSig = (0, viem_1.encodePacked)(['address', 'bytes'], [validatorModule.address, bundleSignature]);
+    const signedOrderBundle = {
+        ...orderPath[0].orderBundle,
+        originSignatures: Array(orderPath[0].orderBundle.segments.length).fill(packedSig),
+        targetSignature: packedSig,
+    };
+    await (0, accounts_1.deployTarget)(targetChain, config, false);
+    const initCode = (0, accounts_1.getBundleInitCode)(config);
+    const bundleResults = await orchestrator.postSignedOrderBundle([
+        {
+            signedOrderBundle,
+            initCode,
+        },
+    ]);
+    return {
+        type: 'bundle',
+        id: bundleResults[0].bundleId,
+        sourceChain: sourceChain?.id,
+        targetChain: targetChain.id,
+    };
+}
+async function waitForExecution(config, result, acceptsPreconfirmations) {
+    const validStatuses = new Set([
+        orchestrator_1.BUNDLE_STATUS_FAILED,
+        orchestrator_1.BUNDLE_STATUS_COMPLETED,
+        orchestrator_1.BUNDLE_STATUS_FILLED,
+    ]);
+    if (acceptsPreconfirmations) {
+        validStatuses.add(orchestrator_1.BUNDLE_STATUS_PRECONFIRMED);
+    }
+    switch (result.type) {
+        case 'bundle': {
+            let bundleResult = null;
+            while (bundleResult === null || !validStatuses.has(bundleResult.status)) {
+                const orchestrator = getOrchestratorByChain(result.targetChain, config.rhinestoneApiKey);
+                bundleResult = await orchestrator.getBundleStatus(result.id);
+                await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL));
+            }
+            if (bundleResult.status === orchestrator_1.BUNDLE_STATUS_FAILED) {
+                throw new Error('Bundle failed');
+            }
+            return bundleResult;
+        }
+        case 'userop': {
+            const targetChain = (0, registry_1.getChainById)(result.targetChain);
+            const publicClient = (0, viem_1.createPublicClient)({
+                chain: targetChain,
+                transport: (0, viem_1.http)(),
+            });
+            const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+            const receipt = await bundlerClient.waitForUserOperationReceipt({
+                hash: result.hash,
+            });
+            return receipt;
+        }
+    }
+}
+async function getMaxSpendableAmount(config, chain, tokenAddress, gasUnits) {
+    const address = (0, accounts_1.getAddress)(config);
+    const orchestrator = getOrchestratorByChain(chain.id, config.rhinestoneApiKey);
+    return orchestrator.getMaxTokenAmount(address, chain.id, tokenAddress, gasUnits);
+}
+async function getPortfolio(config, onTestnets) {
+    const address = (0, accounts_1.getAddress)(config);
+    const chainId = onTestnets ? chains_1.sepolia.id : chains_1.mainnet.id;
+    const orchestrator = getOrchestratorByChain(chainId, config.rhinestoneApiKey);
+    return orchestrator.getPortfolio(address);
+}
+function getOrchestratorByChain(chainId, apiKey) {
+    const orchestratorUrl = (0, registry_1.isTestnet)(chainId)
+        ? consts_1.DEV_ORCHESTRATOR_URL
+        : consts_1.PROD_ORCHESTRATOR_URL;
+    return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
+}

package/dist/execution/smart-session.d.ts

@@ -0,0 +1,13 @@
+import { type Address, type Chain, type Hex } from 'viem';
+import type { OrderPath } from '../orchestrator';
+import type { RhinestoneAccountConfig, Session } from '../types';
+declare function enableSmartSession(chain: Chain, config: RhinestoneAccountConfig, session: Session): Promise<void>;
+declare function hashErc7739(sourceChain: Chain, orderPath: OrderPath, accountAddress: Address): Promise<{
+    hash: `0x${string}`;
+    appDomainSeparator: `0x${string}`;
+    contentsType: string;
+    structHash: `0x${string}`;
+}>;
+declare function getSessionSignature(signature: Hex, appDomainSeparator: Hex, structHash: Hex, contentsType: string, withSession: Session): `0x${string}`;
+export { enableSmartSession, hashErc7739, getSessionSignature };
+//# sourceMappingURL=smart-session.d.ts.map

package/dist/execution/smart-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../execution/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,KAAK,EAIV,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AAWb,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAEhE,iBAAe,kBAAkB,CAC/B,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,OAAO,iBAyBjB;AAED,iBAAe,WAAW,CACxB,WAAW,EAAE,KAAK,EAClB,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,OAAO;;;;;GAiExB;AAED,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,GAAG,EACd,kBAAkB,EAAE,GAAG,EACvB,UAAU,EAAE,GAAG,EACf,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,OAAO,iBAkBrB;AAED,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/execution/smart-session.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableSmartSession = enableSmartSession;
+exports.hashErc7739 = hashErc7739;
+exports.getSessionSignature = getSessionSignature;
+const viem_1 = require("viem");
+const accounts_1 = require("../accounts");
+const utils_1 = require("../accounts/utils");
+const validators_1 = require("../modules/validators");
+const utils_2 = require("../orchestrator/utils");
+async function enableSmartSession(chain, config, session) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const address = (0, accounts_1.getAddress)(config);
+    const isEnabled = await (0, validators_1.isSessionEnabled)(publicClient, address, (0, validators_1.getPermissionId)(session));
+    if (isEnabled) {
+        return;
+    }
+    const smartAccount = await (0, accounts_1.getSmartAccount)(config, publicClient, chain);
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const enableSessionCall = await (0, validators_1.getEnableSessionCall)(chain, session);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        calls: [enableSessionCall],
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function hashErc7739(sourceChain, orderPath, accountAddress) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: sourceChain,
+        transport: (0, viem_1.http)(),
+    });
+    const { appDomainSeparator, contentsType } = await (0, validators_1.getSessionAllowedERC7739Content)(sourceChain);
+    // Create hash following ERC-7739 TypedDataSign workflow
+    const typedDataSignTypehash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [
+        'TypedDataSign(MultichainCompact contents,string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)'.concat(contentsType),
+    ]));
+    // Original struct hash
+    const structHash = (0, utils_2.hashMultichainCompactWithoutDomainSeparator)(orderPath[0].orderBundle);
+    const { name, version, chainId, verifyingContract, salt } = await (0, validators_1.getAccountEIP712Domain)(publicClient, accountAddress);
+    // Final hash according to ERC-7739
+    const hash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes2', 'bytes32', 'bytes32'], [
+        '0x1901',
+        appDomainSeparator,
+        (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([
+            { name: 'typedDataSignTypehash', type: 'bytes32' },
+            { name: 'structHash', type: 'bytes32' },
+            { name: 'name', type: 'bytes32' },
+            { name: 'version', type: 'bytes32' },
+            { name: 'chainId', type: 'uint256' },
+            { name: 'verifyingContract', type: 'address' },
+            { name: 'salt', type: 'bytes32' },
+        ], [
+            typedDataSignTypehash,
+            structHash,
+            (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [name])),
+            (0, viem_1.keccak256)((0, viem_1.encodePacked)(['string'], [version])),
+            BigInt(Number(chainId)),
+            verifyingContract,
+            salt,
+        ])),
+    ]));
+    return {
+        hash,
+        appDomainSeparator,
+        contentsType,
+        structHash,
+    };
+}
+function getSessionSignature(signature, appDomainSeparator, structHash, contentsType, withSession) {
+    const erc7739Signature = (0, viem_1.encodePacked)(['bytes', 'bytes32', 'bytes32', 'string', 'uint16'], [
+        signature,
+        appDomainSeparator,
+        structHash,
+        contentsType,
+        contentsType.length,
+    ]);
+    // Pack with permissionId for smart session
+    const wrappedSignature = (0, viem_1.encodePacked)(['bytes32', 'bytes'], [(0, validators_1.getPermissionId)(withSession), erc7739Signature]);
+    return wrappedSignature;
+}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import type { Address, Chain } from 'viem';
+import type { TransactionResult } from './execution';
+import type { BundleStatus, MetaIntent, MultiChainCompact, PostOrderBundleResult, SignedMultiChainCompact } from './orchestrator';
+import type { Call, Execution, RhinestoneAccountConfig, Session, Transaction } from './types';
+/**
+ * Initialize a Rhinestone account
+ * Note: accounts are deployed onchain only when the first transaction is sent.
+ * @param config Account config (e.g. implementation vendor, owner signers, smart sessions)
+ * @returns account
+ */
+declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promise<{
+    config: RhinestoneAccountConfig;
+    sendTransaction: (transaction: Transaction) => Promise<TransactionResult>;
+    waitForExecution: (result: TransactionResult, acceptsPreconfirmations?: boolean) => Promise<import("./orchestrator").BundleResult | {
+        actualGasCost: bigint;
+        actualGasUsed: bigint;
+        entryPoint: Address;
+        logs: import("viem").Log<bigint, number, false>[];
+        nonce: bigint;
+        paymaster?: `0x${string}` | undefined;
+        reason?: string | undefined | undefined;
+        receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
+        sender: Address;
+        success: boolean;
+        userOpHash: import("viem").Hash;
+    }>;
+    getAddress: () => `0x${string}`;
+    getPortfolio: (onTestnets?: boolean) => Promise<import("./orchestrator").UserTokenBalance[]>;
+    getMaxSpendableAmount: (chain: Chain, tokenAddress: Address, gasUnits: bigint) => Promise<bigint>;
+    deploySource: (chain: Chain) => Promise<void>;
+}>;
+export { createRhinestoneAccount };
+export type { BundleStatus, Session, Call, Execution, MetaIntent, MultiChainCompact, PostOrderBundleResult, SignedMultiChainCompact, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAA;AAE1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAOpD,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EACV,IAAI,EACJ,SAAS,EACT,uBAAuB,EACvB,OAAO,EACP,WAAW,EACZ,MAAM,SAAS,CAAA;AAEhB;;;;;GAKG;AACH,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;mCAM9B,WAAW;+BAWvC,iBAAiB;;;;;;;;;;;;;;;mCA+BlB,KAAK,gBACE,OAAO,YACX,MAAM;0BAKW,KAAK;GAanC;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAClC,YAAY,EACV,YAAY,EACZ,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,qBAAqB,EACrB,uBAAuB,GACxB,CAAA"}

package/dist/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRhinestoneAccount = createRhinestoneAccount;
+const accounts_1 = require("./accounts");
+const execution_1 = require("./execution");
+/**
+ * Initialize a Rhinestone account
+ * Note: accounts are deployed onchain only when the first transaction is sent.
+ * @param config Account config (e.g. implementation vendor, owner signers, smart sessions)
+ * @returns account
+ */
+async function createRhinestoneAccount(config) {
+    /**
+     * Sign and send a transaction
+     * @param transaction Transaction to send
+     * @returns transaction result object (a bundle ID or a UserOp hash)
+     */
+    function sendTransaction(transaction) {
+        return (0, execution_1.sendTransaction)(config, transaction);
+    }
+    /**
+     * Wait for the transaction execution onchain
+     * @param result transaction result object
+     * @param acceptsPreconfirmations whether to accept preconfirmations from relayers before the transaction lands onchain (enabled by default)
+     * @returns bundle result or a UserOp receipt
+     */
+    function waitForExecution(result, acceptsPreconfirmations = true) {
+        return (0, execution_1.waitForExecution)(config, result, acceptsPreconfirmations);
+    }
+    /**
+     * Get account address
+     * @returns Address of the smart account
+     */
+    function getAddress() {
+        return (0, accounts_1.getAddress)(config);
+    }
+    /**
+     * Get account portfolio
+     * @param onTestnets Whether to query the testnet balances (default is `false`)
+     * @returns Account balances
+     */
+    function getPortfolio(onTestnets = false) {
+        return (0, execution_1.getPortfolio)(config, onTestnets);
+    }
+    /**
+     * Get the maximum spendable token amount on the target chain
+     * @param chain Target chain
+     * @param tokenAddress Token address (on the target chain)
+     * @param gasUnits Gas cost estimate for the transaction execution
+     * @returns Maximum spendable amount in absolute units
+     */
+    function getMaxSpendableAmount(chain, tokenAddress, gasUnits) {
+        return (0, execution_1.getMaxSpendableAmount)(config, chain, tokenAddress, gasUnits);
+    }
+    function deploySource(chain) {
+        return (0, accounts_1.deploySource)(chain, config);
+    }
+    return {
+        config,
+        sendTransaction,
+        waitForExecution,
+        getAddress,
+        getPortfolio,
+        getMaxSpendableAmount,
+        deploySource,
+    };
+}

package/dist/modules/abi/smart-sessions.d.ts

@@ -0,0 +1,42 @@
+declare const enableSessionsAbi: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+        components: ({
+            name: string;
+            type: string;
+            internalType: string;
+            components?: undefined;
+        } | {
+            name: string;
+            type: string;
+            internalType: string;
+            components: ({
+                name: string;
+                type: string;
+                internalType: string;
+                components?: undefined;
+            } | {
+                name: string;
+                type: string;
+                internalType: string;
+                components: {
+                    name: string;
+                    type: string;
+                    internalType: string;
+                }[];
+            })[];
+        })[];
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];
+export { enableSessionsAbi };
+//# sourceMappingURL=smart-sessions.d.ts.map

package/dist/modules/abi/smart-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../modules/abi/smart-sessions.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8HtB,CAAA;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}