Migration document from Contractkit

- import Web3 from "web3";
- import { newKitFromWeb3 } from "@celo/contractkit";
-
- const web3 = new Web3("https://alfajores-forno.celo-testnet.org");
- const kit = newKitFromWeb3(web3);
+ import { createPublicClient, http } from 'viem'
+ import { celo, celoSepolia } from 'viem/chains'
+
+ const publicClient = createPublicClient({
+   chain: celoSepolia, // or celo for celo's mainnet
+   transport: http()
+ })

- const accounts = await kit.web3.eth.getAccounts();
+ const accounts = await publicClient.getAddresses()
const defaultAccount = accounts[0];

+ import { privateKeyToAccount, createWalletClient, http } from 'viem/accounts'
+
+ const privateKey = "0x...";
+ const walletClient = createWalletClient({
+   transport: http(celoSepolia.rpcUrls.default.http[0] as string),
+   chain: celoSepolia,
+ });
+ const account = privateKeyToAccount(privateKey);
+ 
+ // Sign a message
+ await walletClient.signMessage({
+   account,
+   message: 'hello world',
+ });
+
+ // Sign a transaction
+ const transaction = {
+   to: '0x...',
+   value: 1000n,
+   gasLimit: 21000n,
+   gasPrice: 20000000000n,
+ };
+ const signedTransaction = await walletClient.signTransaction({
+   account,
+   transaction,
+ });
+ 
+ // Send the signed transaction
+ const txHash = await walletClient.sendSignedTransaction(signedTransaction);

- const provider = kit.connection.web3.currentProvider
- kit.connection.getBlock(...)
- kit.connection.getTransaction(...)
+ const block = await publicClient.getBlock()
+ /**
+  * {
+  *  baseFeePerGas: 10000n,
+  *  number: 1234n,
+  *  parentHash: "0x....",
+  *  ...
+  * }
+  */
+ const tx = await publicClient.getTransaction({
+   hash: "0x...",
+ })
+ /**
+  * {
+  *  blockHash: '0x...',
+  *  blockNumber: 1234n,
+  *  from: '0x...',
+  *  ...
+  * }
+  */

- const provider = kit.connection.web3.currentProvider
- const signer = provider.getSigner(kit.connection.defaultAccount)
+ const [account] = await walletClient.getAddresses()
+ const hash = await walletClient.sendTransaction({ account, to: "0x...", value: 1000n })

import { getContract } from 'viem'
import { registryABI } from '@celo/abis/types/viem'

// this address is constant
const REGISTRY_CONTRACT_ADDRESS = '0x000000000000000000000000000000000000ce10'
const registryContract = getContract({
  address: REGISTRY_CONTRACT_ADDRESS,
  abi: registryABI,
  publicClient,
})

async function CeloTokens(): Promise<[string, string][]> {
  return Promise.all(
    ['GoldToken', 'StableToken', 'StableTokenEUR', 'StableTokenBRL'].map(async (token) => [
      token,
      await registryContract.read.getAddressForString(token),
    ])
  )
}

+ import { stableTokenABI } from '@celo/abis/types/viem'

- const contract = await kit.contracts.getGoldToken();
- const balance = await contract.balanceOf(wallet.address);
+ const tokenAddresses = await CeloTokens();
+ const USDm = tokenAddresses["StableToken]
+ const balance = await client.readContract({
+   abi: tokenAbi,
+   address: USDm,
+   functionName: "balanceOf",
+   args: [account.address],
+ });

+ import { stableTokenABI } from '@celo/abis/types/viem'
- const CELO = await kit.contracts.getGoldToken();
- const txReceipt = await CELO.transfer('0x...', amount)
+ const tokenAddresses = await CeloTokens();
+ const USDm = tokenAddresses["StableToken]
+ const { request } = await walletClient.simulateContract({
+   abi,
+   address: USDm,
+   functionName: 'transfer',
+   args: [
+     '0x...', // to address
+     amount: 1000n,
+   ],
+   account: '0x...', // from address
+ })
+ const hash = await walletClient.sendTransaction(request);

import Multicall from '@dopex-io/web3-multicall'
const MULTICALL_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11' // same on mainnet and alfajores
const multicall = new Multicall({
  provider,
  chainId,
  multicallAddress: MULTICALL_ADDRESS,
})
const governance = await kit.contracts._web3Contracts.getGovernance()
const stageTxs = _dequeue.map((proposalId) => governance.methods.getProposalStage(proposalId))
const stages: string[] = await multicall.aggregate(stageTxs)

const governanceAddress = await registryContract.read.getAddressForString(['Governance'])
const governanceContract = getContract({
  address: governanceAddress,
  abi: governanceABI,
  publicClient,
})
const _dequeue = await governanceContract.read.getDequeue()
const stageCalls = _dequeue.map((proposalId) => ({
  address: governanceAddress,
  abi: governanceABI,
  functionName: 'getProposalStage',
  args: [proposalId],
}))
const stages = (await publicClient.multicall({ contracts: stageCalls })).map((x) => x.result)

  import { celo } from 'viem/chains'
  import { createWalletClient, privateKeyToAccount, type SendTransactionParameters, http } from 'viem'

  const account = privateKeyToAccount(PRIVATE_KEY)

  // ALFAJORES ADDRESS: Celo Mainnet can be fetched from the registry
  const USDmAddress = '0x874069Fa1Eb16D44d622F2e0Ca25eeA172369bC1'

  const localAccountClient = createWalletClient({
    account,
    chain: celo,
  })

  const sendTransaction = (tx: SendTransactionParameters<typeof celo>) => {
    return localAccountClient.sendTransaction(tx)
  }

  const hash = await sendTransaction({
    feeCurrency: USDmAddress,
    value: BigInt(100000000),
    to: '0x22579CA45eE22E2E16dDF72D955D6cf4c767B0eF',
  })