@aastar/sdk 0.14.3 → 0.16.6

package/scripts/01_prepare_all.ts

@@ -1,271 +1,222 @@
 import dotenv from 'dotenv';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { createPublicClient, createWalletClient, http, parseAbi, parseEther, formatEther, getContract, maxUint256, Hex, Address, encodeAbiParameters, keccak256, toBytes } from 'viem';
+import { http, parseEther, formatEther, Hex, Address, keccak256, stringToBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
+import { 
+    createAdminClient, 
+    createEndUserClient, 
+    createOperatorClient,
+    RoleIds,
+    CORE_ADDRESSES,
+    TEST_TOKEN_ADDRESSES,
+    parseKey
+} from '../packages/sdk/src/index.ts'; // Correct index path for tsx
+import { getNetworkConfig } from './00_utils.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-import { getNetworkConfig } from './00_utils.js';
-
-dotenv.config({ path: path.resolve(__dirname, '../../env/.env.anvil') });
+// Load env based on EXPERIMENT_NETWORK
+const network = process.env.EXPERIMENT_NETWORK || 'anvil';
+const envFile = network === 'sepolia' ? '.env.sepolia' : '.env.anvil';
+const envPath = path.resolve(process.cwd(), envFile);
+dotenv.config({ path: envPath, override: true });
 
 async function main() {
-    const network = process.env.EXPERIMENT_NETWORK || 'sepolia';
     const { chain, rpc } = getNetworkConfig(network);
     
     console.log(`🚀 Starting Phase 1 Preparation: The Ammo (Network: ${network})`);
     console.log(`🔌 Connecting to RPC: ${rpc}`);
     
     if (!rpc) throw new Error(`Missing RPC URL for ${network}`);
-    
-    const client = createPublicClient({ 
-        chain,
-        transport: http(rpc)
-    });
 
-    const publicClient = client; // Alias for compatibility with existing code
+    // Accounts
+    const ANVIL_ADMIN = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+    const ANVIL_OP = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
 
-    // 2. Setup Operators
-    const supplierKey = process.env.PRIVATE_KEY_SUPPLIER;
-    const operatorKey = process.env.PRIVATE_KEY_JASON; 
+    const supplierKey = process.env.PRIVATE_KEY_SUPPLIER || process.env.ADMIN_KEY || (network === 'anvil' ? ANVIL_ADMIN : undefined);
+    const operatorKey = process.env.PRIVATE_KEY_JASON || process.env.OPERATOR_KEY || (network === 'anvil' ? ANVIL_OP : undefined);
     
-    if (!supplierKey || !operatorKey) throw new Error("Missing Keys");
+    if (!supplierKey || !operatorKey) throw new Error("Missing Keys (PRIVATE_KEY_SUPPLIER, PRIVATE_KEY_JASON)");
 
     const supplierAccount = privateKeyToAccount(parseKey(supplierKey));
     const operatorAccount = privateKeyToAccount(parseKey(operatorKey));
-    
-    const supplierWallet = createWalletClient({ chain, transport: http(rpc), account: supplierAccount });
-    const operatorWallet = createWalletClient({ chain, transport: http(rpc), account: operatorAccount });
 
-    console.log(`\n📋 Configuration:`);
-    console.log(`   MySBT:    ${MYSBT_ADDRESS || "❌"}`);
-    console.log(`   GToken:   ${GTOKEN_ADDRESS || "❌"}`);
-    console.log(`   aPNTs:    ${APNTS_ADDRESS || "❌"}`);
-    console.log(`   bPNTs:    ${BPNTS_ADDRESS || "❌"}`);
-    console.log(`   PIM:      ${PIM_ADDRESS}`);
-    console.log(`   Factory:  ${PAYMASTER_FACTORY_ADDRESS}`);
-    
-    const ownerKey = process.env.PRIVATE_KEY_JASON; 
-    const ownerAccount = privateKeyToAccount(parseKey(ownerKey));
+    // Clients
+    const admin = createAdminClient({ chain, transport: http(rpc), account: supplierAccount });
+    const operator = createOperatorClient({ chain, transport: http(rpc), account: operatorAccount });
+
+    console.log(`\n📋 SDK Configuration:`);
+    console.log(`   Registry: ${CORE_ADDRESSES.registry}`);
+    console.log(`   GToken:   ${TEST_TOKEN_ADDRESSES.gToken}`);
+    console.log(`   aPNTs:    ${TEST_TOKEN_ADDRESSES.apnts}`);
+    console.log(`   PIM:      ${TEST_TOKEN_ADDRESSES.pimToken}`);
 
     const targets = [
         { 
             label: 'Baseline (A - Pimlico)', 
-            address: process.env.TEST_SIMPLE_ACCOUNT_A as Hex,
+            address: process.env.TEST_SIMPLE_ACCOUNT_A as Address,
             salt: 0n, 
             requireMySBT: false, 
-            requireGToken: false,
-            requirePIM: true
+            token: TEST_TOKEN_ADDRESSES.pimToken,
+            amount: parseEther("1.0")
         },
         { 
             label: 'Standard (B - Paymaster V4/AOA)', 
-            address: process.env.TEST_SIMPLE_ACCOUNT_B as Hex,
+            address: process.env.TEST_SIMPLE_ACCOUNT_B as Address,
             salt: 1n, 
             requireMySBT: true, 
-            requireBPNTs: true 
+            token: TEST_TOKEN_ADDRESSES.bpnts,
+            amount: parseEther("50")
         },
         { 
             label: 'SuperPaymaster (C)', 
-            address: process.env.TEST_SIMPLE_ACCOUNT_C as Hex,
+            address: process.env.TEST_SIMPLE_ACCOUNT_C as Address,
             salt: 2n, 
             requireMySBT: true, 
-            requireGToken: true,
-            requireAPNTs: true 
+            token: TEST_TOKEN_ADDRESSES.apnts,
+            amount: parseEther("50")
         }
     ];
 
     console.log(`\n🔄 Processing ${targets.length} Accounts...`);
 
     for (const target of targets) {
-        await sleep(500);
         console.log(`\n--------------------------------------------`);
         console.log(`👤 Target: ${target.label}`);
 
         let senderAddress = target.address;
-        const ACCOUNT_FACTORY = '0x91E60e0613810449d098b0b5Ec8b51A0FE8c8985';
+        
+        // Use EndUserClient for each target to handle their specific needs
+        const userClient = createEndUserClient({ chain, transport: http(rpc), account: supplierAccount }); // Supplier acting for them
 
         if (!senderAddress) {
-             console.warn(`   ⚠️  Address missing. Calculating...`);
-             const factoryData = encodeFunctionData({ abi: factoryAbi, functionName: 'createAccount', args: [ownerAccount.address, target.salt] });
-             const initCode = concat([ACCOUNT_FACTORY, factoryData]);
-             try {
-                await client.simulateContract({
-                    address: ENTRY_POINT_ADDRESS,
-                    abi: [{ inputs: [{ name: "initCode", type: "bytes" }], name: "getSenderAddress", outputs: [], stateMutability: "nonpayable", type: "function" }, ...senderAddressResultAbi],
-                    functionName: 'getSenderAddress',
-                    args: [initCode]
-                });
-             } catch (err: any) {
-                 const data = err.data || (err.cause && err.cause.data);
-                 if (data) {
-                     try {
-                        const decoded = decodeErrorResult({ abi: senderAddressResultAbi, data });
-                        senderAddress = decoded.args[0] as Hex;
-                     } catch (e) {}
-                 }
-                 if (!senderAddress) {
-                     const match = (err.details || err.message).match(/0x[a-fA-F0-9]{40}/);
-                     if (match) senderAddress = match[0] as Hex;
-                 }
-            }
+            console.warn(`   ⚠️  Address missing. Calculating via SDK...`);
+            const { accountAddress } = await userClient.createSmartAccount({
+                owner: supplierAccount.address, // Assuming supplier is owner for prep
+                salt: target.salt
+            });
+            senderAddress = accountAddress;
         }
         
-        if (senderAddress) console.log(`   📍 Address: ${senderAddress}`);
-
-        // 1. ETH Check
-        if (senderAddress) {
-            const balance = await publicClient.getBalance({ address: senderAddress });
-            if (balance < parseEther("0.05")) {
-                 console.log("   📉 Low ETH. Funding...");
-                 try {
-                    const tx = await supplierWallet.sendTransaction({ to: senderAddress, value: parseEther("0.05") });
-                    await publicClient.waitForTransactionReceipt({ hash: tx });
-                    console.log(`      ✅ Funded ETH`);
-                 } catch (e) { console.error("      ❌ ETH Fail", e); }
-            }
+        console.log(`   📍 Address: ${senderAddress}`);
+
+        // 1. ETH Check & Fund
+        const balance = await admin.getBalance({ address: senderAddress });
+        if (balance < parseEther("0.05")) {
+             console.log(`   📉 Low ETH (${formatEther(balance)}). Funding 0.1 ETH...`);
+             const hash = await admin.sendTransaction({ to: senderAddress, value: parseEther("0.1") });
+             await admin.waitForTransactionReceipt({ hash });
+             console.log(`      ✅ Funded ETH`);
+        } else {
+             console.log(`      ✅ ETH Sufficient: ${formatEther(balance)}`);
         }
 
-        // 2. Assets Check
-        if (senderAddress) {
-            // MySBT
-            if (target.requireMySBT && MYSBT_ADDRESS) {
-                 try {
-                     const sbtBal = await publicClient.readContract({ address: MYSBT_ADDRESS, abi: sbtAbi, functionName: 'balanceOf', args: [senderAddress] });
-                     if (sbtBal === 0n) {
-                         console.log("   📉 Minting MySBT...");
-                         const { request } = await publicClient.simulateContract({ account: operatorAccount, address: MYSBT_ADDRESS, abi: sbtAbi, functionName: 'mint', args: [senderAddress] });
-                         const tx = await operatorWallet.writeContract(request);
-                         await publicClient.waitForTransactionReceipt({ hash: tx });
-                         console.log(`      ✅ Minted`);
-                     }
-                 } catch (e: any) { console.error(`      ⚠️ SBT Error: ${e.message}`); }
-            }
-            
-            // aPNTs
-            if ((target as any).requireAPNTs && APNTS_ADDRESS) {
-                try {
-                    const bal = await publicClient.readContract({ address: APNTS_ADDRESS, abi: erc20Abi, functionName: 'balanceOf', args: [senderAddress] });
-                    if ((bal as bigint) < parseEther("10")) {
-                        console.log("   📉 Transferring aPNTs...");
-                        const { request } = await publicClient.simulateContract({ account: supplierAccount, address: APNTS_ADDRESS, abi: erc20Abi, functionName: 'transfer', args: [senderAddress, parseEther("50")] });
-                        await supplierWallet.writeContract(request);
-                        console.log(`      ✅ Sent aPNTs`);
-                    }
-                } catch(e: any) { console.error(`      ⚠️ aPNTs Error: ${e.message}`); }
-            }
+        // 2. MySBT (Join Community)
+        if (target.requireMySBT) {
+            console.log(`   🆔 Checking MySBT (ENDUSER role)...`);
+            const hasRole = await userClient.hasRole({ 
+                user: senderAddress, 
+                roleId: RoleIds.ENDUSER 
+            });
 
-             // bPNTs
-            if ((target as any).requireBPNTs && BPNTS_ADDRESS) {
+            if (!hasRole) {
+                console.log(`   🏗️  Joining community for ${senderAddress}...`);
+                // Note: In a real scenario, the user signs. For prep, Admin/Supplier might grant it or we use registerRole for them if we have permission.
+                // Since this is prep, we'll try to grant it via Admin if it fails via self-registration (which requires signatures we might not have here without private keys for A/B/C)
                 try {
-                    const bal = await publicClient.readContract({ address: BPNTS_ADDRESS, abi: erc20Abi, functionName: 'balanceOf', args: [senderAddress] });
-                    if ((bal as bigint) < parseEther("10")) {
-                         console.log("   📉 Transferring bPNTs...");
-                        const { request } = await publicClient.simulateContract({ account: supplierAccount, address: BPNTS_ADDRESS, abi: erc20Abi, functionName: 'transfer', args: [senderAddress, parseEther("50")] });
-                        await supplierWallet.writeContract(request);
-                        console.log(`      ✅ Sent bPNTs`);
-                    }
-                } catch(e:any) { console.error(`      ⚠️ bPNTs Error: ${e.message}`); }
+                    // For prep, let's use Admin to grant the role directly to the AA address
+                    const data = stringToBytes("0x"); // Placeholder
+                    const hash = await admin.system.grantRole({
+                        roleId: RoleIds.ENDUSER,
+                        user: senderAddress,
+                        data: '0x' as Hex
+                    });
+                    console.log(`      ✅ SBT Role Granted via Admin: ${hash}`);
+                } catch (e: any) {
+                    console.warn(`      ⚠️  SBT Grant Failed: ${e.message}`);
+                }
+            } else {
+                console.log(`      ✅ Already member`);
             }
+        }
 
-            // PIM
-            if ((target as any).requirePIM && PIM_ADDRESS) {
-                try {
-                    const bal = await publicClient.readContract({ address: PIM_ADDRESS, abi: erc20Abi, functionName: 'balanceOf', args: [senderAddress] });
-                    if ((bal as bigint) < parseEther("0.1")) {
-                         console.log("   📉 Transferring PIM...");
-                        const { request } = await publicClient.simulateContract({ account: supplierAccount, address: PIM_ADDRESS, abi: erc20Abi, functionName: 'transfer', args: [senderAddress, parseEther("1.0")] });
-                        await supplierWallet.writeContract(request);
-                        console.log(`      ✅ Sent PIM`);
-                    }
-                } catch(e:any) { console.error(`      ⚠️ PIM Error (Ignored): ${e.message}`); }
+        // 3. Tokens Check & Fund
+        if (target.token && target.token !== '0x' && target.token !== '0x0000000000000000000000000000000000000000') {
+            const tokenBal = await admin.readContract({
+                address: target.token,
+                abi: [parseAbi(['function balanceOf(address) view returns (uint256)'])[0]],
+                functionName: 'balanceOf',
+                args: [senderAddress]
+            }) as bigint;
+
+            if (tokenBal < target.amount / 2n) {
+                console.log(`   📉 Low Token Balance (${formatEther(tokenBal)}). Funding...`);
+                // We don't have a direct 'transfer' in AdminClient Finance, but we can use base writeContract
+                const hash = await admin.writeContract({
+                    address: target.token,
+                    abi: parseAbi(['function transfer(address, uint256) returns (bool)']),
+                    functionName: 'transfer',
+                    args: [senderAddress, target.amount],
+                    account: supplierAccount
+                });
+                await admin.waitForTransactionReceipt({ hash });
+                console.log(`      ✅ Token Sent`);
+            } else {
+                console.log(`      ✅ Token Sufficient: ${formatEther(tokenBal)}`);
             }
         }
     }
 
-    // 4. Verify/Deploy Paymaster V4.1 (AOA Mode for Group B)
+    // 4. Paymaster V4.1 Setup (AOA Mode)
     console.log(`\n--------------------------------------------`);
-    console.log(`🏭 Verifying Paymaster V4.1 (Group B / AOA)...`);
+    console.log(`🏭 Verifying Paymaster V4.1 (AOA)...`);
     
-    if (!BPNTS_ADDRESS) {
-        console.error("❌ Stats: Missing bPNTs Address! Cannot deploy Paymaster V4 properly.");
+    const pmV4Status = await operator.getOperatorStatus(operatorAccount.address);
+    if (!pmV4Status.paymasterV4) {
+        console.log(`   🏗️  Deploying Paymaster V4 for operator...`);
+        const deployTx = await operator.deployPaymasterV4();
+        console.log(`      ✅ Deployed: ${deployTx}`);
+        
+        // Wait for it to be indexed/available
+        await new Promise(r => setTimeout(r, 2000));
+        const updatedStatus = await operator.getOperatorStatus(operatorAccount.address);
+        if (updatedStatus.paymasterV4) {
+            console.log(`      📍 Address: ${updatedStatus.paymasterV4.address}`);
+        }
     } else {
-        let paymasterV4Address: Hex | undefined;
-
-        try {
-            // Predict address
-            const { result } = await publicClient.simulateContract({
-                address: PAYMASTER_FACTORY_ADDRESS,
-                abi: paymasterFactoryAbi,
-                functionName: 'deployPaymaster',
-                args: [
-                    BPNTS_ADDRESS, 
-                    MYSBT_ADDRESS || "0x0000000000000000000000000000000000000000", 
-                    supplierAccount.address, 
-                    200n
-                ],
-                account: operatorAccount
-            });
-            paymasterV4Address = result;
-            console.log(`   📍 Paymaster Address (for bPNTs): ${paymasterV4Address}`);
-
-            const code = await publicClient.getBytecode({ address: paymasterV4Address });
-            if (code && code.length > 2) {
-                console.log("   ✅ Contract Deployed");
-            } else {
-                console.log("   🏗️  Deploying Paymaster...");
-                const tx = await operatorWallet.writeContract({
-                    address: PAYMASTER_FACTORY_ADDRESS,
-                    abi: paymasterFactoryAbi,
-                    functionName: 'deployPaymaster',
-                    args: [BPNTS_ADDRESS, MYSBT_ADDRESS!, supplierAccount.address, 200n],
-                    chain,
-                    account: operatorAccount
-                });
-                console.log(`      ✅ Deployed. Hash: ${tx}`);
-                // await publicClient.waitForTransactionReceipt({ hash: tx }); // Skip wait to prevent timeout if slow
-                console.log("      (Check explorer if pending)");
-            }
+        console.log(`      ✅ Paymaster V4 already exists: ${pmV4Status.paymasterV4.address}`);
+    }
 
-            // 5. Deposit ETH
-            const epBal = await publicClient.readContract({
-                address: ENTRY_POINT_ADDRESS,
-                abi: entryPointAbi,
-                functionName: 'balanceOf',
-                args: [paymasterV4Address]
+    // 5. EntryPoint Deposit for PM V4
+    const pmStatus = await operator.getOperatorStatus(operatorAccount.address);
+    if (pmStatus.paymasterV4) {
+        const pmAddr = pmStatus.paymasterV4.address;
+        const deposit = await admin.readContract({
+            address: CORE_ADDRESSES.entryPoint,
+            abi: parseAbi(['function balanceOf(address) view returns (uint256)']),
+            functionName: 'balanceOf',
+            args: [pmAddr]
+        }) as bigint;
+
+        console.log(`   💰 Paymaster V4 EntryPoint Deposit: ${formatEther(deposit)} ETH`);
+        if (deposit < parseEther("0.1")) {
+            console.log(`   📉 Low Deposit. Adding 0.2 ETH...`);
+            const hash = await admin.writeContract({
+                address: CORE_ADDRESSES.entryPoint,
+                abi: parseAbi(['function depositTo(address) payable']),
+                functionName: 'depositTo',
+                args: [pmAddr],
+                value: parseEther("0.2"),
+                account: supplierAccount
             });
-            console.log(`   💰 EntryPoint Deposit: ${formatEther(epBal)} ETH`);
-            
-            if (epBal < parseEther("0.1")) {
-                console.log("   📉 Low Deposit. Depositing 0.2 ETH...");
-                try {
-                const tx = await supplierWallet.writeContract({
-                    address: ENTRY_POINT_ADDRESS,
-                    abi: entryPointAbi,
-                    functionName: 'depositTo',
-                    args: [paymasterV4Address],
-                    value: parseEther("0.2")
-                });
-                console.log(`      ✅ Deposited. Hash: ${tx}`);
-                } catch(e:any) { console.error("      ❌ Deposit Error:", e.message); }
-            } else {
-                console.log("      ✅ Deposit Sufficient");
-            }
-
-        } catch (e: any) {
-            console.error("   ❌ Paymaster Init Failed:", e.message);
+            await admin.waitForTransactionReceipt({ hash });
+            console.log(`      ✅ Deposit Added`);
         }
-
-        console.log("\n============================================");
-        console.log("✅ SUMMARY OF PAYMASTERS");
-        console.log("============================================");
-        console.log(`1. Pimlico (Group A):        ${PIM_ADDRESS} (Token) via RPC`);
-        console.log(`2. Paymaster V4 (Group B):   ${paymasterV4Address}`);
-        console.log(`3. SuperPaymaster (Group C): ${SUPER_PAYMASTER_ADDRESS}`);
-        console.log("============================================");
     }
+
+    console.log(`\n✅ Phase 1 Preparation Complete!`);
 }
 
 main().catch(console.error);

package/scripts/02_test_eoa.ts

@@ -1,49 +1,52 @@
-import { createPublicClient, createWalletClient, http, parseEther, formatEther, Hex } from 'viem';
+
+import { http, parseEther, formatEther, type Hex } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
+import { 
+    createAdminClient, 
+    parseKey 
+} from '../packages/sdk/src/index.ts';
+import { getNetworkConfig } from './00_utils.js';
 import * as dotenv from 'dotenv';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 
-dotenv.config({ path: path.resolve(__dirname, '../../env/.env.anvil') });
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
-const RPC_URL = process.env.SEPOLIA_RPC_URL;
-const RELAYER_KEY = process.env.PRIVATE_KEY_RELAYER as Hex || process.env.PRIVATE_KEY_JASON as Hex;
-const RECEIVER = "0x93E67dbB7B2431dE61a9F6c7E488e7F0E2eD2B3e";
+// Dynamic Env Loading
+const NETWORK = process.env.EXPERIMENT_NETWORK || 'anvil';
+const envFile = NETWORK === 'sepolia' ? '.env.sepolia' : '.env.anvil';
+dotenv.config({ path: path.resolve(process.cwd(), envFile) });
 
-if (!RPC_URL || !RELAYER_KEY) throw new Error("Missing Config for EOA Test");
+const RPC_URL = process.env.RPC_URL || (NETWORK === 'sepolia' ? process.env.SEPOLIA_RPC_URL : "http://127.0.0.1:8545");
+const RELAYER_KEY = (process.env.PRIVATE_KEY_RELAYER || process.env.PRIVATE_KEY_JASON || process.env.ADMIN_KEY) as Hex;
+const RECEIVER = "0x93E67dbB7B2431dE61a9F6c7E488e7F0E2eD2B3e";
 
 async function main() {
-    console.log("🚀 Starting Baseline 1: EOA Transfer...");
+    console.log(`🚀 Baseline 1: EOA Transfer (Network: ${NETWORK})`);
     
-    const account = privateKeyToAccount(RELAYER_KEY);
-    const client = createWalletClient({
-        account,
-        chain: foundry,
-        transport: http(RPC_URL)
-    });
-    const publicClient = createPublicClient({ 
-        chain: foundry, 
-        transport: http(RPC_URL) 
-    });
+    if (!RELAYER_KEY) throw new Error("Missing Private Key (PRIVATE_KEY_RELAYER or ADMIN_KEY)");
+    const account = privateKeyToAccount(parseKey(RELAYER_KEY));
+    const admin = createAdminClient({ transport: http(RPC_URL), account });
 
     console.log(`   👤 Sender: ${account.address}`);
     
-    const balanceBefore = await publicClient.getBalance({ address: account.address });
+    const balanceBefore = await admin.getBalance({ address: account.address });
     console.log(`   💰 Balance: ${formatEther(balanceBefore)} ETH`);
 
     try {
-        const hash = await client.sendTransaction({
+        const hash = await admin.sendTransaction({
             to: RECEIVER,
             value: parseEther("0.0001"), 
         });
         console.log(`   ⏳ Transaction sent: ${hash}`);
         
-        const receipt = await publicClient.waitForTransactionReceipt({ hash });
-        console.log(`   ✅ Success!`);
+        const receipt = await admin.waitForTransactionReceipt({ hash });
+        console.log(`   ✅ Success! Status: ${receipt.status}`);
         console.log(`   ⛽ Gas Used: ${receipt.gasUsed.toString()}`);
         console.log(`   💸 Effective Gas Price: ${formatEther(receipt.effectiveGasPrice)} ETH`);
-    } catch (error) {
-        console.error("   ❌ EOA Test Failed:", error);
+    } catch (error: any) {
+        console.error("   ❌ EOA Test Failed:", error.message.split('\n')[0]);
     }
 }