@aastar/sdk 0.16.8 → 0.16.12

package/dist/{sdk/src/clients → clients}/operator.js

@@ -1,8 +1,7 @@
-import { createClient, publicActions, walletActions, keccak256, stringToBytes } from 'viem';
-import { stakingActions, registryActions, RegistryABI, superPaymasterActions, paymasterV4Actions, PaymasterFactoryABI, tokenActions, CORE_ADDRESSES, TEST_TOKEN_ADDRESSES, TEST_ACCOUNT_ADDRESSES, validateAddress, validateAmount, validateHex, SuperPaymasterABI } from '@aastar/core';
+import { createClient, erc20Abi, parseAbi, publicActions, walletActions, keccak256, stringToBytes } from 'viem';
+import { stakingActions, registryActions, RegistryABI, superPaymasterActions, paymasterActions, PaymasterFactoryABI, CORE_ADDRESSES, TEST_TOKEN_ADDRESSES, TEST_ACCOUNT_ADDRESSES } from '@aastar/core';
 import { RoleDataFactory } from '../utils/roleData.js';
-import { createError } from '../errors/AAStarError.js';
-import { decodeContractEvents, logDecodedEvents } from '../utils/eventDecoder.js';
+import { decodeContractError } from '../errors/decoder.js';
 export function createOperatorClient({ chain, transport, account, addresses }) {
     const client = createClient({
         chain,
@@ -15,40 +14,42 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
     const spActions = superPaymasterActions(usedAddresses.superPaymaster)(client);
     const regActions = registryActions(usedAddresses.registry)(client);
     const stkActions = stakingActions(usedAddresses.gTokenStaking)(client);
-    const p4Actions = paymasterV4Actions(usedAddresses.paymasterV4)(client);
-    const tokActions = tokenActions()(client);
+    const pmV4Actions = paymasterActions(usedAddresses.paymasterV4)(client);
     const actions = {
-        ...client,
-        ...publicActions(client),
-        ...walletActions(client),
-        ...regActions,
-        ...spActions,
-        ...p4Actions,
         ...stkActions,
-        ...tokActions,
+        ...spActions,
+        ...pmV4Actions,
+        ...regActions,
         async setup(args) {
             console.log('⚙️ Setting up operator...');
-            const txs = await this.onboardFully(args);
+            const txs = await this._onboardOperator(args);
             console.log(`✅ Operator setup complete! Transactions: ${txs.length}`);
             return { txs };
         },
         async onboardOperator(args) {
             return this.onboardFully(args);
         },
-        async onboardToSuperPaymaster(args) {
-            return this.onboardFully(args);
-        },
         async onboardFully(args) {
-            validateAmount(args.stakeAmount, 'Stake Amount');
-            validateAmount(args.depositAmount, 'Deposit Amount');
-            validateHex(args.roleId, 'Role ID');
-            if (args.gasTokens) {
-                args.gasTokens.forEach((token, index) => validateAddress(token, `Gas Token [${index}]`));
-            }
-            const results = [];
+            return this._onboardOperator(args);
+        },
+        async deployPaymasterV4({ version = 'v4.1', initData = '0x' } = {}) {
+            console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
+            const tx = await client.writeContract({
+                address: usedAddresses.paymasterFactory,
+                abi: PaymasterFactoryABI,
+                functionName: 'deployPaymaster',
+                args: [version, initData],
+                account,
+                chain
+            });
+            await client.waitForTransactionReceipt({ hash: tx });
+            return tx;
+        },
+        async _onboardOperator({ stakeAmount, depositAmount, roleId, roleData }) {
+            const txs = [];
             const accountToUse = account;
             if (!accountToUse)
-                throw createError.validation("Account", "Account required for onboarding");
+                throw new Error("Account required for onboarding");
             try {
                 // 1. Fetch Entry Burn & Approve GToken
                 console.log('   SDK: Fetching role config for entry burn...');
@@ -56,35 +57,35 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
                     address: usedAddresses.registry,
                     abi: RegistryABI,
                     functionName: 'roleConfigs',
-                    args: [args.roleId]
+                    args: [roleId]
                 });
                 const entryBurn = roleConfig[1];
-                const totalStakeNeeded = args.stakeAmount + entryBurn;
-                console.log(`   SDK: Approving GToken (Stake: ${args.stakeAmount}, Burn: ${entryBurn})...`);
-                const approveStkTx = await tokActions.tokenApprove({
-                    token: usedAddresses.gToken,
-                    spender: usedAddresses.gTokenStaking,
-                    amount: totalStakeNeeded,
-                    account: accountToUse
+                const totalStakeNeeded = stakeAmount + entryBurn;
+                console.log(`   SDK: Approving GToken (Stake: ${stakeAmount}, Burn: ${entryBurn})...`);
+                const approveGToken = await client.writeContract({
+                    address: usedAddresses.gToken,
+                    abi: erc20Abi,
+                    functionName: 'approve',
+                    args: [usedAddresses.gTokenStaking, totalStakeNeeded],
+                    account: accountToUse,
+                    chain
                 });
-                let receipt = await client.waitForTransactionReceipt({ hash: approveStkTx });
-                let events = decodeContractEvents(receipt.logs);
-                logDecodedEvents(events);
-                results.push({ hash: approveStkTx, events });
+                await client.waitForTransactionReceipt({ hash: approveGToken });
+                txs.push(approveGToken);
                 // 2. Register Role
                 let data;
-                if (args.roleData && args.roleData !== '0x') {
-                    data = args.roleData;
+                if (roleData && roleData !== '0x') {
+                    data = roleData;
                 }
                 else {
-                    console.log(`   SDK: Auto-generating roleData for roleId ${args.roleId}...`);
-                    if (args.roleId === keccak256(stringToBytes('COMMUNITY'))) {
+                    console.log(`   SDK: Auto-generating roleData for roleId ${roleId}...`);
+                    if (roleId === keccak256(stringToBytes('COMMUNITY'))) {
                         data = RoleDataFactory.community();
                     }
-                    else if (args.roleId === keccak256(stringToBytes('ENDUSER'))) {
+                    else if (roleId === keccak256(stringToBytes('ENDUSER'))) {
                         data = RoleDataFactory.endUser();
                     }
-                    else if (args.roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
+                    else if (roleId === keccak256(stringToBytes('PAYMASTER_SUPER'))) {
                         data = RoleDataFactory.paymasterSuper();
                     }
                     else {
@@ -92,88 +93,58 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
                     }
                 }
                 console.log(`   SDK: Checking if role already granted...`);
-                const hasRoleResult = await regActions.registryHasRole({
-                    user: accountToUse.address,
-                    roleId: args.roleId
+                const hasRoleResult = await client.readContract({
+                    address: usedAddresses.registry,
+                    abi: RegistryABI,
+                    functionName: 'hasRole',
+                    args: [roleId, accountToUse.address]
                 });
                 if (hasRoleResult) {
                     console.log(`   ℹ️  Role already granted, skipping registration`);
                 }
                 else {
-                    console.log(`   SDK: Registering role ${args.roleId}...`);
-                    const registerTx = await regActions.registryRegisterRoleSelf({
-                        roleId: args.roleId,
+                    console.log(`   SDK: Registering role ${roleId}...`);
+                    const registerTx = await actions.registerRoleSelf({
+                        roleId,
                         data,
                         account: accountToUse
                     });
-                    const receipt = await client.waitForTransactionReceipt({ hash: registerTx });
-                    const events = decodeContractEvents(receipt.logs);
-                    logDecodedEvents(events);
-                    results.push({ hash: registerTx, events });
+                    await client.waitForTransactionReceipt({ hash: registerTx });
+                    txs.push(registerTx);
                 }
-                // 3. Deposit aPNTs
-                if (args.depositAmount > 0n) {
-                    console.log('   SDK: Depositing aPNTs via superPaymasterDepositFor...');
-                    const depositTx = await spActions.superPaymasterDepositFor({
-                        operator: accountToUse.address,
-                        amount: args.depositAmount,
-                        account: accountToUse
+                if (depositAmount > 0n) {
+                    console.log('   SDK: Depositing aPNTs via depositFor...');
+                    const depositTx = await client.writeContract({
+                        address: usedAddresses.superPaymaster,
+                        abi: parseAbi(['function depositFor(address targetOperator, uint256 amount) external']),
+                        functionName: 'depositFor',
+                        args: [accountToUse.address, depositAmount],
+                        account: accountToUse,
+                        chain
                     });
-                    const receipt = await client.waitForTransactionReceipt({ hash: depositTx });
-                    const events = decodeContractEvents(receipt.logs);
-                    logDecodedEvents(events);
-                    results.push({ hash: depositTx, events });
+                    await client.waitForTransactionReceipt({ hash: depositTx });
+                    txs.push(depositTx);
                 }
-                return results;
+                return txs;
             }
             catch (error) {
-                // const decodedMsg = decodeContractError(error);
-                // throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
-                throw error;
+                const decodedMsg = decodeContractError(error);
+                throw decodedMsg ? new Error(`Onboarding Failed: ${decodedMsg}`) : error;
             }
         },
-        async deployPaymasterV4({ version = 'v4.1', initData = '0x' } = {}) {
-            console.log(`   SDK: Deploying Paymaster V4 (${version})...`);
-            const tx = await client.writeContract({
-                address: usedAddresses.paymasterFactory,
-                abi: PaymasterFactoryABI,
-                functionName: 'deployPaymaster',
-                args: [version, initData],
-                account,
-                chain
-            });
-            await client.waitForTransactionReceipt({ hash: tx });
-            return tx;
+        async onboardToSuperPaymaster(args) {
+            return this.onboardOperator(args);
         },
         async configureOperator({ xPNTsToken, treasury, exchangeRate, account: accountOverride }) {
-            validateAddress(xPNTsToken, 'xPNTs Token');
-            validateAddress(treasury, 'Treasury');
-            validateAmount(exchangeRate, 'Exchange Rate');
-            const tx = await spActions.superPaymasterConfigureOperator({
+            const tx = await spActions.configureOperator({
                 xPNTsToken,
-                treasury,
+                opTreasury: treasury,
                 exchangeRate,
                 account: accountOverride || account
             });
             await client.waitForTransactionReceipt({ hash: tx });
             return tx;
         },
-        async checkReadiness() {
-            if (!account)
-                throw createError.validation("Account", "Account required for readiness check");
-            const addr = account.address;
-            const roleId = keccak256(stringToBytes('PAYMASTER_SUPER'));
-            const roleStatus = await regActions.registryHasRole({ user: addr, roleId });
-            const operatorData = await spActions.superPaymasterOperators({ operator: addr });
-            // operators(address) returns (uint128 aPNTsBalance, uint96 exchangeRate, bool isConfigured, bool isPaused, ...)
-            return {
-                isRegistered: roleStatus,
-                isConfigured: operatorData[2],
-                collateralBalance: operatorData[0],
-                isPaused: operatorData[3],
-                roleStatus
-            };
-        },
         async getOperatorStatus(accountAddress) {
             try {
                 const hasRole = await client.readContract({
@@ -186,9 +157,10 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
                 let superPaymasterInfo = null;
                 let paymasterV4Info = null;
                 if (hasRole && usedAddresses.superPaymaster) {
+                    const pmAbi = parseAbi(['function operators(address) view returns (uint128 balance, uint96 exchangeRate, bool isConfigured, bool isPaused, address token, uint32 reputation, address treasury, uint256 spent, uint256 txSponsored)']);
                     const operatorData = await client.readContract({
                         address: usedAddresses.superPaymaster,
-                        abi: SuperPaymasterABI,
+                        abi: pmAbi,
                         functionName: 'operators',
                         args: [accountAddress]
                     });
@@ -206,9 +178,10 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
                 // 检查 Paymaster V4 (Direct)
                 if (usedAddresses.paymasterFactory && usedAddresses.paymasterFactory !== '0x0000000000000000000000000000000000000000') {
                     try {
+                        const factoryAbi = parseAbi(['function getPaymasterByOperator(address) view returns (address)']);
                         const pmAddr = await client.readContract({
                             address: usedAddresses.paymasterFactory,
-                            abi: PaymasterFactoryABI,
+                            abi: factoryAbi,
                             functionName: 'getPaymasterByOperator',
                             args: [accountAddress]
                         });
@@ -230,17 +203,6 @@ export function createOperatorClient({ chain, transport, account, addresses }) {
                 console.error('Error in getOperatorStatus:', error);
                 return { type: null, superPaymaster: null, paymasterV4: null };
             }
-        },
-        async isOperator(operator) {
-            const data = await spActions.superPaymasterOperators({ operator });
-            return data[2]; // isConfigured
-        },
-        async getDepositDetails() {
-            const deposit = await spActions.superPaymasterGetDeposit();
-            return { deposit };
-        },
-        async deposit(args) {
-            return this.superPaymasterDeposit(args);
         }
     };
     return Object.assign(client, actions);

package/dist/errors/decoder.d.ts

@@ -0,0 +1,6 @@
+export declare const CustomErrors: {
+    readonly RoleNotConfigured: "RoleNotConfigured(bytes32,bool)";
+    readonly RoleAlreadyGranted: "RoleAlreadyGranted(bytes32,address)";
+    readonly InsufficientStake: "InsufficientStake(uint256,uint256)";
+};
+export declare function decodeContractError(error: any): string | null;

package/dist/errors/decoder.js

@@ -0,0 +1,44 @@
+import { decodeErrorResult } from 'viem';
+import { RegistryABI } from '../index.js'; // Assuming RegistryABI is exported
+export const CustomErrors = {
+    RoleNotConfigured: 'RoleNotConfigured(bytes32,bool)',
+    RoleAlreadyGranted: 'RoleAlreadyGranted(bytes32,address)',
+    InsufficientStake: 'InsufficientStake(uint256,uint256)',
+};
+export function decodeContractError(error) {
+    if (!error || typeof error !== 'object')
+        return null;
+    // Check if it's a viem ContractFunctionExecutionError
+    if (error.name === 'ContractFunctionExecutionError' || error.walk) {
+        // Try to extract internal error data
+        const internalError = error.walk ? error.walk((e) => e.data) : error;
+        const data = internalError?.data;
+        if (data) {
+            try {
+                const decoded = decodeErrorResult({
+                    abi: RegistryABI,
+                    data: data
+                });
+                if (decoded.errorName === 'RoleNotConfigured') {
+                    const [roleId, isActive] = decoded.args;
+                    return `RoleNotConfigured: Role ${roleId} is ${isActive ? 'ACTIVE' : 'INACTIVE'} in Registry.`;
+                }
+                if (decoded.errorName === 'RoleAlreadyGranted') {
+                    const [roleId, user] = decoded.args;
+                    return `RoleAlreadyGranted: User ${user} already has role ${roleId}.`;
+                }
+                if (decoded.errorName === 'InsufficientStake') {
+                    const [stake, minStake] = decoded.args;
+                    // Viem returns bigints, format them?
+                    return `InsufficientStake: Provided ${stake}, Required ${minStake}.`;
+                }
+                return `${decoded.errorName}: ${decoded.args}`;
+            }
+            catch (e) {
+                // ABI mismatch or unknown error
+                return null;
+            }
+        }
+    }
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from '@aastar/core';
+export * from '@aastar/account';
+export * from '@aastar/paymaster';
+export * from '@aastar/identity';
+export * from '@aastar/tokens';
+export * from '@aastar/tokens';
+export * from '@aastar/dapp';
+export * from './clients/endUser.js';
+export * from './clients/operator.js';
+export * from './clients/community.js';
+export * from './clients/admin.js';
+export * from './clients/ExperimentClient.js';
+export * from './utils/roleData.js';
+export * from './utils/keys.js';
+export * from './utils/funding.js';
+export * from './utils/userOp.js';
+export * from './utils/testScenarios.js';
+export * from './errors/decoder.js';

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from '@aastar/core';
+export * from '@aastar/account';
+export * from '@aastar/paymaster';
+export * from '@aastar/identity';
+export * from '@aastar/tokens';
+export * from '@aastar/tokens';
+export * from '@aastar/dapp';
+// export * from '@aastar/enduser'; // Commented to avoid CommunityClient conflict with clients/community.js
+// Export Role-Based Clients
+export * from './clients/endUser.js';
+export * from './clients/operator.js';
+export * from './clients/community.js';
+export * from './clients/admin.js';
+export * from './clients/ExperimentClient.js';
+// Export Utils & Errors
+export * from './utils/roleData.js';
+export * from './utils/keys.js';
+export * from './utils/funding.js';
+export * from './utils/userOp.js';
+export * from './utils/testScenarios.js';
+export * from './errors/decoder.js';

package/dist/{sdk/src/utils → utils}/keys.d.ts

@@ -1,11 +1,4 @@
 import type { Hex, Address } from 'viem';
-/**
- * ⚠️ WARNING: TESTING & NODE.JS UTILITY ONLY ⚠️
- *
- * This file uses Node.js 'fs' module and is NOT compatible with browsers.
- * It is intended for use in test scripts, CLI tools, and backend environments only.
- * DO NOT import this file in frontend/browser code.
- */
 /**
  * 密钥对接口
  */
@@ -66,8 +59,3 @@ export declare class KeyManager {
      */
     static printKeys(keys: KeyPair[], showPrivateKey?: boolean): void;
 }
-/**
- * 解析私钥，确保其带有 0x 前缀
- * @param key - 私钥字符串
- */
-export declare function parseKey(key: string): Hex;

package/dist/{sdk/src/utils → utils}/keys.js

@@ -128,10 +128,3 @@ export class KeyManager {
         console.log('─'.repeat(80));
     }
 }
-/**
- * 解析私钥，确保其带有 0x 前缀
- * @param key - 私钥字符串
- */
-export function parseKey(key) {
-    return (key.startsWith('0x') ? key : `0x${key}`);
-}

package/dist/{sdk/src/utils → utils}/roleData.js

@@ -83,14 +83,21 @@ export const RoleDataFactory = {
                 ]
             }], data);
         const result = decoded[0];
-        return {
-            name: result.name,
-            ensName: result.ensName,
-            website: result.website,
-            description: result.description,
-            logoURI: result.logoURI,
-            stakeAmount: result.stakeAmount
-        };
+        // Check if result is array (iterable) or object
+        if (Array.isArray(result)) {
+            const [n, e, w, d, l, s] = result;
+            return { name: n, ensName: e, website: w, description: d, logoURI: l, stakeAmount: s };
+        }
+        else {
+            return {
+                name: result.name,
+                ensName: result.ensName,
+                website: result.website,
+                description: result.description,
+                logoURI: result.logoURI,
+                stakeAmount: result.stakeAmount
+            };
+        }
     },
     decodeEndUser: (data) => {
         const decoded = decodeAbiParameters([{
@@ -104,12 +111,18 @@ export const RoleDataFactory = {
                 ]
             }], data);
         const result = decoded[0];
-        return {
-            account: result.account,
-            community: result.community,
-            avatarURI: result.avatarURI,
-            ensName: result.ensName,
-            stakeAmount: result.stakeAmount
-        };
+        if (Array.isArray(result)) {
+            const [a, c, av, en, s] = result;
+            return { account: a, community: c, avatarURI: av, ensName: en, stakeAmount: s };
+        }
+        else {
+            return {
+                account: result.account,
+                community: result.community,
+                avatarURI: result.avatarURI,
+                ensName: result.ensName,
+                stakeAmount: result.stakeAmount
+            };
+        }
     }
 };

package/dist/{sdk/src/utils → utils}/testScenarios.js

@@ -13,7 +13,7 @@ export class UserOpScenarioBuilder {
      * Builds a signed PackedUserOperation for a token transfer based on the specified scenario.
      */
     static async buildTransferScenario(type, params) {
-        const { sender, ownerAccount, recipient, tokenAddress, amount, entryPoint, chainId, publicClient, paymaster, operator, paymasterGasLimit = 300000n, paymasterPostOpGasLimit = 50000n, nonceKey = 0n, gasToken } = params;
+        const { sender, ownerAccount, recipient, tokenAddress, amount, entryPoint, chainId, publicClient, paymaster, operator, paymasterGasLimit = 100000n, paymasterPostOpGasLimit = 40000n, nonceKey = 0n, gasToken } = params;
         // 1. Build Token Transfer CallData
         const transferData = encodeFunctionData({
             abi: [{ name: 'transfer', type: 'function', inputs: [{ type: 'address', name: 'to' }, { type: 'uint256', name: 'amount' }], outputs: [{ type: 'bool' }] }],

package/dist/{sdk/src/utils → utils}/userOp.js

@@ -99,16 +99,16 @@ export class UserOperationBuilder {
             paymasterAndData: userOp.paymasterAndData,
             signature: userOp.signature
         };
+        // Ensure all numeric fields are hex strings and padded
+        // Helper to ensure '0x' prefix and valid hex string
         const toCompactHex = (val) => {
             if (typeof val === 'bigint')
                 return `0x${val.toString(16)}`;
             if (typeof val === 'number')
                 return `0x${val.toString(16)}`;
             if (typeof val === 'string') {
-                // Remove leading zeros if present (but keep 0x)
                 if (val === '0x')
-                    return '0x'; // invalid quantity? Should be 0x0?
-                // JSON-RPC Quantity: 0x0
+                    return '0x0';
                 if (val === '0x0')
                     return '0x0';
                 return val.replace(/^0x0+(?!$)/, '0x');
@@ -117,11 +117,6 @@ export class UserOperationBuilder {
         };
         result.nonce = toCompactHex(result.nonce);
         result.preVerificationGas = toCompactHex(result.preVerificationGas);
-        // Note: Alchemy usually accepts non-padded Quantities for nonce/preVerificationGas.
-        // But let's verify if strict padding is required by using viem's pad
-        // Alchemy v0.7 Validator seems to reject PADDED Quantities (leads to 'Invalid fields').
-        // It accepts COMPACT HEX (e.g. 0x1 instead of 0x0...01).
-        // Viem toHex produces compact hex.
         return result;
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aastar/sdk",
-  "version": "0.16.8",
+  "version": "0.16.12",
   "description": "AAStar SDK - The all-in-one package for Mycelium Network",
   "type": "module",
   "publishConfig": {
@@ -9,40 +9,26 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist",
-    "scripts",
-    "examples"
+    "dist"
   ],
   "dependencies": {
     "viem": "2.43.3",
-    "dotenv": "17.2.3",
-    "@aastar/account": "0.16.8",
-    "@aastar/identity": "0.16.8",
-    "@aastar/core": "0.16.8",
-    "@aastar/tokens": "0.16.8",
-    "@aastar/paymaster": "0.16.8",
-    "@aastar/dapp": "0.16.8"
+    "@aastar/dapp": "0.16.12",
+    "@aastar/account": "0.16.12",
+    "@aastar/enduser": "0.16.12",
+    "@aastar/paymaster": "0.16.12",
+    "@aastar/tokens": "0.16.12",
+    "@aastar/core": "0.16.12",
+    "@aastar/identity": "0.16.12"
   },
   "devDependencies": {
     "typescript": "5.7.2"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./node": {
-      "types": "./dist/node/index.d.ts",
-      "import": "./dist/node/index.js"
-    }
-  },
-  "license": "MIT",
   "scripts": {
     "clean": "find src -name '*.js' -o -name '*.d.ts' -o -name '*.map' | xargs rm -f",
     "prebuild": "pnpm clean",
     "build": "tsc",
-    "lint": "ESLINT_USE_FLAT_CONFIG=false eslint src --ext .ts",
-    "lint:fix": "ESLINT_USE_FLAT_CONFIG=false eslint src --ext .ts --fix",
-    "example:local": "tsx examples/regression_test.ts"
+    "example:local": "tsx examples/regression_test.ts",
+    "test": "vitest run"
   }
 }

package/dist/account/src/accounts/simple.d.ts

@@ -1,18 +0,0 @@
-import { type Address, type Hex, type LocalAccount } from 'viem';
-export type SimpleSmartAccount = LocalAccount & {
-    signUserOperation: (userOp: any) => Promise<Hex>;
-    getInitCode: () => Promise<Hex>;
-    getDummySignature: () => Promise<Hex>;
-    entryPoint: Address;
-};
-export declare function toSimpleSmartAccount(parameters: {
-    client: any;
-    owner: LocalAccount;
-    factoryAddress: Address;
-    entryPoint: {
-        address: Address;
-        version: '0.6' | '0.7';
-    };
-    salt?: bigint;
-    index?: bigint;
-}): Promise<SimpleSmartAccount>;

package/dist/account/src/accounts/simple.js

@@ -1,49 +0,0 @@
-import { concatHex, encodeFunctionData, } from 'viem';
-import { SimpleAccountFactoryABI } from '@aastar/core';
-import { getUserOpHash } from '../index.js';
-export async function toSimpleSmartAccount(parameters) {
-    const { client, owner, factoryAddress, entryPoint, index = 0n, salt = 0n } = parameters;
-    // Calculate initCode
-    const factoryData = encodeFunctionData({
-        abi: SimpleAccountFactoryABI,
-        functionName: 'createAccount',
-        args: [owner.address, salt]
-    });
-    const initCode = concatHex([factoryAddress, factoryData]);
-    // Calculate counterfactual address
-    const address = await client.readContract({
-        address: factoryAddress,
-        abi: SimpleAccountFactoryABI,
-        functionName: 'getAddress',
-        args: [owner.address, salt]
-    });
-    return {
-        address,
-        publicKey: owner.address,
-        source: 'custom',
-        type: 'local',
-        entryPoint: entryPoint.address,
-        async signMessage({ message }) {
-            // validating signature for smart account usually involves EIP-1271, 
-            // but here we just sign with owner for SimpleAccount which validates owner sig
-            return owner.signMessage({ message });
-        },
-        async signTypedData(typedData) {
-            return owner.signTypedData(typedData);
-        },
-        async signTransaction(transaction) {
-            throw new Error('Smart Accounts cannot sign transactions directly. Use UserOperations.');
-        },
-        async signUserOperation(userOp) {
-            const chainId = client.chain?.id || 31337; // Default to local anvil if not found
-            const hash = getUserOpHash(userOp, entryPoint.address, chainId);
-            return owner.signMessage({ message: { raw: hash } });
-        },
-        async getInitCode() {
-            return initCode;
-        },
-        async getDummySignature() {
-            return '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
-        }
-    };
-}