Send Transaction

import { MiniKit } from "@worldcoin/minikit-js";
import { encodeFunctionData, parseEther } from "viem";

const PERMIT2 = "0x000000000022D473030F116dDEE9F6B43aC78BA3";

async function approveAndSwap(
  token: `0x${string}`,
  spender: `0x${string}`,
  amount: bigint,
) {
  const result = await MiniKit.sendTransaction({
    chainId: 480,
    transactions: [
      // 1. Approve spender via Permit2
      {
        to: PERMIT2,
        data: encodeFunctionData({
          abi: [
            {
              name: "approve", // You must use this method of Allowance Transfers
              type: "function",
              inputs: [
                { name: "token", type: "address" },
                { name: "spender", type: "address" },
                { name: "amount", type: "uint160" },
                { name: "expiration", type: "uint48" },
              ],
              outputs: [],
              stateMutability: "nonpayable",
            },
          ],
          functionName: "approve",
          args: [
            token,
            spender,
            amount,
            // Always set deadline to 0 as it will be consumed in the same transaction
           0,
          ],
        }),
      },
      // 2. Call your contract (which pulls tokens via permit2.transferFrom)
      {
        to: spender,
        data: encodeFunctionData({
          abi: [
            {
              name: "swap",
              type: "function",
              inputs: [{ name: "amount", type: "uint256" }],
              outputs: [],
              stateMutability: "nonpayable",
            },
          ],
          functionName: "swap",
          args: [amount],
        }),
      },
    ],
  });

  console.log(result.data.userOpHash);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";

contract Swap {
    IERC20 public tokenA;
    IERC20 public tokenB;
    IAllowanceTransfer public immutable permit2;

    constructor(address _tokenA, address _tokenB, address _permit2) {
        tokenA = IERC20(_tokenA);
        tokenB = IERC20(_tokenB);
        permit2 = IAllowanceTransfer(_permit2);
    }

    function swap(uint256 amount) external {
        // Pull tokenA from caller via Permit2 AllowanceTransfer
        permit2.transferFrom(
            msg.sender,
            address(this),
            uint160(amount),
            address(tokenA)
        );
        // Send tokenB to caller
        tokenB.transfer(msg.sender, amount);
    }
}

type SendTransactionResponse =
  | {
      executedWith: "minikit" | "wagmi";
      data: {
        userOpHash: string;
        status: "success";
        version: number;
        from: string;
        timestamp: string;
      };
    }
  | {
      executedWith: "fallback";
      data: unknown;
    };

{
  "executedWith": "minikit",
  "data": {
    "userOpHash": "0x8004b63530b968a2a2c9ff414e01fc06a3ec5e4068d36d923df6aa4334744369",
    "status": "success",
    "version": 2,
    "from": "0x1234567890123456789012345678901234567890",
    "timestamp": "2026-03-28T18:24:00.000Z"
  }
}

import { useUserOperationReceipt } from "@worldcoin/minikit-react";
import { createPublicClient, http } from "viem";
import { worldchain } from "viem/chains";

const client = createPublicClient({
  chain: worldchain,
  transport: http("https://worldchain-mainnet.g.alchemy.com/public"),
});

const { poll, isLoading, reset } = useUserOperationReceipt({ client });

const onClick = async () => {
  const result = await MiniKit.sendTransaction({...});
  const { receipt } = await poll(result.data.userOpHash);
  // receipt contains the final transaction receipt
};

type UserOperationStatusSuccess = {
  status: "success";
  userOpHash: string;
  sender: string;
  transaction_hash: string;
  nonce: string;
};

const response = await fetch(
  `https://developer.world.org/api/v2/minikit/userop/${userOpHash}`,
);
const status = await response.json();

if (status.status === "success") {
  const success = status as UserOperationStatusSuccess;
  console.log(success.transaction_hash);
}