@aastar/sdk 0.16.11 → 0.16.14

package/dist/utils/funding.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi } from 'vitest';
+import { FundingManager } from './funding.js';
+import { parseEther } from 'viem';
+vi.mock('viem', async () => {
+    const actual = await vi.importActual('viem');
+    return {
+        ...actual,
+        createPublicClient: vi.fn(() => ({
+            getBalance: vi.fn().mockResolvedValue(parseEther('1')),
+            readContract: vi.fn().mockResolvedValue(parseEther('100')),
+            simulateContract: vi.fn().mockResolvedValue({ request: {} }),
+            waitForTransactionReceipt: vi.fn().mockResolvedValue({ status: 'success' })
+        })),
+        createWalletClient: vi.fn(() => ({
+            sendTransaction: vi.fn().mockResolvedValue('0xhash'),
+            writeContract: vi.fn().mockResolvedValue('0xhash'),
+            account: { address: '0xsupplier' }
+        })),
+        http: vi.fn()
+    };
+});
+describe('FundingManager', () => {
+    const params = {
+        rpcUrl: 'http://localhost:8545',
+        chain: { id: 1 },
+        supplierKey: '0x1234567890123456789012345678901234567890123456789012345678901234',
+        targetAddress: '0x1111111111111111111111111111111111111111'
+    };
+    it('should fund with ETH', async () => {
+        const result = await FundingManager.fundWithETH({ ...params, amount: '0.1' });
+        expect(result.success).toBe(true);
+        expect(result.txHash).toBe('0xhash');
+    });
+    it('should fund with Token', async () => {
+        const result = await FundingManager.fundWithToken({
+            ...params,
+            tokenAddress: '0x2222222222222222222222222222222222222222',
+            amount: '100'
+        });
+        expect(result.success).toBe(true);
+    });
+    it('should ensure funding when below threshold', async () => {
+        const results = await FundingManager.ensureFunding({
+            ...params,
+            minETH: '2.0',
+            targetETH: '1.0'
+        });
+        expect(results[0].txHash).toBe('0xhash');
+    });
+    it('should batch fund ETH', async () => {
+        const results = await FundingManager.batchFundETH(params, [
+            { address: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', amount: '0.1' },
+            { address: '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', amount: '0.2' }
+        ]);
+        expect(results).toHaveLength(2);
+        expect(results[0].success).toBe(true);
+    });
+    it('should get ETH balance', async () => {
+        const balance = await FundingManager.getETHBalance(params);
+        expect(balance).toBe(parseEther('1'));
+    });
+    it('should get Token balance', async () => {
+        const balance = await FundingManager.getTokenBalance(params, '0x2222222222222222222222222222222222222222');
+        expect(balance).toBe(parseEther('100'));
+    });
+    it('should batch fund Token', async () => {
+        const results = await FundingManager.batchFundToken(params, '0x2222222222222222222222222222222222222222', [
+            { address: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', amount: '100' },
+            { address: '0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB', amount: '200' }
+        ]);
+        expect(results).toHaveLength(2);
+    });
+    it('should handle ensure funding with token', async () => {
+        const results = await FundingManager.ensureFunding({
+            ...params,
+            minETH: '0.5',
+            targetETH: '1.0',
+            token: {
+                address: '0x2222222222222222222222222222222222222222',
+                minBalance: '50',
+                targetAmount: '100'
+            }
+        });
+        expect(results.length).toBeGreaterThan(0);
+    });
+    it('should handle ETH funding errors', async () => {
+        vi.spyOn(FundingManager, 'createClients').mockReturnValueOnce({
+            publicClient: {},
+            walletClient: { sendTransaction: vi.fn().mockRejectedValue(new Error('Network error')) },
+            account: {}
+        });
+        const result = await FundingManager.fundWithETH({ ...params, amount: '0.1' });
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('Network error');
+    });
+    it('should handle Token funding errors', async () => {
+        vi.spyOn(FundingManager, 'createClients').mockReturnValueOnce({
+            publicClient: { simulateContract: vi.fn().mockRejectedValue(new Error('Insufficient balance')) },
+            walletClient: {},
+            account: {}
+        });
+        const result = await FundingManager.fundWithToken({ ...params, tokenAddress: '0x2222222222222222222222222222222222222222', amount: '100' });
+        expect(result.success).toBe(false);
+    });
+});

package/dist/utils/keys.d.ts

@@ -0,0 +1,61 @@
+import type { Hex, Address } from 'viem';
+/**
+ * 密钥对接口
+ */
+export interface KeyPair {
+    name: string;
+    privateKey: Hex;
+    address: Address;
+}
+/**
+ * 密钥管理器
+ * 提供密钥生成、存储、加载等工具函数
+ */
+export declare class KeyManager {
+    /**
+     * 生成单个密钥对
+     * @param name - 密钥名称（如 'Jason', 'Anni'）
+     */
+    static generateKeyPair(name: string): KeyPair;
+    /**
+     * 批量生成密钥对
+     * @param names - 密钥名称数组
+     */
+    static generateKeyPairs(names: string[]): KeyPair[];
+    /**
+     * 生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）
+     * @param count - 数量
+     * @param prefix - 名称前缀（默认 'Operator'）
+     */
+    static generateMultiple(count: number, prefix?: string): KeyPair[];
+    /**
+     * 保存密钥到 .env 文件
+     * @param filePath - 文件路径（绝对路径）
+     * @param keys - 密钥对数组
+     * @param overwrite - 是否覆盖已存在的文件（默认 false）
+     */
+    static saveToEnvFile(filePath: string, keys: KeyPair[], overwrite?: boolean): void;
+    /**
+     * 从 .env 文件加载密钥
+     * @param filePath - 文件路径（绝对路径）
+     * @returns 密钥对数组
+     */
+    static loadFromEnvFile(filePath: string): KeyPair[];
+    /**
+     * 保存密钥到 JSON 文件（包含地址信息）
+     * @param filePath - 文件路径（绝对路径）
+     * @param keys - 密钥对数组
+     * @param overwrite - 是否覆盖已存在的文件（默认 false）
+     */
+    static saveToJsonFile(filePath: string, keys: KeyPair[], overwrite?: boolean): void;
+    /**
+     * 从 JSON 文件加载密钥
+     * @param filePath - 文件路径（绝对路径）
+     */
+    static loadFromJsonFile(filePath: string): KeyPair[];
+    /**
+     * 打印密钥信息（隐藏私钥）
+     * @param keys - 密钥对数组
+     */
+    static printKeys(keys: KeyPair[], showPrivateKey?: boolean): void;
+}

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

@@ -1,17 +1,5 @@
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
-import type { Hex, Address } from 'viem';
 import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * 密钥对接口
- */
-export interface KeyPair {
-    name: string;
-    privateKey: Hex;
-    address: Address;
-}
-
 /**
  * 密钥管理器
  * 提供密钥生成、存储、加载等工具函数
@@ -21,7 +9,7 @@ export class KeyManager {
      * 生成单个密钥对
      * @param name - 密钥名称（如 'Jason', 'Anni'）
      */
-    static generateKeyPair(name: string): KeyPair {
+    static generateKeyPair(name) {
         const privateKey = generatePrivateKey();
         const account = privateKeyToAccount(privateKey);
         return {
@@ -30,63 +18,52 @@ export class KeyManager {
             address: account.address
         };
     }
-
     /**
      * 批量生成密钥对
      * @param names - 密钥名称数组
      */
-    static generateKeyPairs(names: string[]): KeyPair[] {
+    static generateKeyPairs(names) {
         return names.map(name => this.generateKeyPair(name));
     }
-
     /**
      * 生成指定数量的密钥对（自动命名为 Operator_1, Operator_2, ...）
      * @param count - 数量
      * @param prefix - 名称前缀（默认 'Operator'）
      */
-    static generateMultiple(count: number, prefix: string = 'Operator'): KeyPair[] {
+    static generateMultiple(count, prefix = 'Operator') {
         const names = Array.from({ length: count }, (_, i) => `${prefix}_${i + 1}`);
         return this.generateKeyPairs(names);
     }
-
     /**
      * 保存密钥到 .env 文件
      * @param filePath - 文件路径（绝对路径）
      * @param keys - 密钥对数组
      * @param overwrite - 是否覆盖已存在的文件（默认 false）
      */
-    static saveToEnvFile(filePath: string, keys: KeyPair[], overwrite: boolean = false): void {
+    static saveToEnvFile(filePath, keys, overwrite = false) {
         if (fs.existsSync(filePath) && !overwrite) {
             throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
         }
-
-        const content = keys.map(k => 
-            `${k.name.toUpperCase().replace(/\s+/g, '_')}_PRIVATE_KEY=${k.privateKey}`
-        ).join('\n') + '\n';
-
+        const content = keys.map(k => `${k.name.toUpperCase().replace(/\s+/g, '_')}_PRIVATE_KEY=${k.privateKey}`).join('\n') + '\n';
         fs.writeFileSync(filePath, content, { mode: 0o600 }); // 仅所有者可读写
         console.log(`✅ Keys saved to ${filePath} (${keys.length} keys)`);
     }
-
     /**
      * 从 .env 文件加载密钥
      * @param filePath - 文件路径（绝对路径）
      * @returns 密钥对数组
      */
-    static loadFromEnvFile(filePath: string): KeyPair[] {
+    static loadFromEnvFile(filePath) {
         if (!fs.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
         }
-
         const content = fs.readFileSync(filePath, 'utf-8');
         const lines = content.split('\n').filter(line => line.trim() && !line.startsWith('#'));
-        
         return lines.map(line => {
             const [key, value] = line.split('=');
             const name = key.replace(/_PRIVATE_KEY$/, '').toLowerCase().replace(/_/g, ' ');
-            const privateKey = value.trim() as Hex;
+            const privateKey = value.trim();
             const account = privateKeyToAccount(privateKey);
-            
             return {
                 name,
                 privateKey,
@@ -94,18 +71,16 @@ export class KeyManager {
             };
         });
     }
-
     /**
      * 保存密钥到 JSON 文件（包含地址信息）
      * @param filePath - 文件路径（绝对路径）
      * @param keys - 密钥对数组
      * @param overwrite - 是否覆盖已存在的文件（默认 false）
      */
-    static saveToJsonFile(filePath: string, keys: KeyPair[], overwrite: boolean = false): void {
+    static saveToJsonFile(filePath, keys, overwrite = false) {
         if (fs.existsSync(filePath) && !overwrite) {
             throw new Error(`File already exists: ${filePath}. Set overwrite=true to replace.`);
         }
-
         const data = {
             generated: new Date().toISOString(),
             keys: keys.map(k => ({
@@ -114,35 +89,30 @@ export class KeyManager {
                 address: k.address
             }))
         };
-
         fs.writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
         console.log(`✅ Keys saved to ${filePath} (${keys.length} keys)`);
     }
-
     /**
      * 从 JSON 文件加载密钥
      * @param filePath - 文件路径（绝对路径）
      */
-    static loadFromJsonFile(filePath: string): KeyPair[] {
+    static loadFromJsonFile(filePath) {
         if (!fs.existsSync(filePath)) {
             throw new Error(`File not found: ${filePath}`);
         }
-
         const content = fs.readFileSync(filePath, 'utf-8');
         const data = JSON.parse(content);
-        
-        return data.keys.map((k: any) => ({
+        return data.keys.map((k) => ({
             name: k.name,
-            privateKey: k.privateKey as Hex,
-            address: k.address as Address
+            privateKey: k.privateKey,
+            address: k.address
         }));
     }
-
     /**
      * 打印密钥信息（隐藏私钥）
      * @param keys - 密钥对数组
      */
-    static printKeys(keys: KeyPair[], showPrivateKey: boolean = false): void {
+    static printKeys(keys, showPrivateKey = false) {
         console.log('\n🔑 Generated Keys:');
         console.log('─'.repeat(80));
         keys.forEach((k, i) => {
@@ -150,7 +120,8 @@ export class KeyManager {
             console.log(`   Address: ${k.address}`);
             if (showPrivateKey) {
                 console.log(`   Private Key: ${k.privateKey}`);
-            } else {
+            }
+            else {
                 console.log(`   Private Key: ${k.privateKey.slice(0, 10)}...${k.privateKey.slice(-8)}`);
             }
         });

package/dist/utils/keys.test.d.ts

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

package/dist/utils/keys.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { KeyManager, parseKey } from './keys.js';
+import * as fs from 'fs';
+import { isAddress } from 'viem';
+vi.mock('fs');
+describe('KeyManager', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should generate a single key pair', () => {
+        const key = KeyManager.generateKeyPair('Test');
+        expect(key.name).toBe('Test');
+        expect(key.privateKey).toMatch(/^0x/);
+        expect(isAddress(key.address)).toBe(true);
+    });
+    it('should generate multiple key pairs', () => {
+        const keys = KeyManager.generateMultiple(3, 'Op');
+        expect(keys.length).toBe(3);
+        expect(keys[0].name).toBe('Op_1');
+        expect(keys[2].name).toBe('Op_3');
+    });
+    it('should save keys to env file', () => {
+        const keys = [
+            { name: 'Admin', privateKey: '0x1', address: '0x1' }
+        ];
+        fs.existsSync.mockReturnValue(false);
+        KeyManager.saveToEnvFile('/mock/.env', keys);
+        expect(fs.writeFileSync).toHaveBeenCalledWith('/mock/.env', expect.stringContaining('ADMIN_PRIVATE_KEY=0x1'), expect.objectContaining({ mode: 0o600 }));
+    });
+    it('should load keys from env file', () => {
+        const mockEnv = 'ADMIN_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80\n';
+        fs.existsSync.mockReturnValue(true);
+        fs.readFileSync.mockReturnValue(mockEnv);
+        const keys = KeyManager.loadFromEnvFile('/mock/.env');
+        expect(keys.length).toBe(1);
+        expect(keys[0].name).toBe('admin');
+        expect(keys[0].privateKey).toBe('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80');
+    });
+    it('should save and load keys from json file', () => {
+        const keys = [
+            { name: 'Test', privateKey: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80', address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266' }
+        ];
+        fs.existsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+        fs.readFileSync.mockReturnValue(JSON.stringify({ keys }));
+        KeyManager.saveToJsonFile('/mock/keys.json', keys);
+        expect(fs.writeFileSync).toHaveBeenCalled();
+        const loaded = KeyManager.loadFromJsonFile('/mock/keys.json');
+        expect(loaded).toEqual(keys);
+    });
+    it('should parse keys with and without prefix', () => {
+        expect(parseKey('abc')).toBe('0xabc');
+        expect(parseKey('0xabc')).toBe('0xabc');
+    });
+    it('should throw if json file exists and overwrite is false', () => {
+        fs.existsSync.mockReturnValue(true);
+        expect(() => KeyManager.saveToJsonFile('/mock/keys.json', [], false)).toThrow(/File already exists/);
+    });
+    it('should throw if json file not found', () => {
+        fs.existsSync.mockReturnValue(false);
+        expect(() => KeyManager.loadFromJsonFile('/mock/missing.json')).toThrow(/File not found/);
+    });
+    it('should print keys with masked private key', () => {
+        const consoleSpy = vi.spyOn(console, 'log');
+        const keys = [
+            { name: 'Admin', privateKey: '0x1234567890123456789012345678901234567890', address: '0xAddress' }
+        ];
+        KeyManager.printKeys(keys, false);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Generated Keys'));
+        // Check for masked key format (start...end)
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/Private Key: 0x12345678\.\.\.34567890/));
+        expect(consoleSpy).not.toHaveBeenCalledWith(expect.stringContaining('0x1234567890123456789012345678901234567890'));
+    });
+    it('should print keys with full private key', () => {
+        const consoleSpy = vi.spyOn(console, 'log');
+        const keys = [
+            { name: 'Admin', privateKey: '0x1234567890123456789012345678901234567890', address: '0xAddress' }
+        ];
+        KeyManager.printKeys(keys, true);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('0x1234567890123456789012345678901234567890'));
+    });
+});

package/dist/utils/roleData.d.ts

@@ -0,0 +1,66 @@
+import { type Hex, type Address } from 'viem';
+export declare const RoleIds: {
+    readonly PAYMASTER_SUPER: `0x${string}`;
+    readonly DVT: `0x${string}`;
+    readonly PAYMASTER_AOA: `0x${string}`;
+    readonly KMS: `0x${string}`;
+    readonly COMMUNITY: `0x${string}`;
+    readonly ENDUSER: `0x${string}`;
+    readonly ANODE: `0x${string}`;
+};
+export type RoleId = typeof RoleIds[keyof typeof RoleIds];
+export declare const RoleDataFactory: {
+    /**
+     * Data for SuperPaymaster Operator (Empty)
+     */
+    paymasterSuper: () => Hex;
+    /**
+     * Data for Generic DVT Role (Empty)
+     */
+    dvt: () => Hex;
+    /**
+     * Data for Community Registration (matches Registry.sol CommunityRoleData)
+     * NOTE: Solidity's abi.encode(struct) adds a 32-byte offset prefix (0x20)
+     * which is required for abi.decode(struct) to work correctly.
+     *
+     * @param params.name Community Name (defaults to 'TestCommunity')
+     * @param params.ensName ENS name (optional)
+     * @param params.website Website URL (optional)
+     * @param params.description Community description (optional)
+     * @param params.logoURI Logo URI string (optional)
+     * @param params.stakeAmount Stake amount (defaults to 0)
+     */
+    community: (params?: {
+        name?: string;
+        ensName?: string;
+        website?: string;
+        description?: string;
+        logoURI?: string;
+        stakeAmount?: bigint;
+    }) => Hex;
+    /**
+     * Data for EndUser (matches Registry.sol EndUserRoleData)
+     */
+    endUser: (params?: {
+        account?: Address;
+        community?: Address;
+        avatarURI?: string;
+        ensName?: string;
+        stakeAmount?: bigint;
+    }) => Hex;
+    decodeCommunity: (data: Hex) => {
+        name: any;
+        ensName: any;
+        website: any;
+        description: any;
+        logoURI: any;
+        stakeAmount: any;
+    };
+    decodeEndUser: (data: Hex) => {
+        account: any;
+        community: any;
+        avatarURI: any;
+        ensName: any;
+        stakeAmount: any;
+    };
+};

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

@@ -1,37 +1,27 @@
-import { keccak256, stringToBytes, encodeAbiParameters, decodeAbiParameters, parseAbiParameters, type Hex, type Address, zeroAddress } from 'viem';
-
+import { keccak256, stringToBytes, encodeAbiParameters, decodeAbiParameters, zeroAddress } from 'viem';
 export const RoleIds = {
     PAYMASTER_SUPER: keccak256(stringToBytes('PAYMASTER_SUPER')),
     DVT: keccak256(stringToBytes('DVT')), // Replaced PAYMASTER
     PAYMASTER_AOA: keccak256(stringToBytes('PAYMASTER_AOA')),
-
     KMS: keccak256(stringToBytes('KMS')),
     COMMUNITY: keccak256(stringToBytes('COMMUNITY')),
     ENDUSER: keccak256(stringToBytes('ENDUSER')),
     ANODE: keccak256(stringToBytes('ANODE'))
-} as const;
-
-export type RoleId = typeof RoleIds[keyof typeof RoleIds];
-
+};
 export const RoleDataFactory = {
     /**
      * Data for SuperPaymaster Operator (Empty)
      */
-    paymasterSuper: (): Hex => '0x',
-
-
+    paymasterSuper: () => '0x',
     /**
      * Data for Generic DVT Role (Empty)
      */
-    dvt: (): Hex => '0x',
-
-
-
+    dvt: () => '0x',
     /**
      * Data for Community Registration (matches Registry.sol CommunityRoleData)
      * NOTE: Solidity's abi.encode(struct) adds a 32-byte offset prefix (0x20)
      * which is required for abi.decode(struct) to work correctly.
-     * 
+     *
      * @param params.name Community Name (defaults to 'TestCommunity')
      * @param params.ensName ENS name (optional)
      * @param params.website Website URL (optional)
@@ -39,9 +29,8 @@ export const RoleDataFactory = {
      * @param params.logoURI Logo URI string (optional)
      * @param params.stakeAmount Stake amount (defaults to 0)
      */
-    community: (params?: { name?: string, ensName?: string, website?: string, description?: string, logoURI?: string, stakeAmount?: bigint }): Hex => {
-        return encodeAbiParameters(
-            [{
+    community: (params) => {
+        return encodeAbiParameters([{
                 type: 'tuple',
                 components: [
                     { name: 'name', type: 'string' },
@@ -51,24 +40,20 @@ export const RoleDataFactory = {
                     { name: 'logoURI', type: 'string' },
                     { name: 'stakeAmount', type: 'uint256' }
                 ]
-            }],
-            [[
+            }], [[
                 params?.name || 'TestCommunity',
                 params?.ensName || '',
                 params?.website || '',
                 params?.description || '',
                 params?.logoURI || '',
                 params?.stakeAmount || 0n
-            ] as any]
-        );
+            ]]);
     },
-
     /**
      * Data for EndUser (matches Registry.sol EndUserRoleData)
      */
-    endUser: (params?: { account?: Address, community?: Address, avatarURI?: string, ensName?: string, stakeAmount?: bigint }): Hex => {
-        return encodeAbiParameters(
-            [{
+    endUser: (params) => {
+        return encodeAbiParameters([{
                 type: 'tuple',
                 components: [
                     { name: 'account', type: 'address' },
@@ -77,20 +62,16 @@ export const RoleDataFactory = {
                     { name: 'ensName', type: 'string' },
                     { name: 'stakeAmount', type: 'uint256' }
                 ]
-            }],
-            [[
+            }], [[
                 params?.account || zeroAddress,
                 params?.community || zeroAddress,
                 params?.avatarURI || '',
                 params?.ensName || '',
                 params?.stakeAmount || 0n
-            ] as any]
-        );
+            ]]);
     },
-
-    decodeCommunity: (data: Hex) => {
-        const decoded = decodeAbiParameters(
-            [{
+    decodeCommunity: (data) => {
+        const decoded = decodeAbiParameters([{
                 type: 'tuple',
                 components: [
                     { name: 'name', type: 'string' },
@@ -100,29 +81,26 @@ export const RoleDataFactory = {
                     { name: 'logoURI', type: 'string' },
                     { name: 'stakeAmount', type: 'uint256' }
                 ]
-            }],
-            data
-        );
-        const result = decoded[0] as any;
+            }], data);
+        const result = decoded[0];
         // 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 
+            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: Hex) => {
-        const decoded = decodeAbiParameters(
-            [{
+    decodeEndUser: (data) => {
+        const decoded = decodeAbiParameters([{
                 type: 'tuple',
                 components: [
                     { name: 'account', type: 'address' },
@@ -131,14 +109,13 @@ export const RoleDataFactory = {
                     { name: 'ensName', type: 'string' },
                     { name: 'stakeAmount', type: 'uint256' }
                 ]
-            }],
-            data
-        );
-        const result = decoded[0] as any;
+            }], data);
+        const result = decoded[0];
         if (Array.isArray(result)) {
             const [a, c, av, en, s] = result;
             return { account: a, community: c, avatarURI: av, ensName: en, stakeAmount: s };
-        } else {
+        }
+        else {
             return {
                 account: result.account,
                 community: result.community,

package/dist/utils/roleData.test.d.ts

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