Wallet Deployment

import { createSDK } from '@wirexapp/wirexpay-sdk';

const sdk = await createSDK({
  env: 'production', // or 'sandbox'
  companyId: '0x00000000000000000000000000000007', // Your partner_id
  enableLogging: true,
  getMainWalletClient: async () => {
    // Return the user's EOA wallet client (from Privy, WalletConnect, etc.)
    return mainWalletClient;
  },
});

// Check if already installed
const policyInstalled = await sdk.crypto.accountAbstraction.isPolicyInstalled();
const executorInstalled = await sdk.crypto.accountAbstraction.isExecutorInstalled();

// Install both policy and executor in one transaction
if (!policyInstalled || !executorInstalled) {
  await sdk.crypto.accountAbstraction.signInPolicyAndExecutor();
}

// Check if already registered
const isRegistered = await sdk.crypto.accountContract.isWalletInAccounts();

// Register
if (!isRegistered) {
  await sdk.crypto.accountContract.registerInAccounts();
}

npm install @zerodev/sdk @zerodev/ecdsa-validator @zerodev/permissions viem

// ============================================================
// Imports
// ============================================================
import { createZeroDevPaymasterClient, KernelV3_1AccountAbi } from '@zerodev/sdk';
import { createKernelAccount, createKernelAccountClient } from '@zerodev/sdk';
import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator';
import { getEntryPoint, KERNEL_V3_1, VALIDATOR_TYPE } from '@zerodev/sdk/constants';
import { toPermissionValidator } from '@zerodev/permissions';
import { toSudoPolicy } from '@zerodev/permissions/policies';
import { toECDSASigner } from '@zerodev/permissions/signers';
import {
  createPublicClient,
  http,
  encodeFunctionData,
  concatHex,
  pad,
  zeroAddress,
  zeroHash,
  type PrivateKeyAccount,
} from 'viem';
import { base } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

// ============================================================
// ABIs - see ABI Reference guide for complete definitions
// ============================================================
import { ContractRegistryAbi, AccountsAbi } from './abi';
// Or define inline - see: ABI Reference guide

// ============================================================
// Configuration (provided by Wirex during onboarding)
// ============================================================
interface WirexConfig {
  chainId: number;
  rpcUrl: string;
  bundlerRpc: string;
  paymasterRpc: string;
  contractRegistryAddress: `0x${string}`;
  partnerId: `0x${string}`;
}

// Example configuration for Base mainnet
const config: WirexConfig = {
  chainId: 8453,
  rpcUrl: 'https://...', // Provided by Wirex
  bundlerRpc: 'https://...', // Provided by Wirex
  paymasterRpc: 'https://...', // Provided by Wirex
  contractRegistryAddress: '0x...', // Provided by Wirex
  partnerId: '0x00000000000000000000000000000007', // Your partner_id
};

// ============================================================
// Step 1: Initialize Clients
// ============================================================
async function initializeClients(config: WirexConfig) {
  const chain = base;

  const publicClient = createPublicClient({
    chain,
    transport: http(config.rpcUrl, { timeout: 30_000 }),
  });

  // Kernel public client for account operations
  const kernelPublicClient = createPublicClient({
    chain,
    transport: http(config.rpcUrl, { timeout: 60_000 }),
  });

  const paymasterClient = createZeroDevPaymasterClient({
    chain,
    transport: http(config.paymasterRpc),
  });

  return { chain, publicClient, kernelPublicClient, paymasterClient };
}

// ============================================================
// Step 2: Resolve Contract Addresses from Registry
// ============================================================
interface ContractAddresses {
  accounts: `0x${string}`;
  fundsManagement: `0x${string}`;
  executionDelayPolicy: `0x${string}`;
}

async function resolveContractAddresses(
  publicClient: any,
  registryAddress: `0x${string}`
): Promise<ContractAddresses> {
  const getAddress = async (name: string): Promise<`0x${string}`> => {
    return publicClient.readContract({
      address: registryAddress,
      abi: ContractRegistryAbi,
      functionName: 'contractByName',
      args: [name],
    });
  };

  return {
    accounts: await getAddress('Accounts'),
    fundsManagement: await getAddress('FundsManagement'),
    executionDelayPolicy: await getAddress('ExecutionDelayPolicy'),
  };
}

// ============================================================
// Step 3: Obtain User Signer
// ============================================================

// Option A: From Privy
// import { usePrivy, useWallets } from '@privy-io/react-auth';
// const { wallets } = useWallets();
// const wallet = wallets[0];
// await wallet.switchChain(config.chainId);
// const provider = await wallet.getEthereumProvider();
// const signer = ... // Create viem wallet client from provider

// Option B: From private key (embedded wallets, custodial solutions)
function getSignerFromPrivateKey(privateKey: `0x${string}`): PrivateKeyAccount {
  return privateKeyToAccount(privateKey);
}

// Option C: From WalletConnect / wagmi
// import { useWalletClient } from 'wagmi';
// const { data: walletClient } = useWalletClient();

// ============================================================
// Step 4: Create and Deploy Smart Wallet (Single Transaction)
// ============================================================
async function createAndDeployAAWallet(
  signer: PrivateKeyAccount,
  config: WirexConfig
) {
  const { chain, publicClient, kernelPublicClient, paymasterClient } =
    await initializeClients(config);

  const contracts = await resolveContractAddresses(
    publicClient,
    config.contractRegistryAddress
  );

  console.log('Resolved contract addresses:', contracts);

  // Create simple ECDSA validator for initial deployment
  const simpleValidator = await signerToEcdsaValidator(kernelPublicClient, {
    signer,
    entryPoint: getEntryPoint('0.7'),
    kernelVersion: KERNEL_V3_1,
  });

  // Create kernel account (not yet deployed on-chain)
  const kernelAccount = await createKernelAccount(kernelPublicClient, {
    entryPoint: getEntryPoint('0.7'),
    kernelVersion: KERNEL_V3_1,
    plugins: {
      sudo: simpleValidator,
    },
  });

  // Create kernel client with paymaster for gas sponsorship
  const kernelClient = createKernelAccountClient({
    account: kernelAccount,
    chain,
    bundlerTransport: http(config.bundlerRpc),
    paymaster: {
      getPaymasterData: (userOperation) =>
        paymasterClient.sponsorUserOperation({ userOperation }),
    },
  });

  console.log('Smart Wallet address (counterfactual):', kernelAccount.address);

  // ---- Build batched calls ----

  // 1. Executor installation
  const executorCallData = encodeFunctionData({
    abi: KernelV3_1AccountAbi,
    functionName: 'installModule',
    args: [
      BigInt(2), // Module type: Executor
      contracts.fundsManagement,
      concatHex([zeroAddress, zeroHash]),
    ],
  });

  // 2. Policy installation
  const rootPolicy = toSudoPolicy({
    policyAddress: contracts.executionDelayPolicy,
  });

  const permissionValidator = await toPermissionValidator(kernelPublicClient, {
    entryPoint: getEntryPoint('0.7'),
    signer: await toECDSASigner({ signer }),
    kernelVersion: KERNEL_V3_1,
    policies: [rootPolicy],
  });
  permissionValidator.address = contracts.executionDelayPolicy;

  const rootValidatorId = concatHex([
    VALIDATOR_TYPE.PERMISSION,
    pad(permissionValidator.getIdentifier(), { size: 20, dir: 'right' }),
  ]);

  const policyCallData = encodeFunctionData({
    abi: KernelV3_1AccountAbi,
    functionName: 'changeRootValidator',
    args: [
      rootValidatorId,
      zeroAddress,
      await permissionValidator.getEnableData(kernelAccount.address),
      '0x',
    ],
  });

  // 3. Account registration
  const registerCallData = encodeFunctionData({
    abi: AccountsAbi,
    functionName: 'createUserAccountWithWallet',
    args: [config.partnerId],
  });

  // 4. Batch all calls
  const batchedCalls = await kernelAccount.encodeCalls([
    {
      to: kernelAccount.address,
      value: BigInt(0),
      data: policyCallData,
    },
    {
      to: kernelAccount.address,
      value: BigInt(0),
      data: executorCallData,
    },
    {
      to: contracts.accounts,
      value: BigInt(0),
      data: registerCallData,
    },
  ]);

  // 5. Send single UserOperation
  console.log('Sending UserOperation...');
  const txHash = await kernelClient.sendUserOperation({
    callData: batchedCalls,
  });

  console.log('UserOperation hash:', txHash);

  const receipt = await kernelClient.waitForUserOperationReceipt({
    hash: txHash,
    timeout: 60_000,
  });

  console.log('Transaction hash:', receipt.receipt.transactionHash);
  console.log('Smart Wallet deployed:', kernelAccount.address);

  return {
    smartWalletAddress: kernelAccount.address,
    eoaAddress: signer.address,
    transactionHash: receipt.receipt.transactionHash,
  };
}

// ============================================================
// Step 5: Create Client with Policy (for subsequent operations)
// ============================================================
async function createPolicyClient(
  signer: PrivateKeyAccount,
  smartWalletAddress: `0x${string}`,
  config: WirexConfig
) {
  const { chain, publicClient, kernelPublicClient, paymasterClient } =
    await initializeClients(config);

  const contracts = await resolveContractAddresses(
    publicClient,
    config.contractRegistryAddress
  );

  // Create permission validator with policy
  const policyValidator = await toPermissionValidator(kernelPublicClient, {
    entryPoint: getEntryPoint('0.7'),
    signer: await toECDSASigner({ signer }),
    kernelVersion: KERNEL_V3_1,
    policies: [toSudoPolicy({ policyAddress: contracts.executionDelayPolicy })],
  });
  policyValidator.address = contracts.executionDelayPolicy;

  // Create kernel account pointing to existing address
  const kernelAccount = await createKernelAccount(kernelPublicClient, {
    entryPoint: getEntryPoint('0.7'),
    kernelVersion: KERNEL_V3_1,
    address: smartWalletAddress,
    plugins: {
      sudo: policyValidator,
    },
  });

  return createKernelAccountClient({
    account: kernelAccount,
    chain,
    bundlerTransport: http(config.bundlerRpc),
    paymaster: {
      getPaymasterData: (userOperation) =>
        paymasterClient.sponsorUserOperation({ userOperation }),
    },
  });
}

// ============================================================
// Usage Example
// ============================================================
async function main() {
  // From private key (embedded wallets, custodial solutions)
  // Or from Privy, WalletConnect, or other wallet provider
  const signer = getSignerFromPrivateKey('0x...');

  // Deploy Smart Wallet with policy, executor, and registration
  const result = await createAndDeployAAWallet(signer, config);

  console.log('Deployment complete:');
  console.log('  EOA:', result.eoaAddress);
  console.log('  Smart Wallet:', result.smartWalletAddress);
  console.log('  TX Hash:', result.transactionHash);

  // For subsequent operations, create client with policy
  const policyClient = await createPolicyClient(
    signer,
    result.smartWalletAddress,
    config
  );

  // Now use policyClient for all subsequent operations
}

import { KernelV3_1AccountAbi } from '@zerodev/sdk';
import { AccountsAbi } from './abi'; // See ABI Reference

async function verifyWalletSetup(
  publicClient: any,
  smartWalletAddress: `0x${string}`,
  contracts: ContractAddresses,
  partnerId: `0x${string}`
) {
  // 1. Check if executor is installed
  const isExecutorInstalled = await publicClient.readContract({
    address: smartWalletAddress,
    abi: KernelV3_1AccountAbi,
    functionName: 'isModuleInstalled',
    args: [BigInt(2), contracts.fundsManagement, '0x'],
  });
  console.log('Executor installed:', isExecutorInstalled);

  // 2. Check if policy is installed (root validator set)
  const rootValidator = await publicClient.readContract({
    address: smartWalletAddress,
    abi: KernelV3_1AccountAbi,
    functionName: 'rootValidator',
  });
  const isPolicyInstalled = rootValidator && rootValidator !== '0x';
  console.log('Policy installed:', isPolicyInstalled);

  // 3. Check if registered in Accounts contract
  try {
    const account = await publicClient.readContract({
      address: contracts.accounts,
      abi: AccountsAbi,
      functionName: 'getUserAccount',
      args: [smartWalletAddress, partnerId],
    });
    const isRegistered = account && account.status !== 0;
    console.log('Account registered:', isRegistered);
    return { isExecutorInstalled, isPolicyInstalled, isRegistered };
  } catch {
    console.log('Account not registered');
    return { isExecutorInstalled, isPolicyInstalled, isRegistered: false };
  }
}

{
  "wallet_address": "0xA7E41d5680dE394EaA2ed417169DFf56840Fb3EE",
  "wallet_name": "Main Wallet",
  "wallet_status": "Confirmed",
  "wallet_type": "Primary",
  "balances": []
}