In contrast to traditional wallets based on a private key (aka EOAs), smart wallets provide new exciting features, like the ability to sign/authenticate transactions with a different mechanism than just a private key, the ability to sponsor the gas required to run a transaction, the ability to have social login, recovery, plugins, basically anything that you can program with Solidity.

How to create an ERC-4337 Smart Wallet?

The first step in creating a smart wallet is deciding which smart wallet implementation you want to use. There are a few popular choices like:

• ZeroDev
• Biconomy
• Safe

In this article, we will be using the ZeroDev Kernel.

Apart from the smart wallet implementation, you will need a few more things:

• An SDK to create and interact with the smart wallet
• An RPC/Bundler endpoint
• A Paymaster

As an SDK, we are going to use the Kriptonio SDK which also automatically creates the rpc, bundler, and paymaster endpoints for us.

Coding time

The first step is to install Kriptonio SDK:

yarn add @kriptonio/sdk

If you are a Typescript user, we suggest that you check the additional setup hints here.

Next, you will need to acquire an access token for the Kriptonio SDK. Here is how:

1. Go to Kriptonio Web App
2. Create an account
3. Go to the settings page (top right corner, cog icon)
4. Select the Access Tokens tab and copy your access token

Now we are ready to initialize the Kriptonio SDK:

import { ChainId, KriptonioSdk } from '@kriptonio/sdk';
 
const sdk = new KriptonioSdk({ accessToken: 'paste-access-token-here' });

With the Kriptonio SDK, you can manage both smart and classic wallets. Smart wallets are the default, so to create one, we will use the wallet generate function. The only thing you need to provide is the wallet type and the chain id of the chain with which you want to interact.

const wallet = await sdk.wallet.generate({
  chainId: ChainId.BaseSepolia,
  type: 'kernel',
});

Congrats, you have created an ERC-4337 smart wallet! 🎉.

Under the hood, the Kriptonio SDK creates a smart wallet powered by the ZeroDev Kernel. Now you can use the wallet object to check the wallet address.

console.log(wallet.address);

It’s now time to send a transaction using your smart wallet.

const hash = await wallet.sendTransaction({
  to: wallet.address,
  value: 0n,
});

That’s it! You have created a smart wallet and sent a transaction using it.

But what happened under the hood?

Under the hood, the Kriptonio SDK created the RPC, Bundler, and Paymaster endpoints. It also sponsored the transaction gas fee for you, so you didn’t have to worry about it.

Another thing that happened is that since this was the first transaction from your smart wallet, it has been automatically deployed to the selected blockchain network, in this case, the Base Sepolia network.

You did great! To learn more about smart wallets and how to utilize the Kriptonio SDK more, check out the official docs.

If you need help, feel free to reach us via our Discord server https://discord.gg/7QreJNYuaz.

Source Code

The complete source code for this article can be found here.

Bonus Tip

You can use the Kriptonio iOS/Android mobile apps to import smart wallets that you created with the Kriptonio SDK.

Links to the mobile apps are here: https://docs.kriptonio.com/mobile

Originally published at https://docs.kriptonio.com.

Recently, the Wevm team released a great minimal framework for building Frames called Frog. With it, you can create a Frame with JSX. Under the hood, JSX code is rendered to SVG and then to PNG. This makes Frames much more powerful because they don’t show just static images anymore but dynamic content.

One of the very popular current uses of Frames is minting NFTs inside Farcaster client apps. With Kriptonio, you can mint NFTs for your users without them having to pay gas fees. This is a great way to onboard new users to your NFT collection.

In this article, you will learn how to create a gasless Farcaster NFT mint frame with Frog.fm and Kriptonio.

Preparation

First, let’s create a new Frog project.

yarn create frog

Follow the instructions, enter the name, and decide how you would like to deploy your Frame.

After that, let’s install the Kriptonio SDK.

yarn add @kriptonio/sdk

NFT Smart Contract

To create an NFT Collection, you will need a smart contract. Here is the simple NFT contract that we will use in this article. We recommend using the same one while following this article.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
 
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
 
contract FarcasterNFT is ERC721, Ownable {
    constructor(address initialOwner)
        ERC721("Farcaster NFT", "FNFT")
        Ownable(initialOwner)
    {}
 
    function safeMint(address to, uint256 tokenId) public onlyOwner {
        require(balanceOf(to) == 0, "User already owns an NFT");
        _safeMint(to, tokenId);
    }
}

It has a safeMint function that prevents users from minting more than one NFT.

There are multiple ways to deploy this smart contract, but one of the easiest ways is to use the Kriptonio Platform to help deploy it.

First, import the contract to the Kriptonio Platform, and then afterwards we are going to deploy it via the Kriptonio SDK, gaslessly.

1. Create Account

Go to https://app.kriptonio.com and create a new free account.

2. Create the Contract

After logging in, go to Smart Contracts => New Smart Contract => By Providing Solidity Source Code, enter the title you like, select the blockchain network where you are planning to deploy the contract (we will use Base Sepolia), paste the contract code from above, and click Save.

3. Copy the Smart Contract ID

After the contract is created on the Kriptonio platform, you will see the Smart Contract ID field. Copy the value, we will need it soon. Please note that the contract is not yet deployed to the blockchain network, but soon it will be.

Deploy the Smart Contract

You can deploy the smart contract via Kriptonio Web UI or via SDK. In case you want to deploy it via Web UI, simply go to smart contract detail page and follow the instructions.

Here we will show how to do it via SDK.

Open the src/index.tsx file, remove the default code, and add the following code:

import { Frog } from 'frog';
import { KriptonioSdk } from '@kriptonio/sdk';
 
export const app = new Frog();
const sdk = new KriptonioSdk({ accessToken: '<kriptonio-access-token>' });

Here we just import Frog and the Kriptonio SDK, and create a new instance of both. To obtain<kriptonio-access-token>, go to settings in your Kriptonio account => Access Tokens and

copy the token.

Next, we will need a wallet that is going to deploy the smart contract. We will generate one with the Kriptonio SDK.

const wallet = await sdk.wallet.generate({
  chainId: 84532,
  type: 'kernel',
});

Now we are ready to deploy the smart contract, if not already deployed.

const smartContract = await sdk.smartContract.get({
  id: '<smart-contract-id>',
  wallet,
});
 
if (!(await smartContract.deployed())) {
  await smartContract.deploy({
    params: [wallet.address],
  });
}

Milestone reached! 🎉 We have created and deployed an NFT smart contract gaslessly.

Let’s create the Frame UI.

Frame UI

The Frog framework exposes a frame function that accepts the URL path where your frame will be accessible, and as a return, it expects a specification on how to render the frame.

Here is the full code first, and then we will explain it.

app.frame('/', async (c) => {
  let alreadyMinted = false;
  let account: Account | null = null;
  const isMint = c.buttonValue === 'mint';
 
  if (c.frameData && isMint) {
    account = await fetch(`https://fnames.farcaster.xyz/transfers?fid=${c.frameData.fid}`)
      .then((r) => r.json())
      .then((r) => r.transfers[0]);
 
    const tokenId = c.frameData.timestamp;
    const balance = await smartContract.read<bigint>('balanceOf', {
      params: [account.owner],
    });
    alreadyMinted = balance > 0;
 
    if (!alreadyMinted) {
      smartContract
        .write('safeMint', {
          params: [account.owner, tokenId],
        })
        .then((tx) => console.log('minted', tx))
        .catch((e) => console.error('minting error', e.message));
    }
  }
 
  return c.res({
    image: (
      <div
        style={{
          display: 'flex',
          width: '100%',
          height: '100%',
          justifyContent: 'center',
          alignItems: 'center',
          background: 'linear-gradient(to right, #432889, #17101F)',
        }}
      >
        <span style={{ color: 'white', fontSize: '50px' }}>
          {alreadyMinted
            ? 'NFT Already Minted'
            : isMint
              ? `NFT Minted to ${account.username} 🏆`
              : 'Click Mint to mint a free NFT 🖼'}
        </span>
      </div>
    ),
    intents: alreadyMinted ? [] : [<Button value="mint">Mint</Button>],
  });
});

The Frame function provides us with a context c that contains information about the frame, the user interacting with the frame, and other HTTP request-related data.

When a user clicks the Mint button, c.buttonValue will have a mint value, because of the attribute that we defined in the Button component.

In order to mint an NFT, we need the receiver’s wallet address. We can get one from Farcaster directly. We want to get the wallet address of the user who is interacting with the Frame.

For that purpose, we have:

account = await fetch(`https://fnames.farcaster.xyz/transfers?fid=${c.frameData.fid}`)
  .then((r) => r.json())
  .then((r) => r.transfers[0]);

The next important part is to check if the user has already minted an NFT. We can do that by reading the smart contract state and checking how many NFTs the user has.

const balance = await smartContract.read<bigint>('balanceOf', {
  params: [account.owner],
});
 
alreadyMinted = balance > 0;

If the user has not minted an NFT, we can mint one for them.

smartContract.write('safeMint', {
  params: [account.owner, tokenId],
});

Here we call the safeMint smart contract function and pass the receiver's wallet address and the generated NFT token id.

The last part is to define the image and the buttons.

We will have only one button, the Mint button. If the user has already minted an NFT, we will not show any buttons.

intents: alreadyMinted ? [] : [<Button value="mint">Mint</Button>],

The image will be a component that is a simple div that shows the message and the status of the minting process.

image: (
  <div
    style={{
      display: 'flex',
      width: '100%',
      height: '100%',
      justifyContent: 'center',
      alignItems: 'center',
      background: 'linear-gradient(to right, #432889, #17101F)',
    }}
  >
    <span style={{ color: 'white', fontSize: '50px' }}>
      {alreadyMinted
        ? 'NFT Already Minted'
        : isMint
          ? `NFT Minted to ${account.username} 🏆`
          : 'Click Mint to mint a free NFT 🖼'}
    </span>
  </div>
),

Congratulations! You have created a gasless Farcaster NFT mint frame with Frog.fm and Kriptonio.

The full code is available on GitHub.

If you have any questions, feel free to ask in our Discord.

Remarks

The above code is a minimal example that will give you a good starting point to expand it further and cover different edge cases.

One of the first things that you might want to adjust is to have a persistent wallet private key, instead of generating a wallet on every app start. In fact, NFT minting will fail if the smart contract is initialized with a wallet that has not deployed it (not the owner).

Here is an example of how to create a wallet from your own private key:

You can read more about importing existing wallets here.

Thanks for reading, and happy coding!

Bonus Tip

You can operate and inspect created NFT smart contract via Kriptonio iOS/Android mobile apps. Simply login to the mobile app, import the wallet that you used to deploy the wallet, and play with the smart contract.

Links to the mobile app here: https://docs.kriptonio.com/mobile

Originally published at https://docs.kriptonio.com.

Account abstraction based on the ERC-4337 standard is a new way to represent user wallets on Ethereum, offering multiple benefits for users. Wallets will be represented as smart contracts, allowing for the abstraction and programmability of various aspects of current wallets. These include the ability to change the signer/owner of the wallet, the possibility of social recovery, paying gas fees in tokens, sponsoring transaction gas fees, and more.

This article is intended for readers who are already familiar with the basic concepts and components of the ERC-4337 standard and want to learn how to create a simple smart wallet based on the ERC-4337 standard.

Key ingredients

To create a smart wallet, we will need the following:

• Bundler RPC
• Solidity smart contracts for the smart wallet
• Web3 libraries

Bundler RPC

For the bundler RPC, you can get one for free from Kriptonio. Simply register on Kriptonio and create a new bundler RPC endpoint.

In this example, we will use the Polygon Mumbai blockchain network.

Next, copy the RPC endpoint. We will need it soon.

Solidity Smart Contracts for Smart Wallet

We will use contracts provided by eth-infinitism, specifically SimpleAccount.sol for our smart wallet and SimpleAccountFactory.sol. The latter one is used to create new smart wallets on the chain.

Web3 libraries

For sending RPC requests to the blockchain network, we will use the ethers v5 library, and as a helper library for creating and signing UserOperation structs, we will use userop library.

Project setup & installing dependencies

Initialize a new npm project.

npm init -y

Install the required smart wallet dependencies.

yarn add ethers@5 userop

We will also use TypeScript in the project, so let’s install TypeScript dependencies as well.

yarn add -D typescript ts-node
yarn run tsc --init

Let’s code

The first thing we need to do is to create a new classic wallet (EOA) that will be the owner of our new smart wallet. The owner is allowed to send transactions from the smart wallet.

const privateKey = ethers.Wallet.createRandom().privateKey;
const owner = new ethers.Wallet(privateKey);

To create a new Smart Wallet, we need two smart contracts which should be deployed before deploying our smart wallet. The first contract is the EntryPoint contract. It acts as a mediator between bundlers and the actual smart contract wallet.

The second one is the contract used as a factory for deploying a new instance of our smart wallet.

The former one is deployed by the core team, and the latter one has to be deployed by the creator of the smart wallet contract. In this case, it’s eth-infinitism.

In both cases, we don’t need to worry about deployment, so let’s just specify the addresses of these contracts.

const entryPointAddress = '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789';
const factoryAddress = '0x9406Cc6185a346906296840746125a0E44976454';

We are now ready to use the userop library to prepare our smart wallet contract object.

On top of your file, add the following import:

import { Client, Presets } from "userop";

Now you can create a smart account builder instance:

const smartAccount = await Presets.Builder.SimpleAccount.init(
    owner,
    bundlerRpcUrl,
    {
      entryPoint: entryPointAddress,
      factory: factoryAddress,
    }
  );

This will create a builder instance which knows how to create user operations based on SimpleAccount.sol smart contract.

It also knows how to deploy the smart contract upon sending first transaction.

You can already see the future address of our smart wallet by calling getSender method.

console.log('smart wallet address', smartAccount.getSender());

IMPORTANT: In order to successfully send transactions later, the smart wallet needs to have enough funds to pay for gas fees. In this example using the Polygon Mumbai network, we will use the Polygon Mumbai Faucet to get some free test tokens. Simply go to the faucet and paste your wallet address. Wait a few seconds and you should see some tokens in your wallet.

To send transactions from the smart wallet, we need to construct a UserOperation struct, fill it with gas estimates, and sign it. User Operation contains following fields:

{
  sender,
  nonce,
  initCode,
  callData,
  callGasLimit,
  verificationGasLimit,
  preVerificationGas,
  maxFeePerGas,
  maxPriorityFeePerGas,
  paymasterAndData,
  signature,
}

We won’t go into details for each field. Each of these fields is exampled in ERC-4337 spec.

To speed up the process we will be using userop library to create and sign UserOperation struct.

const client = await Client.init(bundlerRpcUrl, {
  entryPoint: entryPointAddress,
});

const result = await client.sendUserOperation(
  smartAccount.execute(smartAccount.getSender(), 0, "0x"),
);

This user operation will send 0 MATIC back to the owner. This transaction doesn’t make much sense in a real-life scenario, but it’s enough to demonstrate account deployment and transaction sending in our scenario.

Let’s now wait for the transaction to be mined.

const event = await result.wait();
console.log(`Transaction hash: ${event?.transactionHash}`);

After transaction is mined you can extract transaction hash from the event object.

As this is the first transaction from the smart wallet, the smart wallet itself will be deployed.

Congratulations 🎉! You have successfully deployed your smart wallet and sent the first user operation via it.

Source Code

You can find the complete source code used in this article here.

Questions

Hopefully, this article was helpful. If you have any questions, feel free to ask them in our Discord server.