@aastar/account 0.16.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AAStar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,49 @@
+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';
+        }
+    };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi } from 'vitest';
+import { toSimpleSmartAccount } from './simple.js';
+describe('SimpleSmartAccount', () => {
+    const MOCK_OWNER = {
+        address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+        signMessage: vi.fn().mockResolvedValue('0xsignature'),
+        signTypedData: vi.fn(),
+    };
+    const MOCK_FACTORY = '0x1111111111111111111111111111111111111111';
+    const MOCK_SMART_ACCOUNT = '0x2222222222222222222222222222222222222222';
+    const MOCK_EP = '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789';
+    it('should create simple smart account wrapper', async () => {
+        const mockClient = {
+            readContract: vi.fn().mockResolvedValue(MOCK_SMART_ACCOUNT),
+            chain: { id: 31337 }
+        };
+        const account = await toSimpleSmartAccount({
+            client: mockClient,
+            owner: MOCK_OWNER,
+            factoryAddress: MOCK_FACTORY,
+            entryPoint: { address: MOCK_EP, version: '0.6' }
+        });
+        expect(account.address).toBe(MOCK_SMART_ACCOUNT);
+        expect(account.entryPoint).toBe(MOCK_EP);
+        const initCode = await account.getInitCode();
+        expect(initCode.startsWith(MOCK_FACTORY)).toBe(true);
+        const dummy = await account.getDummySignature();
+        expect(dummy).toBeDefined();
+    });
+    it('should sign user operation', async () => {
+        const mockClient = {
+            readContract: vi.fn().mockResolvedValue(MOCK_SMART_ACCOUNT),
+            chain: { id: 31337 }
+        };
+        const account = await toSimpleSmartAccount({
+            client: mockClient,
+            owner: MOCK_OWNER,
+            factoryAddress: MOCK_FACTORY,
+            entryPoint: { address: MOCK_EP, version: '0.6' }
+        });
+        const userOp = {
+            sender: MOCK_SMART_ACCOUNT,
+            nonce: 0n,
+            initCode: '0x',
+            callData: '0x',
+            accountGasLimits: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            preVerificationGas: 0n,
+            gasFees: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            paymasterAndData: '0x'
+        };
+        const sig = await account.signUserOperation(userOp);
+        expect(sig).toBe('0xsignature');
+        expect(MOCK_OWNER.signMessage).toHaveBeenCalled();
+    });
+    it('should sign message and typed data', async () => {
+        const mockClient = { readContract: vi.fn().mockResolvedValue(MOCK_SMART_ACCOUNT) };
+        const account = await toSimpleSmartAccount({
+            client: mockClient,
+            owner: MOCK_OWNER,
+            factoryAddress: MOCK_FACTORY,
+            entryPoint: { address: MOCK_EP, version: '0.6' }
+        });
+        await account.signMessage({ message: 'hello' });
+        expect(MOCK_OWNER.signMessage).toHaveBeenCalled();
+        await account.signTypedData({});
+        expect(MOCK_OWNER.signTypedData).toHaveBeenCalled();
+    });
+    it('should throw on signTransaction', async () => {
+        const mockClient = { readContract: vi.fn().mockResolvedValue(MOCK_SMART_ACCOUNT) };
+        const account = await toSimpleSmartAccount({
+            client: mockClient,
+            owner: MOCK_OWNER,
+            factoryAddress: MOCK_FACTORY,
+            entryPoint: { address: MOCK_EP, version: '0.6' }
+        });
+        await expect(account.signTransaction({})).rejects.toThrow('UserOperations');
+    });
+});

package/dist/account/src/eoa.d.ts

@@ -0,0 +1,10 @@
+import { type WalletClient, type Address, type Chain, type Transport, type Hash, type Hex } from 'viem';
+export type EOAWalletClient = WalletClient & {
+    sendTransaction: (args: {
+        to: Address;
+        value?: bigint;
+        data?: Hex;
+    }) => Promise<Hash>;
+    getAddress: () => Address;
+};
+export declare const createEOAWalletClient: (privateKey: Hex, chain: Chain, transport?: Transport) => EOAWalletClient;

package/dist/account/src/eoa.js

@@ -0,0 +1,21 @@
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+export const createEOAWalletClient = (privateKey, chain, transport = http()) => {
+    const account = privateKeyToAccount(privateKey);
+    const client = createWalletClient({
+        account,
+        chain,
+        transport
+    });
+    const baseSendTransaction = client.sendTransaction.bind(client);
+    return Object.assign(client, {
+        async sendTransaction(args) {
+            return baseSendTransaction({
+                ...args,
+                account,
+                chain
+            });
+        },
+        getAddress: () => account.address
+    });
+};

package/dist/account/src/eoa.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/account/src/eoa.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createEOAWalletClient } from './eoa.js';
+import * as viem from 'viem';
+import { mainnet } from 'viem/chains';
+vi.mock('viem', async () => {
+    const actual = await vi.importActual('viem');
+    return {
+        ...actual,
+        createWalletClient: vi.fn(),
+    };
+});
+describe('EOAWalletClient', () => {
+    const MOCK_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+    const MOCK_ADDR = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+    it('should create and use EOA wallet client', async () => {
+        const sendTransactionSpy = vi.fn().mockResolvedValue('0xhash');
+        const mockViemClient = {
+            sendTransaction: sendTransactionSpy,
+            account: { address: MOCK_ADDR }
+        };
+        viem.createWalletClient.mockReturnValue(mockViemClient);
+        const client = createEOAWalletClient(MOCK_KEY, mainnet);
+        expect(client.getAddress()).toBe(MOCK_ADDR);
+        const hash = await client.sendTransaction({ to: MOCK_ADDR, value: 100n });
+        expect(hash).toBe('0xhash');
+        expect(sendTransactionSpy).toHaveBeenCalledWith(expect.objectContaining({
+            to: MOCK_ADDR,
+            value: 100n
+        }));
+    });
+});

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

@@ -0,0 +1,19 @@
+import { type Hex, type Address } from 'viem';
+export * from './eoa.js';
+export * from './accounts/simple.js';
+/**
+ * Common Pack Logic for v0.7 UserOperations
+ */
+export declare function packUserOpLimits(high: bigint, low: bigint): Hex;
+/**
+ * Local implementation of EntryPoint v0.7 getUserOpHash
+ */
+export declare function getUserOpHash(op: any, ep: Address, chainId: number): Hex;
+/**
+ * UserOperation Client for handling high-level flows
+ */
+export declare class UserOpClient {
+    static estimateGas(bundler: any, op: any, entryPoint: Address): Promise<any>;
+    static sendUserOp(bundler: any, op: any, entryPoint: Address): Promise<any>;
+    static getReceipt(bundler: any, hash: Hex): Promise<any>;
+}

package/dist/account/src/index.js

@@ -0,0 +1,49 @@
+import { encodeAbiParameters, keccak256 } from 'viem';
+export * from './eoa.js';
+export * from './accounts/simple.js';
+/**
+ * Common Pack Logic for v0.7 UserOperations
+ */
+export function packUserOpLimits(high, low) {
+    return `0x${((high << 128n) | low).toString(16).padStart(64, '0')}`;
+}
+/**
+ * Local implementation of EntryPoint v0.7 getUserOpHash
+ */
+export function getUserOpHash(op, ep, chainId) {
+    const packed = encodeAbiParameters([
+        { type: 'address' }, { type: 'uint256' }, { type: 'bytes32' }, { type: 'bytes32' },
+        { type: 'bytes32' }, { type: 'uint256' }, { type: 'bytes32' }, { type: 'bytes32' }
+    ], [
+        op.sender, BigInt(op.nonce),
+        keccak256(op.initCode && op.initCode !== "0x" ? op.initCode : '0x'),
+        keccak256(op.callData),
+        op.accountGasLimits, BigInt(op.preVerificationGas), op.gasFees,
+        keccak256(op.paymasterAndData)
+    ]);
+    const enc = encodeAbiParameters([{ type: 'bytes32' }, { type: 'address' }, { type: 'uint256' }], [keccak256(packed), ep, BigInt(chainId)]);
+    return keccak256(enc);
+}
+/**
+ * UserOperation Client for handling high-level flows
+ */
+export class UserOpClient {
+    static async estimateGas(bundler, op, entryPoint) {
+        return bundler.request({
+            method: 'eth_estimateUserOperationGas',
+            params: [op, entryPoint]
+        });
+    }
+    static async sendUserOp(bundler, op, entryPoint) {
+        return bundler.request({
+            method: 'eth_sendUserOperation',
+            params: [op, entryPoint]
+        });
+    }
+    static async getReceipt(bundler, hash) {
+        return bundler.request({
+            method: 'eth_getUserOperationReceipt',
+            params: [hash]
+        });
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi } from 'vitest';
+import { packUserOpLimits, UserOpClient } from './index.js';
+describe('Account Utils', () => {
+    it('should pack user op limits', () => {
+        const packed = packUserOpLimits(100n, 200n);
+        expect(packed).toBeDefined();
+        expect(packed.length).toBe(66); // 0x + 64 chars
+    });
+    describe('UserOpClient', () => {
+        const mockBundler = {
+            request: vi.fn()
+        };
+        it('should estimate gas', async () => {
+            mockBundler.request.mockResolvedValue({ preVerificationGas: 1000n });
+            const res = await UserOpClient.estimateGas(mockBundler, {}, '0x1');
+            expect(res.preVerificationGas).toBe(1000n);
+        });
+        it('should send user operation', async () => {
+            mockBundler.request.mockResolvedValue('0xhash');
+            const res = await UserOpClient.sendUserOp(mockBundler, {}, '0x1');
+            expect(res).toBe('0xhash');
+        });
+        it('should get receipt', async () => {
+            mockBundler.request.mockResolvedValue({ success: true });
+            const res = await UserOpClient.getReceipt(mockBundler, '0xhash');
+            expect(res.success).toBe(true);
+        });
+    });
+});