Recently, Meteora deployed native fee compounding in DAMM v2. It's a new fee mode baked into the AMM program itself where the compounding happens inside the swap instruction, atomically, on every single trade.

What We Deployed

DAMM v2 Release 0.2.0 introduces a new pool collect fee mode: Compounding.

When a pool creator sets this mode, a configurable percentage (between 0% to 100%) of quote token trading fees are compounded directly back into pool reserves on every swap. The rest remains claimable.

Just ONE parameter, compoundingFeeBps, to control the split.

Set it to 10000 bps (100%) and every bps of trading fees earned goes back into the pool. Set it to 5000 bps (50%) and you collect half, compound the other half.

This new fee mode is baked into the core AMM, deployed onchain, audited, and open-source.

Why Program-Level Compounding Changes Everything

Every constant-product AMM operates on the same invariant:

x · y = k where x is base token reserves, y is quote token reserves, and k is the constant that defines the pool's liquidity.

So in other words, a larger k = deeper pool liquidity = less slippage.

Previously, DAMM v2 fees are collected and claimed separately due to the quote token fee earnings feature. Many builders loved this as it didn't require the protocol or the liquidity provider to dump the memecoin into SOL or USDC when collecting fees. But this led to a limitation. The pool liquidity doesn't grow from trading activity, it only grows when someone manually adds liquidity.

With CollectFeeMode.Compounding, k grows on every trade.

When a swap executes, the program calculates the trading fee, splits it according to compoundingFeeBps, and adds the compounding portion directly back to the quote token reserves, all within the same instruction. No separate transaction. No external claim. The fee never leaves the pool.

This means after every swap:

x · (y + compoundingFee) = k' where k' > k

The invariant increases. The pool is structurally deeper than it was before the trade. The next trade has slightly less price impact. The ceiling is slightly higher. Every trade that follows compounds on top of the previous one.

This is the flywheel @latebuild described, but enforced at the program level where: more volume → more fees → higher k → less slippage → bigger buys possible → higher ceiling → more volume

The key difference is that nothing can break this loop. There's no bot to go offline. No claim transaction to miss. No swap step that leaks value due to price impact. The compounding is atomic and unconditional.

Why DAMM v2 Beats Every Alternative

Most AMMs decide where your fees go. DAMM v2 lets you.

Raydium AMM v4 had a fixed 0.25% fee per trade. 0.22% went back to the pool and auto-compounded. 0.03% went to RAY buybacks. That's 88% fee compounded back, but hardcoded. Every pool got the same split regardless of what the token needed. No configuration. No creator fee. No dynamic adjustment.

PumpSwap tried to improve on this with a tiered fee schedule based on SOL-denominated market cap. At the lowest tier (0–420 SOL mcap), where the vast majority of graduated tokens live, the split is 0.93% to the protocol, 0.30% to the creator, and 0.02% to the pool. Which leads to a 98.4% non-compounding rate on a 1.25% total fee. At the highest tier (98,240+ SOL), the LP fee rises to 0.20% on a 0.30% total fee. Better, but still lower than the 0.22% Raydium AMM v4 gave. And almost no token reaches that tier. The overwhelming majority of trading volume happens at the bottom of the schedule. No configuration. No creator control.

DAMM v2 with CollectFeeMode.Compounding doesn't iterate on either model. It operates on a fundamentally different one. The pool creator sets compoundingFeeBps at creation (anywhere from 0 to 10,000 basis points) and that percentage of quote token fees compounds directly into pool reserves on every swap. Inside the swap instruction. Same transaction.

The numbers make the gap obvious. On $100K volume, a DAMM v2 pool with 100% compounding and a 1% fee returns up to $1,000 to the pool, compared to $220 on Raydium and $20 on PumpSwap at the lowest tier. After $1M cumulative volume, the gap accelerates. Every dollar that flows into k generates future fees that also flow into k. The difference isn't linear. It compounds.

The Full DAMM v2 Stack

Fee compounding alone would be enough to justify the switch. But what makes DAMM v2 a generational upgrade is how compounding stacks with everything else the program already does.

Dynamic fees + Compounding: Fees adjust based on real-time volatility. Volatile periods don't just earn more, they compound more into the pool, structurally deepening liquidity exactly when it needs to be deepest.

Fee time / market cap scheduling + Compounding: Fees start high at launch and decay on your terms, either by time or by market cap. With 100% compounding, the highest-fee period of a token's life builds the deepest liquidity. Set launch fees at 5%, decaying to 0.5% over 24 hours or when a token reaches a certain market cap. The first hour of manic trading builds a liquidity base that other AMMs would take weeks otherwise.

Position NFTs + Compounding: Positions are lockable and vestable while still accruing compounded fees. Lock liquidity, set compounding to 100%, and the pool deepens itself without anyone touching it.

Concentrated liquidity + Low cost: Price ranges on constant-product without bin management or 0.25 SOL setup costs. Pool + position costs 0.022 SOL.

Built-in farming: Most AMMs require a separate staking program to distribute rewards. DAMM v2 doesn't. Farming is native to the pool, with each pool having its own reward vault supporting up to two reward tokens. No external contracts. No extra integration. Creators fund rewards directly into the pool they created.

Putting it all together, you can launch a token with decaying fees, compound a certain % of fees back, lock the position and let the pool grow from its own volume.

k should only go up

The liquidity problem was never about fees existing. It was about fees leaving. Every basis point that exits the pool is a basis point that never compounds into future depth. Over thousands of trades, the difference between a compounding pool and a non-compounding pool isn't incremental. It's categorical.

CollectFeeMode.Compounding makes the fee flywheel a native AMM primitive. Configurable by the creator. Enforced by the program. Executed inside the swap. No bot. No router. No dependencies.

The drain doesn't need a plug. It needs to not exist.

Get Started TODAY

DAMM v2 Release 0.2.0 is open source, audited, and live.

• CollectFeeMode.Compounding (mode 2) joins the existing BothToken (0) and OnlyB (1) modes.

• Fee accounting splits tradingFee into claimingFee + compoundingFee.

• A LiquidityHandler abstraction dispatches math based on fee mode.

Create your first compounding pool with the TypeScript SDK: npmjs.com/package/@meteora-ag/cp-amm-sdk

Documentation: https://docs.meteora.ag/developer-guide/guides/damm-v2/overview

Credits to @sudoku_defi for architecting and shipping this upgrade. ❤

In my previous article, I broke down how Jupiter Swap works and demonstrated how you can 10x your dApp development speed when creating React hooks powered by Jupiter’s APIs for seamless swap integration.

But what if I told you that you could 100x your speed and build a dApp with full swap functionality in record time?

That is exactly what we are exploring today. Introducing Jupiter Terminal, an open-source, lightweight version of Jupiter that seamlessly embeds into your HTML. Imagine your dApp having a swap component that looks and feels just like jup.ag. That is the added power that Jupiter Terminal brings with no unnecessary redirects, no disruptions, just a flawless user experience.

In this Builder Guide, I'll be going through how you can integrate Jupiter Terminal directly into your HTML, while also detailing how you can customize the configurations of the swap terminal, allowing you to choose the display mode that best suit your needs. Additionally, I'll also navigate you through some of the JavaScript technical nuances so that you can successfully build from scratch your own swap Terminal.

Well, think of it as a lightweight, plug-and-play version of what you see on jup.ag. It's core purposes? Delivering a seamless, end-to-end swap flow that you can integrate effortlessly with only just a few lines of code in your HTML.

As of today (03/01/2025) in terms of Space Station's documentation, Jupiter's APIs currently only consists of the Swap V6 API endpoint (which will be deprecated soon) and also the newly improved Swap V1 API endpoint that only contains Manual Mode.

Meanwhile, Jupiter Terminal is already ahead of the curve, fully equipped with Ultra Mode and its cutting-edge innovations, such as:

Real-time slippage estimation (RTSE) – Leverages real-time swap data from actual users, historical trends, and heuristics to determine the most optimal slippage for each trade, minimizing losses and improving execution efficiency.

Dynamic priority fees – Estimates optimal transaction fees by analyzing network activity, swap size, and interactions with high-traffic accounts, ensuring your transactions are prioritized without unnecessary overpayment.

Optimised transaction landing – Fires transactions across multiple providers simultaneously, increasing the likelihood of successful execution, especially in volatile market conditions.

Jupiter Shield (coming soon) – Designed to enhance security and safeguard swaps from potential risks in token selection.

Jupiter Uplink

@jup_uplink

Ultra Mode: the cheaper and better way to swap tokens.

23

5:48 • 21 Feb 2025

To lay the basis, I will be exploring two approaches of how you can integrate Jupiter Terminal into a Typescript React application, both of which begin by embedding a <script> tag in a HTML file.  The first method involves initializing the Jupiter object via window object, while the second method leverages the @jup-ag/terminal npm package to initialize Jupiter Terminal.

As we are building in a Typescript React application for this Builder Guide, we will need to do this step. Since Jupiter Terminal is only importable via CDN, to get proper typing, you will need to create a type declaration file - terminal.d.ts - in your project's types folder and copy the following content.

declare global {
  interface Window {
    Jupiter: JupiterTerminal;
  }
}

In today’s development landscape, there are many different React-based frameworks that are widely used for building applications. For this builder guide, we will demonstrate two approaches: one for a plain React application and another specifically for Next.js projects.

In your index.html file, include the following code to allow Terminal to work anywhere in your web application.

<head>
	...
	<script src='https://terminal.jup.ag/main-v4.js' data-preload defer></script>
</head>

For Next.js applications, you can modify your app.tsx or _app.js file with the Next.js built-in next/script component.

import Script from 'next/script';

function MyApp({ Component, pageProps }) {
  return (
    <>
      <Script
        src="https://terminal.jup.ag/main-v4.js"
        strategy="beforeInteractive" // this allows it to load early like a <head> script
		data-preload // custom attribute
		defer // ensures that it does not block parsing
      />
      <Component {...pageProps} />
    </>
  );
}

export default MyApp;

If your Next.js application follows the App Router structure rather than the older Pages Router, you can place the script in the layout.tsx to apply it globally across your application.

import Script from 'next/script';
import type { Metadata } from 'next';
import './globals.css';

export const metadata: Metadata = {
  title: 'Jupiter Terminal Example',
  description: 'Effortlessly Integrate Jupiter Terminal into your dApp',
};

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <head>
        <Script 
          src="https://terminal.jup.ag/main-v4.js" 
          strategy="beforeInteractive" 
          data-preload 
          defer 
        />
      </head>
      <body>
        {children}
      </body>
    </html>
  );
}

Now that the Terminal script is embedded in your React application, it’s ready to be used throughout your project. But how do we initialize it?

If you are using a plain React application that contains index.html, you can simply initialize a Jupiter via the window object in your <body>.

<body>
  <h1>Jupiter Swap Demo</h1>
  <div id="jupiter-terminal"></div>
  <script>
    document.addEventListener("DOMContentLoaded", function () {
      const jupiterTerminal = document.createElement('div') // create jupiter terminal div
      jupiterTerminal.id = 'jupiter-terminal'
      document.body.appendChild(jupiterTerminal)

      // initialize jupiter terminal
      window.Jupiter.init({
        displayMode: "integrated",
        integratedTargetId: "integrated-terminal",
        endpoint: "https://mainnet.helius-rpc.com/?api-key=HELIUS_API_KEY",
        formProps: {
          fixedOutputMint: false
        }
      });
    });
  </script>
</body>

For Next.js applications, you can initialize Jupiter Terminal via a useEffect hook and adding a <div> with the id of the terminal that has been declared.

"use client";

import React, { useEffect } from "react";

export default function TerminalExample() {
  useEffect(() => {
    if (typeof window !== "undefined") {
      window.Jupiter.init({
  		displayMode: "integrated",
  		integratedTargetId: "integrated-terminal",
  		endpoint: "https://mainnet.helius-rpc.com/?api-key=HELIUS_API_KEY",
	  });
    }
  }, []);

  return (
    <div>
      <h1>Jupiter Terminal Example</h1>
      {/* This is where the terminal will be embedded */}
      <div id="integrated-terminal" style={{ width: "100%", height: "500px" }}></div>
    </div>
  );
}

Alternatively, you can also initialize Jupiter Terminal via the npm package @jup-ag/terminal.

• Install @jup-ag/terminal package

After installing this package, you can use a useEffect hook and initialize Terminal like this.

"use client";

import React, { useEffect } from "react";
import "@jup-ag/terminal/css";

export default function TerminalExample() {
  useEffect(() => {
    if (typeof window !== "undefined") {
      import("@jup-ag/terminal").then((mod) => {
        const { init } = mod;
        init({
          displayMode: "integrated",
          integratedTargetId: "integrated-terminal",
          endpoint: "https://api.mainnet-beta.solana.com",
        });
      });
    }
  }, []);

  return (
    <div>
      <h1>Jupiter Terminal</h1>
      {/* This is where the terminal will be embedded */}
      <div id="integrated-terminal" style={{ width: "100%", height: "500px" }}></div>
    </div>
  );
}

From the code above, I have demonstrated Jupiter Terminal using only the Integrated display mode. However, Jupiter Terminal is highly versatile and supports a total of three display modes to suit different use cases: Integrated, Widget, and Modal.

For each display mode, I will outline the customizable parameters that allow you to modify the Terminal’s behavior based on your chosen mode.

interface IntegratedTerminal {
  displayMode: "integrated";
  integratedTargetId: string;

  /** Form configuration options */
  formProps: {
    /** Initial amount to swap */
    initialAmount?: string;
    /** When true, user cannot change the amount (e.g. for Payments) */
    fixedAmount?: boolean;
    /** Initial input token to swap */
    initialInputMint?: string;
    /** When true, user cannot change the input token */
    fixedInputMint?: boolean;
    /** Initial output token to swap */
    initialOutputMint?: string;
    /** When true, user cannot change the output token (e.g. to buy your project's token) */
    fixedOutputMint?: boolean;
  };

  /** Restrict token selection to a predefined list */
  strictTokenList: boolean;

  /** Style using CSS properties */
  containerStyles: React.CSSProperties;

  /** Style using Tailwind CSS class names */
  containerClassName: string;

  /** Triggered when an error occurs during the swap process */
  onSwapError?: ({
    error,
    quoteResponseMeta,
  }: {
    error?: TransactionError;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;

  /** Triggered when a swap transaction is successfully completed */
  onSuccess?: ({
    txid,
    swapResult,
    quoteResponseMeta,
  }: {
    txid: string;
    swapResult: SwapResult;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;
}

type WidgetPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
type WidgetSize = "sm" | "default";

interface WidgetTerminal {
  displayMode: "widget";

  /** Form configuration options */
  formProps: {
    /** Initial amount to swap */
    initialAmount?: string;
    /** When true, user cannot change the amount (e.g. for Payments) */
    fixedAmount?: boolean;
    /** Initial input token to swap */
    initialInputMint?: string;
    /** When true, user cannot change the input token */
    fixedInputMint?: boolean;
    /** Initial output token to swap */
    initialOutputMint?: string;
    /** When true, user cannot change the output token (e.g. to buy your project's token) */
    fixedOutputMint?: boolean;
  };

  /** Restrict token selection to a predefined list */
  strictTokenList: boolean;

  /** When displayMode is 'widget', this is the behaviour and style of the widget */
  widgetStyle?: {
    position?: WidgetPosition;
    size?: WidgetSize;
  };

  /** Triggered when an error occurs during the swap process */
  onSwapError?: ({
    error,
    quoteResponseMeta,
  }: {
    error?: TransactionError;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;

  /** Triggered when a swap transaction is successfully completed */
  onSuccess?: ({
    txid,
    swapResult,
    quoteResponseMeta,
  }: {
    txid: string;
    swapResult: SwapResult;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;
}

interface ModalTerminal {
  displayMode: "modal";

  /** Form configuration options */
  formProps: {
    /** Initial amount to swap */
    initialAmount?: string;
    /** When true, user cannot change the amount (e.g. for Payments) */
    fixedAmount?: boolean;
    /** Initial input token to swap */
    initialInputMint?: string;
    /** When true, user cannot change the input token */
    fixedInputMint?: boolean;
    /** Initial output token to swap */
    initialOutputMint?: string;
    /** When true, user cannot change the output token (e.g. to buy your project's token) */
    fixedOutputMint?: boolean;
  };

  /** Restrict token selection to a predefined list */
  strictTokenList: boolean;

  /** Triggered when an error occurs during the swap process */
  onSwapError?: ({
    error,
    quoteResponseMeta,
  }: {
    error?: TransactionError;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;

  /** Triggered when a swap transaction is successfully completed */
  onSuccess?: ({
    txid,
    swapResult,
    quoteResponseMeta,
  }: {
    txid: string;
    swapResult: SwapResult;
    quoteResponseMeta: QuoteResponse | null;
  }) => void;
}

For Modal Terminal, you can create a <button> with an onClick handler function that calls a function that initializes the Jupiter Terminal.

import React from 'react';

export default function ModalTerminalExample() {
  const handleLaunchTerminal = () => {
    window.Jupiter.init({
  		displayMode: "modal",
  		integratedTargetId: "modal-terminal",
  		endpoint: "https://mainnet.helius-rpc.com/?api-key=HELIUS_API_KEY",
	  });
  };

  return (
    <button onClick={handleLaunchTerminal}>
      <span>Launch Terminal Modal</span>
    </button>
  );

}

Summing this step-by-step guide, we explored two approaches to integrating Jupiter Terminal into a TypeScript React application. Both methods involved embedding the Jupiter Terminal script in the application, with initialization handled either through the window object or via the @jup-ag/terminal package using the useEffect hook.

For React applications, we demonstrated how to include the script in index.html and initialize Jupiter Terminal within the <body>. For Next.js applications, we leveraged Next.js built-in next/script component and integrated the terminal either in _app.js, layout.tsx, or inside a specific page component using useEffect.

With Jupiter Terminal now set up in your application, you can take advantage of its three display modes—Integrated, Widget, and Modal—to best suit your needs.

Jupiter Terminal revolutionizes swap integration by providing a lightweight, open-source solution that seamlessly embeds into your dApp with minimal effort. Whether you want a fully embedded experience, a floating widget, or a sleek modal, Jupiter Terminal adapts to your design needs while maintaining quality end-to-end swaps without unnecessary redirects or disruptions.

I hope that this guide has provided you with a clear and practical understanding of how to integrate Jupiter Terminal into your dApp, enabling you to streamline swap functionality with minimal effort. Whether you’re building with React or any React-based frameworks, leveraging window-based initialization or the @jup-ag/terminal package, you now have the tools to create a seamless and efficient swap experience for your users.

As Jupiter Terminal continues to evolve, integrating it into your dApp ensures that you’re always at the forefront of Solana DeFi innovation.

Welcome to the Jupiverse

Now, what if I told you that your smart contracts could maintain themselves, freeing you from the constant need to trigger them manually?

Well, thanks to Chainlink Automation, they make automating smart contracts feel like a walk-in-the-park. With Chainlink's Decentralized Oracle Network (Chainlink DON) and onchain Registry architecture, they are able to automate your smart contracts so that you don't have to worry about dealing with setup costs, ongoing maintenance, and risks associated with a centralized automation stack.

In this Builder Guide, I'll be walking you through the process of creating automation-compatible contracts and programmatically registering upkeeps. This will give you full control over the custom logic you want on Chainlink's onchain registry. In return, you’ll receive an upkeepID, which you can use to check balances, fund, modify, or cancel the upkeep all via the registry.

P.S. The Chainlink Automation App interface also provides pre-built options to register upkeeps with custom triggers, time-based triggers, or log-based triggers if you choose not to programatically register your upkeeps.

The diagram below shows a high-level overview of the flow of how Chainlink Automation works.

At its core, the Chainlink Automation Network relies on the Automation Registry, which manages network actors and ensures Automation Nodes are compensated for successfully executing upkeeps.

Automation Nodes operate as a peer-to-peer network using Chainlink’s OCR3 protocol. These nodes rely on the Automation Registry to identify which upkeeps to service and independently simulate checkUpkeep functions on their own block nodes to determine when an upkeep is eligible for execution. Once an upkeep is identified, nodes reach consensus through OCR3 and generate a signed report containing the performData, which is then validated on the Registry before execution. This process ensures cryptographic guarantees, enhancing security and reliability. Additionally, the network is designed with built-in redundancy, ensuring upkeeps are executed even if some nodes go offline.

Chainlink Automation leverages the same battle-tested transaction manager mechanism used in Chainlink Data Feeds. This ensures a highly reliable automation service capable of executing and confirming transactions even during extreme gas spikes or on chains experiencing significant reorgs. By combining robust consensus mechanisms with proven transaction management, Chainlink Automation provides a resilient and efficient solution for decentralized task execution.

To set the stage, this guide will be based on the Base Sepolia network, utilizing Solidity as the programming language and Foundry as the contract deployment toolkit. To better illustrate the entire automation flow, I will demonstrate it using a Dutch Auction for Token ICOs project that I previously built. This project is very similar to the concept of Liquidity Bootstrapping Pools.

Fundamentally, there are 2 main contracts that are used to programatically register automation-compatible contracts:

1. Auctioneer.sol - A Dutch Auction Factory contract for creating and managing Dutch Auctions. This contract contains an internal function to registerUpkeep onto Chainlink.

2. DutchAuction.sol - A Dutch Auction contract designed for token ICOs. It includes the checkUpkeep and performUpkeep functions, which automate auction finalization, airdrop tokens to users, refund surplus ETH, and burn any remaining tokens.

• forge install Chainlink's Smart Contract Kit.

• forge install Open Zeppelin Contracts.

• Get Base Sepolia ETH from Alchemy.

• Get LINK Tokens on Base Sepolia Network.

P.S. I will be skipping the core logic of the smart contracts and focus primarily on the Chainlink Automation functions within them. If you’re interested in the full source code, you can find it in this Github repository.

In our context, theDutchAuction.sol will be an automation-compatible smart contract that contains checkUpkeep and performUpkeep functions. These functions allows the Chainlink Automation Network to determine if, when, and how the contract should be automated.

• checkUpkeep contains the logic that will be executed offchain such that if the criteria in this function that you have set has been met, then the Chainlink Automation Network will automatically trigger performUpkeep.

• performUpkeep contains the logic that will be executed onchain when checkUpkeep returns true. In our case, this function contains the endAuction, airdropToken, refundETH and burnTokens logic that we want to be automatically executed for the Dutch Auction.

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

import {Token} from "./Token.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {Pausable} from "@openzeppelin/contracts/utils/Pausable.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {AutomationCompatibleInterface} from "@chainlink/contracts/src/v0.8/automation/AutomationCompatible.sol";

contract DutchAuction is ReentrancyGuard, Pausable, Ownable, AutomationCompatibleInterface {

	// ... initialise variables, errors, events, mappings and functions

	/////////////////////////////////////////
	///// CHAINLINK AUTOMATION FUNCTIONS ////
	/////////////////////////////////////////

    /**
     * @notice Chainlink Automation: Check if upkeep is needed
     */
    function checkUpkeep(bytes calldata /* checkData */ )
        external
        view
        override
        returns (bool upkeepNeeded, bytes memory /* performData */ )
    {
        upkeepNeeded = (startTime != 0) // auction has started
            && !auctionEnded // auction hasn't ended yet
            && (block.timestamp >= endTime || getRemainingTokens() == 0); // time is up OR remaining tokens is 0
        return (upkeepNeeded, "");
    }

    /**
     * @notice Chainlink Automation: Perform the upkeep
     */
    function performUpkeep(bytes calldata /* performData */ ) external override {
        if (startTime == 0) revert AuctionNotStarted();
        if (auctionEnded) revert AuctionAlreadyEnded();
        if (block.timestamp < endTime && getRemainingTokens() > 0) revert AuctionNotEnded();

		// Ends the auction
        auctionEnded = true;

        // Tokens to distribute are the total tokens sold
        uint256 tokensToDistribute = getSoldTokens();

        // Get the clearing price
        clearingPrice = getCurrentPrice();

        // Airdrop tokens to bidders proportionally
        for (uint256 i = 0; i < bidders.length; i++) {
            address bidder = bidders[i];
            uint256 ethContribution = ethContributed[bidder];

            // Calculate tokens for this bidder based on their ETH contribution
            uint256 tokenAmount = (ethContribution * tokensToDistribute) / totalEthRaised;
            uint256 ethNeeded = tokenAmount * clearingPrice;
            uint256 refund = ethContribution - ethNeeded;

            if (refund > 0) {
                (bool success,) = bidder.call{value: refund}("");
                if (!success) revert RefundFailed();
            }

            if (tokenAmount > 0 && !hasClaimedTokens[bidder]) {
                hasClaimedTokens[bidder] = true;
                bool success = token.transfer(bidder, tokenAmount * 1e18);
                if (!success) {
                    hasClaimedTokens[bidder] = false;
                    revert TransferFailed();
                }
                emit TokensClaimed(bidder, tokenAmount * 1e18);
            }
        }

        // Burn any remaining tokens
        uint256 remainingTokens = totalTokensForSale - tokensToDistribute;
        if (remainingTokens > 0) {
            token.burn(remainingTokens * 1e18);
        }

        emit AuctionEnded(clearingPrice, tokensToDistribute, totalEthRaised);
    }
}

** Please note that the logic in checkUpkeep and performUpkeep is completely customisable based on your automation trigger. The only important thing you need to do is to inherit the AutomationCompatibleInterface from Chainlink.

Now that we have created an automation-compatible contract - DutchAuction.sol, we can create Auctioneer.sol, which includes the registerUpkeep function. This function is triggered whenever a user deploys DutchAuction.sol, programmatically registering it onto the Chainlink Automation Network.

The Auctioneer.sol covers the following main areas:

• Import LinkTokenInterface to instantiate an ERC20 token interface for transferring of LINK.

• Create a RegistrationParams struct for when calling registerUpkeep function on the Chainlink Registrar contract.

• Instantiate an interface called AutomationRegistrarInterface that contains the registerUpkeep function.

• Create an internal function that approve the transfer of LINK tokens, initialises the registration parameters and call registerUpkeep.

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

import {DutchAuction} from "./DutchAuction.sol";
import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/shared/interfaces/LinkTokenInterface.sol";

// Create a RegistrationParams struct
struct RegistrationParams {
    address upkeepContract;
    uint96 amount;
    address adminAddress;
    uint32 gasLimit;
    uint8 triggerType;
    IERC20 billingToken;
    string name;
    bytes encryptedEmail;
    bytes checkData;
    bytes triggerConfig;
    bytes offchainConfig;
}

// Instantiate an Automation Registrar Interface
interface AutomationRegistrarInterface {
    function registerUpkeep(RegistrationParams calldata requestParams) external returns (uint256);
}

contract Auctioneer {
	LinkTokenInterface public immutable i_link;
	AutomationRegistrarInterface public immutable i_registrar;

	// ... initialise variables, errors, events, mappings and functions

	/** 
	* When deploying Auctioneer.sol, you would need the LINK token address, Chainlink Registrar address and the Chainlink Registry address
	*/
	constructor(address _link, address _registrar, address _registry) {
        if (_link == address(0) || _registrar == address(0) || _registry == address(0)) {
            revert InvalidAddresses();
        }
        i_link = LinkTokenInterface(_link); 
        i_registrar = AutomationRegistrarInterface(_registrar);
        i_registry = _registry; 
    }

    /**
     * @notice Create a new Dutch auction
     */
    function createAuction(
        string memory _name,
        string memory _symbol,
        uint256 _totalSupply,
        uint256 _initialPrice,
        uint256 _reservePrice,
        uint256 _minimumBid
    ) external returns (address) {
        // Create new auction
        DutchAuction newAuction = new DutchAuction(
            _name, _symbol, _totalSupply, _initialPrice, _reservePrice, _minimumBid, msg.sender, address(this)
        );

        // Transfer LINK tokens from msg.sender to this contract
        if (!i_link.transferFrom(msg.sender, address(this), UPKEEP_MINIMUM_FUNDS)) {
            revert LinkTransferFailed();
        }

        // Register the upkeep
        uint256 upkeepId = _registerAuctionUpkeep(address(newAuction));

        // Setup auction with registry (not registrar)
        auctions.push(newAuction);
        isValidAuction[address(newAuction)] = true;
        auctionUpkeepIds[address(newAuction)] = upkeepId;

        emit AuctionCreated(
            address(newAuction), _name, _symbol, _totalSupply, _initialPrice, _reservePrice, _minimumBid, upkeepId
        );

        return address(newAuction);
    }

	//////////////////////////////////////////
    ///// CHAINLINK AUTOMATION FUNCTIONS /////
    //////////////////////////////////////////

	/**
     * @notice Internal function to register upkeep for an auction
     * @param auctionAddress The address of the auction to register upkeep for
     * @return upkeepId The ID of the registered upkeep
     */
    function _registerAuctionUpkeep(address auctionAddress) internal returns (uint256) {
        // Approve LINK transfer to registrar
        i_link.approve(address(i_registrar), UPKEEP_MINIMUM_FUNDS);

        // Prepare registration parameters
        RegistrationParams memory params = RegistrationParams({
            name: "Dutch Auction Automation",
            encryptedEmail: bytes(""),
            upkeepContract: auctionAddress,
            gasLimit: UPKEEP_GAS_LIMIT,
            adminAddress: msg.sender,
            triggerType: 0,
            checkData: bytes(""),
            triggerConfig: bytes(""),
            offchainConfig: bytes(""),
            amount: UPKEEP_MINIMUM_FUNDS,
            billingToken: IERC20(address(i_link))
        });

        // Register upkeep
        try i_registrar.registerUpkeep(params) returns (uint256 upkeepId) {
            return upkeepId;
        } catch {
            revert UpkeepRegistrationFailed();
        }
    }
}

** For the LINK token address, Automation Registry address and Automation Registrar address on Base Sepolia network, you can refer to this deployAuctioneer.s.sol file.

Important to note: Chainlink Automation deploys different versions of AutomationRegistry.sol across various chains. For example, Ethereum Sepolia uses AutomationRegistry2_1.sol, while Base Sepolia uses AutomationRegistry2_3.sol. The key difference to be aware of is that the RegistrationParams struct varies between versions:

• AutomationRegistry2_1.sol on Ethereum Sepolia does not require billingToken in the struct

// RegistrationParams for AutomationRegistry2_1.sol
struct RegistrationParams {
    string name;
    bytes encryptedEmail;
    address upkeepContract;
    uint32 gasLimit;
    address adminAddress;
    uint8 triggerType;
    bytes checkData;
    bytes triggerConfig;
    bytes offchainConfig;
    uint96 amount;
}

• AutomationRegistry2_3.sol on Base Sepolia requires billingToken in the struct

// RegistrationParams for AutomationRegistry2_3.sol
struct RegistrationParams {
    address upkeepContract;
    uint96 amount;
    address adminAddress;
    uint32 gasLimit;
    uint8 triggerType;
    IERC20 billingToken;
    string name;
    bytes encryptedEmail;
    bytes checkData;
    bytes triggerConfig;
    bytes offchainConfig;
}

Putting it all together, this guide walks you through the process of creating automation-compatible smart contracts and seamlessly registering upkeeps on the Chainlink Automation Network. The two key contracts — DutchAuction.sol and Auctioneer.sol — work hand in hand, with DutchAuction.sol implementing Chainlink’s checkUpkeep and performUpkeep functions to automate auction finalization, while Auctioneer.sol handles programmatic upkeep registration via the registerUpkeep function.

By leveraging Chainlink Automation, we can eliminate the need for manual smart contract triggers, allowing decentralized applications to function autonomously with greater reliability and efficiency.

I hope that the structured approach used in this guide is able to assist you in your journey of integrating automation into smart contracts, making it easier to deploy, manage, and scale your decentralized system.

With a solid understanding of upkeep registration and automation logic, you are now equipped with the power to build resilient and self-sustaining smart contracts.

Let's work towards building together a fully autonomous onchain future together.

Now, what if I told you that in just 15 to 30 minutes, the Solana dApp that you’re building could seamlessly integrate a Jupiter Swap feature that enables users to transact effortlessly without ever leaving the platform?

That's right. With Jupiter's streamlined swap integration process, you can empower your users to access lightning-fast token swaps directly within your dApp. No extra steps, no unnecessary redirects. Just a smooth, intuitive experience that keeps users engaged while enhancing the functionality of your platform.

In this Builder Guide, I'll walk you through how you can create from scratch a Swap feature that enables seamless swaps on your platform while also covering how you can successfully land transactions onchain with Jupiter. Additionally, I'll show how you can activate a referral fee feature, allowing your platform to earn a fee on every swap transaction made through it. Whether you’re an established Solana dApp or just starting your journey, this guide will provide you with the tools and insights to build a world-class user experience.

Fundamentally, Jupiter Swap is powered by an intricate routing engine, named Metis, designed to handle Solana's numerous AMMs and provide users with the best swap prices while operating seamlessly on Solana's hyper-fast block times.

The diagram below illustrates the evolution of Jupiter Swaps, progressing from V1 to V2 to Metis, growing from single-route swaps to multi-route swaps to incremental-route swaps. Metis optimizes swap prices by streaming input tokens to incrementally construct routes that can split and merge at any stage. This iterative approach allows routes to be generated sequentially for each split, enabling the reuse of the same / different DEX across different splits. As a result, Jupiter can dynamically evaluate route prices, ensuring users receive the best possible swap price.

The Jupiter Swap API facilitates seamless token swaps on the Solana blockchain by enabling developers to interact with liquidity pools efficiently. Upon receiving these inputs, the API returns a serialized transaction that can be signed and broadcasted to the network. You can enhance transaction success by leveraging advanced features like priority fees, compute unit limits, and MEV protection.

The following JSON represents the payload for a POST /swap endpoint request:

{
  // The public key of the user making the request (REQUIRED)
  "userPublicKey": "string",

  // Automatically wrap/unwrap SOL if true; use wSOL token account otherwise (default: true)
  "wrapAndUnwrapSol": true,

  // Enable shared program accounts; required if using destinationTokenAccount
  "useSharedAccounts": true,

  // Fee token account; must be created beforehand if feeBps is set
  "feeAccount": "string",

  // A public key used to track transactions (useful for integrators)
  "trackingAccount": "string",

  // Compute unit price for prioritizing the transaction (in micro lamports)
  "computeUnitPriceMicroLamports": 0,

  // Additional fee for prioritizing the transaction in lamports
  "prioritizationFeeLamports": 0,

  // Request a legacy transaction instead of a versioned transaction (default: false)
  "asLegacyTransaction": false,

  // Use the token ledger to calculate token input based on differences (default: false)
  "useTokenLedger": false,

  // Public key of the token account to receive the output tokens
  "destinationTokenAccount": "string",

  // Enable dynamic compute unit limits using swap simulation (default: false)
  "dynamicComputeUnitLimit": true,

  // Skip RPC calls to check user's accounts; assumes all accounts are set up
  "skipUserAccountsRpcCalls": true,

  // Dynamic slippage settings for trade optimization
  "dynamicSlippage": {
    // Minimum slippage tolerance in basis points (bps)
    "minBps": 0,

    // Maximum slippage tolerance in basis points (bps)
    "maxBps": 0
  },

  // Response from a quote including details of the transaction
  "quoteResponse": {
    // Mint address of the input token
    "inputMint": "string",

    // Amount of input tokens
    "inAmount": "string",

    // Mint address of the output token
    "outputMint": "string",

    // Amount of output tokens
    "outAmount": "string",

    // Threshold amount for the trade
    "otherAmountThreshold": "string",

    // Swap mode (e.g., ExactIn or ExactOut)
    "swapMode": "ExactIn",

    // Slippage in basis points
    "slippageBps": 0,

    // Platform fee details
    "platformFee": {
      // Amount of the fee
      "amount": "string",

      // Fee in basis points
      "feeBps": 0
    },

    // Percentage impact on price due to the trade
    "priceImpactPct": "string",

    // Route plan details for the trade
    "routePlan": [
      {
        "swapInfo": {
          // Key of the automated market maker (AMM)
          "ammKey": "string",

          // Label identifying the AMM
          "label": "string",

          // Mint address of the input token
          "inputMint": "string",

          // Mint address of the output token
          "outputMint": "string",

          // Input token amount
          "inAmount": "string",

          // Output token amount
          "outAmount": "string",

          // Fee amount for the trade
          "feeAmount": "string",

          // Mint address of the fee token
          "feeMint": "string"
        },

        // Percentage of the total trade allocated to this route
        "percent": 0
      }
    ],

    // Slot context of the quote
    "contextSlot": 0,

    // Time taken for the quote in milliseconds
    "timeTaken": 0
  }
}

The Jupiter Quote API is used to obtain optimal token swap routes and pricing. The API provides a detailed route plan, price impact, and fee breakdown to help users evaluate their swaps before execution.

Required Parameters:

• inputMint (string): The mint address of the input token.

• outputMint (string): The mint address of the output token.

• amount (integer): The amount of input tokens in the smallest unit (e.g. lamports for SOL).

Optional Parameters:

• slippageBps (integer): Defaults to 50 basis points (0.5%). Specifies the maximum slippage allowed for the swap.

• dexes (string[]): Defaults to including all available decentralized exchanges (DEXes). You can specify an array of DEX names to include only selected DEXes.

• excludeDexes (string[]): Excludes specific decentralized exchanges from the routing. (e.g. ["DEX1", "DEX2"]).

• swapMode (string): ExactIn (default) for swaps with a fixed input amount. ExactOut for swaps requiring an exact output amount (useful for payments).

• restrictIntermediateTokens (boolean): Defaults to false. Restricts intermediate tokens to highly liquid pairs. This also helps to increase the chances of your transaction landing onchain.

• onlyDirectRoutes (boolean): Defaults to false. If set to true, the routing is restricted to single-hop routes (direct swaps) only.

• asLegacyTransaction (boolean): Defaults to false. When enabled, the API uses legacy transactions instead of versioned transactions.

• platformFeeBps (integer): Specifies a platform fee in basis points (BPS) to be deducted from the output token amount.

• maxAccounts (integer): Allows you to limit the maximum number of accounts involved in the quote for easier integration with your own accounts.

• autoSlippage (boolean): Defaults to false. If enabled, the API provides a suggested smart slippage value to optimize the swap process.

• autoSlippageCollisionUsdValue (integer): Defaults to 1000. When autoSlippage is enabled, this parameter defines the USD value used to calculate the smart slippage impact. You can set a custom USD value here.

• maxAutoSlippageBps (integer): Works in conjunction with autoSlippage=true. Specifies the maximum slippageBps allowed when using smart slippage. Setting this ensures the slippage value remains within a reasonable range.

The Jupiter Tokens API provides detailed information about tokens available in the Jupiter ecosystem. It offers flexibility for retrieving token data by tag, mint address, or liquidity/market thresholds. Here are the details of the parameters and endpoints:

GET Tokens by Tag - https://tokens.jup.ag/tokens?tags=

• Retrieves tokens filtered by specific tags.

• Convenience Tags:

  • verified: Tokens verified and trusted by Jupiter. Combines “community” and “lst” tags.

  • unknown: Tokens flagged as unverified or requiring caution.

• Other Tags:

  • community: Tokens approved by the Jupiter community.

  • strict: Previously validated tokens from deprecated strict-list repositories.

  • lst: Tokens from Sanctum’s list.

  • birdeye-trending: Top 100 trending tokens from BirdEye.

  • clone: Tokens listed by Clone protocol.

  • pump: Tokens that graduated from the Pump protocol.

GET Token by Mint - https://tokens.jup.ag/token/{mint_address}

• Retrieves metadata for a specific token by its mint address.

• mint_address (string): The token’s unique mint address.

GET Tradable Tokens - https://tokens.jup.ag/tokens_with_markets

• Fetches a list of tokens tradable on Jupiter, meeting liquidity and routing thresholds.

To provide context, in this guide we will be focusing mainly on the implementation of Typescript Hooks with Jupiter's V6 Swap API while utilizing Zustand for persistent state management.

NOTE: If you would like an even quicker and easier implementation with the user interface done up, you can go through the following resources:

1. Jupiter Terminal - an open-source plug-and-play terminal that can be embedded in your dApp as an integrated swap OR widget OR modal. (An article will be released in the future covering this)

2. Jupiverse Kit - an open-source passion project kickstarted by myself to equip Solana developers with a ready-to-use React components library powered by Jupiter. (An article will be released in the future covering this)

Now back to building .

In essence, accessing liquidity on Solana has never been easier, thanks to Jupiter’s innovative V6 Swap API. By simply sending a HTTP request to https://quote-api.jup.ag/v6 and specifying the token pairs, amount, and slippage, developers can quickly obtain serialized transactions that are ready for execution. These transactions can then be signed and submitted to the Solana blockchain with minimal effort. However, there are several prerequisites that you will have to prepare first before using the V6 Swap API.

• Install @solana/wallet-adapter-react

• Install @solana/web3.js

export interface Token {
  address: string;
  name: string;
  symbol: string;
  decimals: number;
  logoURI: string;
  tags: string[];
  daily_volume: number;
  freeze_authority: string | null;
  mint_authority: string | null;
}

export interface QuoteResponse {
  inputMint: string;
  outputMint: string;
  amount: string;
  swapMode: "ExactIn" | "ExactOut";
  slippageBps: number;
  otherAmountThreshold: string;
  routes: any[];
  contextSlot: number;
}

export interface SwapResponse {
  swapTransaction: string;
}

export interface SwapState {
  tokenFrom: Token | null;
  tokenTo: Token | null;
  amountFrom: string;
  amountTo: string;
  slippage: number;
  quoteResponse: QuoteResponse | null;
  isCalculating: boolean;
  isSwapping: boolean;
  isFromDialogOpen: boolean;
  isToDialogOpen: boolean;
  error: string | null;
}

export interface SwapActions {
  setTokenFrom: (token: Token | null) => void;
  setTokenTo: (token: Token | null) => void;
  setAmountFrom: (amount: string) => void;
  setAmountTo: (amount: string) => void;
  setSlippage: (slippage: number) => void;
  setQuoteResponse: (quote: QuoteResponse | null) => void;
  setIsCalculating: (isCalculating: boolean) => void;
  setIsSwapping: (isSwapping: boolean) => void;
  setIsFromDialogOpen: (isOpen: boolean) => void;
  setIsToDialogOpen: (isOpen: boolean) => void;
  setError: (error: string | null) => void;
  reset: () => void;
  swapTokens: () => void;
  resetAmounts: () => void;
}

The useTokens.ts hook fetches verified tokens via Jupiter's Tokens API

import { useEffect, useState } from "react";
import { Token } from "../utils/interfaces";

export const useTokens = () => {
  const [tokens, setTokens] = useState<Token[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    const fetchTokens = async () => {
      try {
        setLoading(true);
        const response = await fetch(
          "https://tokens.jup.ag/tokens?tags=verified"
        );
        if (!response.ok) {
          throw new Error("Failed to fetch tokens");
        }
        const data = await response.json();
        setTokens(data);
      } catch (err) {
        setError(err instanceof Error ? err.message : "Failed to fetch tokens");
      } finally {
        setLoading(false);
      }
    };

    fetchTokens();
  }, []);

  return { tokens, loading, error };
};

This useSwap.ts Hook will be the main file that interacts with Jupiter's Swap APIs, providing the following key functionalities:

• Quote Retrieval - the getQuote function is responsible for fetching a quote for swapping a specified amount of one token for another, while taking into consideration the slippage and platform fees.

  • Ensure that restrictIntermediateTokens is set to true. Without it, your route may be routed through random intermediate tokens, leading to higher chances of failure. Enabling this option ensures your route only uses highly liquid intermediate tokens, providing you with the best price and a more stable transaction path.

• Swap Execution - the executeSwap function is in charge of preparing and executing a swap transaction.

  • You can access the Jupiter Referral Dashboard to create your referral account and obtain your referral key. By using this key, you can earn fees on every swap transaction conducted through your platform.

• Output Calculation - the calculateOutputAmount function estimates the output amount of tokens received from a swap based on the input amount and current market conditions.

• Max Input Calculation - the calculateMaxInput function determines the maximum amount of a token that can be swapped, while taking into account the necessary gas fees if the token is SOL.

import { useCallback, useMemo, useState } from "react";
import { useWallet } from "@solana/wallet-adapter-react";
import {
  Connection,
  LAMPORTS_PER_SOL,
  PublicKey,
  VersionedTransaction,
} from "@solana/web3.js";
import { Token, QuoteResponse, SwapResponse } from "../utils/interfaces";

// Minimum SOL to keep for gas fees (0.01 SOL)
const MIN_SOL_FOR_GAS = 0.01 * LAMPORTS_PER_SOL;
const WSOL_MINT = "So11111111111111111111111111111111111111112";

interface UseSwapProps {
  rpcUrl: string;
  referralKey?: string;
  platformFeeBps?: number;
}

export const useSwap = ({
  rpcUrl,
  referralKey,
  platformFeeBps,
}: UseSwapProps) => {
  const { publicKey, signTransaction } = useWallet();
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  // Initialize connection with provided RPC URL
  const connection = useMemo(() => new Connection(rpcUrl), [rpcUrl]);

  // Get quote for swap
  const getQuote = useCallback(
    async (
      inputToken: Token,
      outputToken: Token,
      amount: number,
      slippageBps: number = 300
    ) => {
      try {
        setLoading(true);
        setError(null);

        const url = new URL("https://quote-api.jup.ag/v6/quote");
        url.searchParams.append("inputMint", inputToken.address);
        url.searchParams.append("outputMint", outputToken.address);
        url.searchParams.append(
          "amount",
          (amount * Math.pow(10, inputToken.decimals)).toString()
        );
        url.searchParams.append("slippageBps", slippageBps.toString());
        url.searchParams.append("restrictIntermediateTokens", "true");

        // Add platform fee if provided
        if (platformFeeBps) {
          url.searchParams.append("platformFeeBps", platformFeeBps.toString());
        }

        const response = await fetch(url.toString());
        const data = await response.json();

        if (!response.ok) {
          throw new Error(data.error || "Failed to get quote");
        }

        return data as QuoteResponse;
      } catch (err) {
        const errorMessage =
          err instanceof Error ? err.message : "Failed to get quote";
        setError(errorMessage);
        throw new Error(errorMessage);
      } finally {
        setLoading(false);
      }
    },
    [platformFeeBps]
  );

  // Execute swap
  const executeSwap = useCallback(
    async (quoteResponse: QuoteResponse) => {
      if (!publicKey || !signTransaction) {
        setError("Wallet not connected");
        return null;
      }

      try {
        setLoading(true);
        setError(null);

        let feeAccount;
        if (referralKey) {
          // Calculate fee account address
          const [feeAccountAddress] = await PublicKey.findProgramAddressSync(
            [
              Buffer.from("referral_ata"),
              new PublicKey(referralKey).toBuffer(),
              new PublicKey(quoteResponse.inputMint).toBuffer(),
            ],
            new PublicKey("REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3")
          );
          feeAccount = feeAccountAddress.toString();
        }

        const swapResponse = await fetch("https://quote-api.jup.ag/v6/swap", {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            quoteResponse,
            userPublicKey: publicKey.toString(),
            wrapAndUnwrapSol: true,
            dynamicComputeUnitLimit: true,
            feeAccount,
            dynamicSlippage: {
              maxBps: quoteResponse.slippageBps,
            },
            prioritizationFeeLamports: {
              priorityLevelWithMaxLamports: {
                maxLamports: 10000000,
                priorityLevel: "veryHigh",
              },
            },
          }),
        });

        if (!swapResponse.ok) {
          throw new Error("Failed to prepare swap transaction");
        }

        const { swapTransaction } = (await swapResponse.json()) as SwapResponse;

        // Deserialize the transaction
        const swapTransactionBuf = Buffer.from(swapTransaction, "base64");
        const transaction = VersionedTransaction.deserialize(
          new Uint8Array(swapTransactionBuf.toJSON().data)
        );

        // Sign the transaction
        const signedTransaction = await signTransaction(transaction);

        // Execute the transaction
        const rawTransaction = signedTransaction.serialize();
        const txid = await connection.sendRawTransaction(rawTransaction, {
          skipPreflight: true,
          maxRetries: 2,
        });

        // Get the latest blockhash
        const latestBlockhash = await connection.getLatestBlockhash();

        // Confirm transaction
        await connection.confirmTransaction({
          blockhash: latestBlockhash.blockhash,
          lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
          signature: txid,
        });

        return txid;
      } catch (err) {
        const errorMessage =
          err instanceof Error ? err.message : "Failed to execute swap";
        setError(errorMessage);
        throw new Error(errorMessage);
      } finally {
        setLoading(false);
      }
    },
    [connection, publicKey, signTransaction, referralKey]
  );

  // Calculate output amount based on input
  const calculateOutputAmount = useCallback(
    async (inputToken: Token, outputToken: Token, inputAmount: number) => {
      if (!inputAmount || inputAmount <= 0) return "0";

      try {
        const quote = await getQuote(inputToken, outputToken, inputAmount);
        if (!quote) return "0";

        // Convert amount from base units to decimal
        const outputAmount = (
          parseInt(quote.otherAmountThreshold) /
          Math.pow(10, outputToken.decimals)
        ).toString();

        return outputAmount;
      } catch (err) {
        const errorMessage =
          err instanceof Error
            ? err.message
            : "Failed to calculate output amount";
        console.error("Failed to calculate output amount:", err);
        setError(errorMessage);
        throw new Error(errorMessage);
      }
    },
    [getQuote]
  );

  // Calculate max input amount accounting for gas fees if token is SOL
  const calculateMaxInput = useCallback(
    async (inputToken: Token, balance: number) => {
      if (!balance || balance <= 0) return 0;

      // If input token is SOL, leave some for gas
      if (inputToken.address === WSOL_MINT) {
        const maxAmount = Math.max(
          0,
          (balance * LAMPORTS_PER_SOL - MIN_SOL_FOR_GAS) / LAMPORTS_PER_SOL
        );
        return parseFloat(maxAmount.toFixed(inputToken.decimals));
      }

      // For other tokens, use full balance
      return balance;
    },
    []
  );

  return {
    getQuote,
    executeSwap,
    calculateOutputAmount,
    calculateMaxInput,
    loading,
    error,
  };
};

The useSwapStore.ts manages the state and actions related to the useSwap.ts hook, ensuring that the token states are saved across sessions, providing world-class user experience. Additionally, the useSwapSelector hook is provided for optimized state selection.

import { create } from "zustand";
import { persist } from "zustand/middleware";
import { SwapState, SwapActions } from "../utils/interfaces";

// Define the initial state of the swap store
const initialState: SwapState = {
  tokenFrom: null,
  tokenTo: null,
  amountFrom: "",
  amountTo: "",
  slippage: 3,
  quoteResponse: null,
  isCalculating: false,
  isSwapping: false,
  isFromDialogOpen: false,
  isToDialogOpen: false,
  error: null,
};

export const useSwapStore = create<SwapState & SwapActions>()(
  persist(
    (set, get) => ({
      ...initialState,

      setTokenFrom: (token) => set({ tokenFrom: token }),
      setTokenTo: (token) => set({ tokenTo: token }),
      setAmountFrom: (amount) => {
        // Always set the input amount
        set({ amountFrom: amount });

        // Reset 'to' amount if 'from' amount is invalid
        if (!amount || isNaN(parseFloat(amount))) {
          set({ amountTo: "0", quoteResponse: null });
        }
      },
      setAmountTo: (amount) => set({ amountTo: amount }),
      setSlippage: (slippage) => set({ slippage }),
      setQuoteResponse: (quote) => set({ quoteResponse: quote }),
      setIsCalculating: (isCalculating) => set({ isCalculating }),
      setIsSwapping: (isSwapping) => set({ isSwapping }),
      setIsFromDialogOpen: (isOpen) => set({ isFromDialogOpen: isOpen }),
      setIsToDialogOpen: (isOpen) => set({ isToDialogOpen: isOpen }),
      setError: (error) => {
        set({ error });
        // Reset 'to' amount when there's an error to trigger recalculation
        if (error) {
          set({ amountTo: "", quoteResponse: null });
        }
      },

      reset: () => {
        const { tokenFrom, tokenTo } = get();
        set({
          ...initialState,
          // Preserve selected tokens
          tokenFrom,
          tokenTo,
        });
      },

      resetAmounts: () =>
        set({
          amountFrom: "",
          amountTo: "",
          quoteResponse: null,
          error: null,
        }),

      swapTokens: () => {
        const { tokenFrom, tokenTo, amountFrom, amountTo } = get();
        set({
          tokenFrom: tokenTo,
          tokenTo: tokenFrom,
          amountFrom: amountTo,
          amountTo: amountFrom,
        });
      },
    }),
    {
      name: "swap-storage",
      // Only persist tokens, amounts, and slippage
      partialize: (state) => ({
        tokenFrom: state.tokenFrom,
        tokenTo: state.tokenTo,
        amountFrom: state.amountFrom,
        amountTo: state.amountTo,
        slippage: state.slippage,
      }),
    }
  )
);

// Selector hook for better performance
export const useSwapSelector = <T>(selector: (state: SwapState) => T) =>
  useSwapStore(selector);

The useSwapOperations.ts is designed to manage the state and logic required for calculating token swap quote, executing swaps, and handling user interactions related to token swaps. Key functionalities includes:

• Quote Calculation - uses the getQuote function from useSwap.ts

• Swap Execution - uses the executeSwap function from useSwap.ts

• Auto-Refresh and Debounce - auto refresh and calculate debounces via useEffect hooks

• Error Handling - provides user feedback through toast notifications for various error scenarios

P.S. If your dApp already includes toast notifications, you can replace the ones in this file with the toast notifications used in your dApp.

import React, { useCallback, useEffect, useRef } from "react";
import { useSwapStore, useSwapSelector } from "../store/useSwapStore";
import { useSwap } from "./useSwap";
import { useTokenBalance } from "./useTokenBalance";
import { SquareArrowOutUpRightIcon } from "lucide-react";
import { toast } from "sonner";

interface SwapOperationsConfig {
  rpcUrl: string;
  referralKey?: string;
  platformFeeBps?: number;
}

export const useSwapOperations = (config: SwapOperationsConfig) => {
  // State selectors
  const tokenFrom = useSwapSelector((state) => state.tokenFrom);
  const tokenTo = useSwapSelector((state) => state.tokenTo);
  const amountFrom = useSwapSelector((state) => state.amountFrom);
  const amountTo = useSwapSelector((state) => state.amountTo);
  const slippage = useSwapSelector((state) => state.slippage);
  const isCalculating = useSwapSelector((state) => state.isCalculating);
  const isSwapping = useSwapSelector((state) => state.isSwapping);

  // Actions
  const {
    setAmountFrom,
    setAmountTo,
    setQuoteResponse,
    setIsCalculating,
    setIsSwapping,
    setError,
  } = useSwapStore();

  const { getQuote, executeSwap, calculateMaxInput } = useSwap(config);
  const { balance: fromBalance, refetch: refetchFromBalance } =
    useTokenBalance(tokenFrom);
  const { balance: toBalance, refetch: refetchToBalance } =
    useTokenBalance(tokenTo);

  const refreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);

  // Memoized quote calculation with debounce
  const calculateQuote = useCallback(
    async (amount: string) => {
      // Skip quote calculation if tokens aren't selected
      if (!tokenFrom || !tokenTo) {
        setAmountTo("0");
        setQuoteResponse(null);
        setIsCalculating(false);
        return;
      }

      // Handle empty input silently
      if (!amount) {
        setAmountTo("0");
        setQuoteResponse(null);
        setIsCalculating(false);
        return;
      }

      // Show error for invalid number after debounce
      if (isNaN(parseFloat(amount))) {
        setAmountTo("0");
        setQuoteResponse(null);
        setIsCalculating(false);
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">
              Invalid Input: Please enter a valid number
            </span>
            <span>The amount must be a valid numerical value</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
        return;
      }

      const parsedAmount = parseFloat(amount);
      // Show error for zero or negative amount after debounce
      if (parsedAmount <= 0) {
        setAmountTo("0");
        setQuoteResponse(null);
        setIsCalculating(false);
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">Invalid Amount</span>
            <span>Amount must be greater than 0</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
        return;
      }

      // Check balance only after we have a valid amount
      if (fromBalance !== null && parsedAmount > fromBalance) {
        setAmountTo("0");
        setQuoteResponse(null);
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">Insufficient Balance</span>
            <span>You don't have enough {tokenFrom.symbol} in your wallet</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
        return;
      }

      setIsCalculating(true);
      try {
        const quote = await getQuote(
          tokenFrom,
          tokenTo,
          parsedAmount,
          slippage * 100
        );

        if (quote) {
          setQuoteResponse(quote);
          const outputAmount = (
            parseInt(quote.otherAmountThreshold) /
            Math.pow(10, tokenTo.decimals)
          ).toString();
          setAmountTo(outputAmount);
        }
      } catch (err) {
        const errorMessage =
          err instanceof Error
            ? err.message
            : "Failed to calculate output amount";
        console.error("Failed to calculate output amount:", err);
        setAmountTo("0");
        setQuoteResponse(null);
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">Quote Calculation Failed</span>
            <span className="break-words text-wrap">{errorMessage}</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
      } finally {
        setIsCalculating(false);
      }
    },
    [
      tokenFrom,
      tokenTo,
      slippage,
      fromBalance,
      getQuote,
      setAmountTo,
      setQuoteResponse,
      setIsCalculating,
    ]
  );

  // Add this new function to handle manual refresh
  const handleRefreshQuote = useCallback(() => {
    if (!amountFrom || !tokenFrom || !tokenTo) return;

    // Clear existing timer if any
    if (refreshTimerRef.current) {
      clearTimeout(refreshTimerRef.current);
    }

    // Trigger immediate quote calculation
    calculateQuote(amountFrom);

    // Start new refresh timer
    refreshTimerRef.current = setTimeout(() => {
      handleRefreshQuote();
    }, 15000);
  }, [amountFrom, tokenFrom, tokenTo, calculateQuote]);

  // Add auto-refresh effect
  useEffect(() => {
    if (amountFrom && tokenFrom && tokenTo && !isCalculating && !isSwapping) {
      refreshTimerRef.current = setTimeout(() => {
        handleRefreshQuote();
      }, 15000);
    }

    return () => {
      if (refreshTimerRef.current) {
        clearTimeout(refreshTimerRef.current);
      }
    };
  }, [
    amountFrom,
    tokenFrom,
    tokenTo,
    isCalculating,
    isSwapping,
    handleRefreshQuote,
  ]);

  // Debounced quote calculation
  const debouncedCalculateQuote = useCallback(
    (amount: string) => {
      const debounced = setTimeout(() => calculateQuote(amount), 500);
      return () => clearTimeout(debounced);
    },
    [calculateQuote]
  );

  // Effect to handle input validation and trigger quote calculation
  useEffect(() => {
    const validateAndCalculate = () => {
      // Reset 'to' amount for empty/invalid input without showing error
      if (!amountFrom || isNaN(parseFloat(amountFrom))) {
        setAmountTo("0");
        setQuoteResponse(null);
        return;
      }

      const parsedAmount = parseFloat(amountFrom);
      // Skip calculation for zero or negative amounts without showing error
      if (parsedAmount <= 0) {
        setAmountTo("0");
        setQuoteResponse(null);
        return;
      }

      // Proceed with quote calculation if input is valid and positive
      debouncedCalculateQuote(amountFrom);
    };

    validateAndCalculate();
  }, [amountFrom, debouncedCalculateQuote, setAmountTo, setQuoteResponse]);

  // Calculate maximum input amount
  const calculateMaximumInput = useCallback(async () => {
    if (!tokenFrom || !fromBalance || fromBalance <= 0) return;

    const maxAmount = await calculateMaxInput(tokenFrom, fromBalance);
    return maxAmount.toFixed(tokenFrom.decimals);
  }, [tokenFrom, fromBalance, calculateMaxInput]);

  // Handle swap execution
  const handleSwap = useCallback(async () => {
    if (!tokenFrom || !tokenTo || !amountFrom || !amountTo) {
      toast.error(
        <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
          <span className="font-semibold">Invalid Swap</span>
          <span>
            Please ensure you have selected tokens and entered valid amounts
          </span>
        </div>,
        {
          style: {
            padding: 0,
            margin: 0,
          },
        }
      );
      return;
    }

    setIsSwapping(true);
    const loadingToast = toast.loading(
      <div className="flex flex-col p-4">
        <span className="font-semibold">Processing Transaction</span>
        <span className="text-xs text-black/50">
          Please wait while your transaction is being processed
        </span>
      </div>,
      {
        style: {
          padding: 0,
          margin: 0,
        },
      }
    );

    try {
      const quote = await getQuote(
        tokenFrom,
        tokenTo,
        parseFloat(amountFrom),
        slippage * 100
      );

      if (!quote) {
        throw new Error("Failed to get quote");
      }

      const txid = await executeSwap(quote);
      if (!txid) {
        throw new Error("Failed to execute swap");
      }

      // Reset amounts and states only on successful swap
      setAmountFrom("");
      setAmountTo("0");
      setQuoteResponse(null);
      setError(null);

      toast.dismiss(loadingToast);
      toast.success(
        <div className="flex flex-col bg-green-100 w-full p-4  rounded-lg">
          <span className="font-semibold">Swap Successful!</span>
          <span className="text-xs text-black/50">
            <span className="break-words">Transaction ID:</span>
            <a
              href={`https://solana.fm/tx/${txid}`}
              target="_blank"
              rel="noopener noreferrer"
              className="text-blue-500 hover:underline break-words"
            >
              {txid}{" "}
              <SquareArrowOutUpRightIcon className="h-3 w-3 inline align-text-bottom" />
            </a>
          </span>
        </div>,
        {
          style: {
            padding: 0,
            margin: 0,
          },
        }
      );

      await Promise.all([refetchFromBalance(), refetchToBalance()]);
    } catch (err) {
      const errorMessage =
        err instanceof Error ? err.message : "Failed to execute swap";

      toast.dismiss(loadingToast);

      // Check if user rejected/cancelled the transaction
      if (
        errorMessage.toLowerCase().includes("user rejected") ||
        errorMessage.toLowerCase().includes("cancelled")
      ) {
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">Transaction Cancelled</span>
            <span>You cancelled the transaction</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
      } else {
        toast.error(
          <div className="flex flex-col bg-red-100 w-full p-4 rounded-lg">
            <span className="font-semibold">Transaction Failed</span>
            <span className="break-words text-wrap">{errorMessage}</span>
          </div>,
          {
            style: {
              padding: 0,
              margin: 0,
            },
          }
        );
      }

      console.error("Swap failed:", err);
      setError(errorMessage);

      // Refetch quote to ensure prices are up to date
      if (amountFrom && !isNaN(parseFloat(amountFrom))) {
        calculateQuote(amountFrom);
      }
    } finally {
      setIsSwapping(false);
    }
  }, [
    tokenFrom,
    tokenTo,
    amountFrom,
    amountTo,
    slippage,
    getQuote,
    executeSwap,
    setAmountFrom,
    setAmountTo,
    setQuoteResponse,
    setIsCalculating,
    setIsSwapping,
    setError,
    refetchFromBalance,
    refetchToBalance,
  ]);

  return {
    calculateMaximumInput,
    handleSwap,
    handleRefreshQuote,
    fromBalance,
    toBalance,
  };
};

With the logic already set up, we can now proceed to implement the <Swap /> component in the dApp’s UI. Essentially, since useSwap.ts is called from useSwapOperations.ts, your <Swap /> component will only need to import the following modules:

import { useTokens } from "../hooks/useTokens";
import { useSwapOperations } from "../hooks/useSwapOperations";
import { useSwapStore } from "../store/useSwapStore";

Thereafter, we can initialize the hooks like this:

const { tokens } = useTokens();
const {
    tokenFrom,
    tokenTo,
    amountFrom,
    amountTo,
    slippage,
    isFromDialogOpen,
    isToDialogOpen,
    isCalculating,
    isSwapping,
    setTokenFrom,
    setTokenTo,
    setAmountFrom,
    setSlippage,
    setIsFromDialogOpen,
    setIsToDialogOpen,
    swapTokens,
  } = useSwapStore();
const {
    calculateMaximumInput,
    handleSwap,
    handleRefreshQuote,
    fromBalance,
    toBalance,
  } = useSwapOperations({ rpcUrl, referralKey, platformFeeBps });

After initializing the hooks, you can now use these variables and methods to implement the core functionality and UI interactions of the <Swap /> component that you desire.

Here’s a TL;DR example of how I integrated the variables and methods into my <Swap /> component. Note that I modularized my codebase by creating custom components and helper functions to streamline the swap interface. The implementation utilizes NextJS (TypeScript) and TailwindCSS for a clean and efficient build.

import React, { useEffect } from "react";
import { ReactComponent as JupiterBrightLogo } from "../../assets/powered-by-jupiter/poweredbyjupiter-bright.svg";
import { ReactComponent as JupiterDarkLogo } from "../../assets/powered-by-jupiter/poweredbyjupiter-dark.svg";
import { ArrowDown, Loader2, WalletIcon } from "lucide-react";
import { useWallet } from "@solana/wallet-adapter-react";
import { UnifiedWalletButton } from "@jup-ag/wallet-adapter";
import SwapReset from "./SwapReset";
import SwapSettings from "./SwapSettings";
import SwapTokenButton from "./SwapTokenButton";
import SwapTokenDialog from "./SwapTokenDialog";
import { useTokens } from "../hooks/useTokens";
import { useSwapOperations } from "../hooks/useSwapOperations";
import { useSwapStore } from "../store/useSwapStore";
import { formatBalance } from "../helpers/formatBalance";

interface SwapProps {
  rpcUrl: string;
  referralKey?: string;
  platformFeeBps?: number;
}

const Swap = ({ rpcUrl, referralKey, platformFeeBps = 0 }: SwapProps) => {
  const { tokens } = useTokens();
  const { connected } = useWallet();
  const {
    tokenFrom,
    tokenTo,
    amountFrom,
    amountTo,
    slippage,
    isFromDialogOpen,
    isToDialogOpen,
    isCalculating,
    isSwapping,
    setTokenFrom,
    setTokenTo,
    setAmountFrom,
    setSlippage,
    setIsFromDialogOpen,
    setIsToDialogOpen,
    swapTokens,
  } = useSwapStore();

  const {
    calculateMaximumInput,
    handleSwap,
    handleRefreshQuote,
    fromBalance,
    toBalance,
  } = useSwapOperations({ rpcUrl, referralKey, platformFeeBps });

  // Initialize default tokens only if no tokens are selected or persisted
  useEffect(() => {
    // Skip if tokens haven't loaded yet
    if (tokens.length === 0) return;

    // Skip if we already have tokens selected
    if (tokenFrom || tokenTo) return;

    // Check if we have persisted tokens in localStorage
    const persistedState = localStorage.getItem("swap-storage");
    if (persistedState) {
      const { state } = JSON.parse(persistedState);
      // Skip if we have persisted tokens
      if (state.tokenFrom || state.tokenTo) return;
    }

    // Set default tokens only if no tokens are selected or persisted
    const solToken = tokens.find((token) => token.symbol === "SOL");
    const usdcToken = tokens.find((token) => token.symbol === "USDC");

    if (solToken && usdcToken) {
      setTokenFrom(solToken);
      setTokenTo(usdcToken);
    }
  }, [tokens, tokenFrom, tokenTo]); // Run when tokens load or selection changes

  const isSwapDisabled =
    !connected ||
    !tokenFrom ||
    !tokenTo ||
    !amountFrom ||
    !amountTo ||
    isCalculating ||
    isSwapping;

  return (
    <>
      <div className="w-full max-w-[480px] p-4 font-sans">
        <div className="rounded-3xl shadow-xl bg-background dark:bg-background-dark">
          <div className="p-6">
            {/* Header */}
            <div className="flex justify-between items-center mb-6">
              <h2 className="text-xl font-bold text-foreground dark:text-foreground-dark">
                Swap
              </h2>
              <div className="flex items-center">
                <SwapSettings
                  slippage={slippage}
                  onSlippageChange={setSlippage}
                  onSave={() => {}}
                />
                <SwapReset
                  onRefresh={handleRefreshQuote}
                  isCalculating={isCalculating}
                  isSwapping={isSwapping}
                />
              </div>
            </div>

            {/* From Token Input */}
            <div className="themed-card rounded-2xl p-4 mb-2">
              <div className="flex justify-between mb-3">
                <input
                  type="number"
                  placeholder="0"
                  value={amountFrom}
                  onChange={(e) => setAmountFrom(e.target.value)}
                  className="w-full bg-transparent text-xl font-medium p-0 h-auto focus-visible:outline-none focus-visible:ring-0 [appearance:textfield] [&::-webkit-outer-spin-button]:appearance-none [&::-webkit-inner-spin-button]:appearance-none"
                  disabled={isSwapping}
                />
                <SwapTokenButton
                  token={tokenFrom}
                  onClick={() => setIsFromDialogOpen(true)}
                />
              </div>
              <div className="flex justify-between items-center">
                <div className="text-sm text-muted-foreground dark:text-muted-dark-foreground">
                  {tokenFrom &&
                    `Balance: ${formatBalance(fromBalance)} ${
                      tokenFrom.symbol
                    }`}
                </div>
                <div className="flex gap-1.5">
                  <button
                    className="h-7 px-2.5 text-xs font-medium rounded-lg transition-colors hover:bg-accent hover:text-accent-foreground"
                    onClick={async () => {
                      if (fromBalance && tokenFrom) {
                        const amount = (fromBalance * 0.25).toFixed(
                          tokenFrom.decimals
                        );
                        setAmountFrom(amount);
                      }
                    }}
                    disabled={!fromBalance || fromBalance <= 0}
                  >
                    25%
                  </button>
                  <button
                    className="h-7 px-2.5 text-xs font-medium rounded-lg transition-colors hover:bg-accent hover:text-accent-foreground"
                    onClick={async () => {
                      if (fromBalance && tokenFrom) {
                        const amount = (fromBalance * 0.5).toFixed(
                          tokenFrom.decimals
                        );
                        setAmountFrom(amount);
                      }
                    }}
                    disabled={!fromBalance || fromBalance <= 0}
                  >
                    50%
                  </button>
                  <button
                    className="h-7 px-2.5 text-xs font-medium rounded-lg transition-colors hover:bg-accent hover:text-accent-foreground"
                    onClick={async () => {
                      const maxAmount = await calculateMaximumInput();
                      if (maxAmount) setAmountFrom(maxAmount);
                    }}
                    disabled={!fromBalance || fromBalance <= 0}
                  >
                    MAX
                  </button>
                </div>
              </div>
            </div>

            {/* Swap Button */}
            <div className="flex justify-center -my-3 relative z-10 mt-3 mb-3">
              <button
                className="h-9 w-9 cursor-pointer rounded-xl bg-card dark:bg-card-dark hover:bg-accent dark:hover:bg-accent transition-colors flex items-center justify-center shadow-md disabled:opacity-50"
                onClick={swapTokens}
                disabled={isSwapping}
                aria-label="Swap token positions"
              >
                <ArrowDown className="h-4 w-4 text-foreground dark:text-foreground-dark" />
              </button>
            </div>

            {/* To Token Input */}
            <div className="themed-card rounded-2xl p-4 mt-2 bg-muted/20 dark:bg-muted-dark/20">
              <div className="flex justify-between mb-3">
                <input
                  type="number"
                  placeholder="0"
                  value={amountTo}
                  readOnly
                  className="w-full bg-transparent text-xl font-medium p-0 h-auto focus-visible:outline-none focus-visible:ring-0 [appearance:textfield] [&::-webkit-outer-spin-button]:appearance-none [&::-webkit-inner-spin-button]:appearance-none"
                />
                <SwapTokenButton
                  token={tokenTo}
                  onClick={() => setIsToDialogOpen(true)}
                />
              </div>
              <div className="text-sm text-muted-foreground dark:text-muted-dark-foreground">
                {tokenTo &&
                  `Balance: ${formatBalance(toBalance)} ${tokenTo.symbol}`}
              </div>
            </div>

            {/* Swap Button or Connect Wallet Button */}
            {connected ? (
              <button
                className="w-full h-10 mt-6 py-4 text-base font-semibold rounded-2xl themed-button-primary disabled:opacity-50 disabled:cursor-not-allowed flex items-center justify-center"
                onClick={handleSwap}
                disabled={isSwapDisabled}
              >
                {isCalculating ? (
                  <>
                    <Loader2 className="mr-2 h-5 w-5 animate-spin" />
                    Loading...
                  </>
                ) : isSwapping ? (
                  <>
                    <Loader2 className="mr-2 h-5 w-5 animate-spin" />
                    Swapping...
                  </>
                ) : (
                  "Swap"
                )}
              </button>
            ) : (
              <UnifiedWalletButton
                buttonClassName="font-sans font-semibold rounded-3xl mt-6 themed-button-primary w-full px-4 py-3 text-sm flex justify-center items-center text-center gap-2 hover:opacity-90 dark:hover:opacity-90 transition-colors text-white dark:text-white cursor-pointer"
                overrideContent={
                  <>
                    <WalletIcon className="h-4 w-4 opacity-70" />
                    Connect Wallet
                  </>
                }
              />
            )}

            {/* Powered by Jupiter logo */}
            <div className="flex justify-center mt-6">
              <a
                href="https://jup.ag"
                target="_blank"
                rel="noopener noreferrer"
              >
                <JupiterBrightLogo
                  width={150}
                  height={25}
                  className="block dark:hidden opacity-75 hover:opacity-100 transition-opacity"
                  preserveAspectRatio="xMidYMid meet"
                />
                <JupiterDarkLogo
                  width={150}
                  height={25}
                  className="hidden dark:block opacity-75 hover:opacity-100 transition-opacity"
                  preserveAspectRatio="xMidYMid meet"
                />
              </a>
            </div>
          </div>
        </div>

        {/* Token Selection Dialogs */}
        <SwapTokenDialog
          open={isFromDialogOpen}
          onClose={() => setIsFromDialogOpen(false)}
          onSelect={setTokenFrom}
        />
        <SwapTokenDialog
          open={isToDialogOpen}
          onClose={() => setIsToDialogOpen(false)}
          onSelect={setTokenTo}
        />
      </div>
    </>
  );
};

export default Swap;

That's all it takes to implement the logic for the <Swap /> component in your dApp.

Straightforward, isn't it?

Here is a Github repository that you can refer to in case you are stuck.

Jupiter stands out as a game-changer in simplifying token swaps on the Solana blockchain. Its ability to abstract the complexities of liquidity aggregation and transaction serialization empowers developers to focus on creating seamless, user-friendly dApps. By providing robust APIs, streamlined integration, and support for advanced features like dynamic routing and referral fee mechanisms, Jupiter offers the tools necessary to elevate any Solana dApp to the next level without having to worry about the nitty-gritty of swaps.

As part of my passion for empowering builders, I’ve been working on a project aimed at accelerating development on Solana. Built on the foundation of Jupiter, this initiative aims to help builders bring their dApps to market faster while delivering exceptional user experiences.

Enter Jupiverse Kit—an open-source ready-to-use React components library that consolidates all of Jupiter’s APIs, SDKs, and packages (such as @jup-ag/terminal, @jup-ag/api, @jup-ag/wallet-adapter, and @jup-ag/react-hooks) along with other Solana packages. This unified package simplifies integration and enables developers to hit the ground running with prebuilt components.

P.S. Contributions are always welcome! This project is open to anyone in the Jupiverse who wants to collaborate and make an impact!

I hope this guide helps accelerate your development process and enables you to build more efficiently with Jupiter!

A huge shoutout to Soju for getting me involved with building with Jupiter and inspiring me to share my experience through writing! The big question now is, ‘Wen next article?’

Imagine a world where sending crypto, connecting with communities, and managing your digital assets are as intuitive as using social media. This isn't a distant dream - it's already taking shape, thanks to Basenames in the Base ecosystem.

By turning complex wallet addresses into easy, human-readable names, Basenames are transforming how we interact with the onchain economy. They unlock a future where anyone, from blockchain novices to seasoned pros, can engage seamlessly in a decentralized digital landscape. Whether you’re sending assets, collaborating on projects, or building your digital identity, Basenames are the gateway to a more intuitive, inclusive, and efficient blockchain experience.

In this Builder Guide, I’ll walk you through how to allow users of your dApp to programatically register for a Basename, along with the key considerations and best practices to keep in mind when building. Plus, I’ll also show you how to integrate CDP Paymaster to sponsor gas fees, making the user experience 1000x smoother. Whether you’re a seasoned developer or a newbie, this guide will equip you with the tools to build a more user-friendly onchain ecosystem.

Essentially, Basenames leverages the ENS (Ethereum Name Service) and functions as human-readable subdomains (*.base.eth) where users can register and manage their onchain name.

The diagram below provides a high-level overview of how Basenames work, while the open-source GitHub repository delves into the detailed implementation, consisting of the contracts for resolving, managing, and tokenising subdomains as ERC721 tokens. These names are fully onchain, which means they are compatible across the Base network and other EVM-compatible blockchains, ensuring seamless cross-chain integration. With support for public resolvers, you as a developer can set various records (address, text, DNS) tied to your user's Basename, making it a versatile tool for dApps and decentralised identities.

For context, in this guide we will be on Base Sepolia network, using NextJS (Typescript) as the frontend framework, with Wagmi + Viem as the frontend hooks and low-level interface to interact with anything Ethereum.

Essentially, the main smart contract that you have to interact with to programatically register Basenames via your dApp is Registrar.sol that contains the register() function.

However, it’s not as straightforward as simply passing a string into the register function to register the Basenames. There are numerous nuances to consider in preparing your arguments before properly passing into the function.

• Install the CDP SDK.

• Install Onchainkit.

• Have an 'ETH funded' wallet (minimum of 0.005 ETH) to get started.
  Reason: The _validatePayment() function in the RegistrarController.sol has a require statement that requires the msg.value to be more than the price of the Basename.

      /// @notice Internal helper for validating ETH payments
      ///
      /// @dev Emits `ETHPaymentProcessed` after validating the payment.
      ///
      /// @param price The expected value.
      function _validatePayment(uint256 price) internal {
          if (msg.value < price) {
              revert InsufficientValue();
          }
          emit ETHPaymentProcessed(msg.sender, price);
      }

Create a basename.ts in your lib folder and import the following modules

import {
  encodeFunctionData,
  namehash,
  Address,
  createPublicClient,
  http,
} from "viem";
import { baseSepolia, base } from "viem/chains";
import { Basename } from "@coinbase/onchainkit/identity";

In your basename.ts file, include the following code, which specifies the contract addresses for RegistrarController.sol and L2Resolver.sol, along with the ABIs for each of these contracts.

// Chain ID
export const BASE_SEPOLIA_CHAIN_ID = 84532

// Contract Addresses
export const BASE_SEPOLIA_REGISTRAR_CONTROLLER_ADDRESS =
	"0x49ae3cc2e3aa768b1e5654f5d3c6002144a59581";
export const BASE_SEPOLIA_L2_RESOLVER_ADDRESS =
	"0x6533C94869D28fAA8dF77cc63f9e2b2D6Cf77eBA";

// ABIs
export const BASE_SEPOLIA_L2_RESOLVER_ABI = [
  {
    inputs: [
      { internalType: "bytes32", name: "node", type: "bytes32" },
      { internalType: "uint256", name: "coinType", type: "uint256" },
      { internalType: "bytes", name: "a", type: "bytes" },
    ],
    name: "setAddr",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
  {
    inputs: [
      { internalType: "bytes32", name: "node", type: "bytes32" },
      { internalType: "string", name: "newName", type: "string" },
    ],
    name: "setName",
    outputs: [],
    stateMutability: "nonpayable",
    type: "function",
  },
];

export const BASE_SEPOLIA_REGISTRAR_CONTROLLER_ABI = [
   {
    inputs: [
      {
        components: [
          { internalType: "string", name: "name", type: "string" },
          { internalType: "address", name: "owner", type: "address" },
          { internalType: "uint256", name: "duration", type: "uint256" },
          { internalType: "address", name: "resolver", type: "address" },
          { internalType: "bytes[]", name: "data", type: "bytes[]" },
          { internalType: "bool", name: "reverseRecord", type: "bool" },
        ],
        internalType: "struct RegistrarController.RegisterRequest",
        name: "request",
        type: "tuple",
      },
    ],
    name: "register",
    outputs: [],
    stateMutability: "payable",
    type: "function",
  },
  {
    inputs: [
      { internalType: "string", name: "name", type: "string" },
      { internalType: "uint256", name: "duration", type: "uint256" },
    ],
    name: "registerPrice",
    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
    stateMutability: "view",
    type: "function",
  },
];

Before implementing the function to generate arguments for the register() method, we first need to define a constant USERNAME_DOMAINS to record the domain name associated with the network. For Base Sepolia, this will be basetest.eth, and for Base, it will be base.eth.

Next, we will create a helper function, formatBaseEthDomain(), to properly format the Base domain.

Finally, we'll construct the arguments for the register() method in RegistrarController.sol. These arguments will leverage the setName() and setAddr() methods from L2Resolver.sol.

// username domains
export const USERNAME_DOMAINS: Record<number, string> = {
  [baseSepolia.id]: "basetest.eth",
  [base.id]: "base.eth",
};

// format base eth domain name
export const formatBaseEthDomain = (
  name: string,
  chainId: number
): Basename => {
  return `${name}.${
    USERNAME_DOMAINS[chainId] ?? ".base.eth"
  }`.toLocaleLowerCase() as Basename;
};

// Create register contract method arguments
export function createRegisterContractMethodArgs(
  baseName: string,
  addressId: Address
): RegistrationArgs {
  const addressData = encodeFunctionData({
    abi: L2ResolverAbi,
    functionName: "setAddr",
    args: [namehash(formatBaseEthDomain(baseName, baseSepolia.id)), addressId],
  });

  const nameData = encodeFunctionData({
    abi: L2ResolverAbi,
    functionName: "setName",
    args: [
      namehash(formatBaseEthDomain(baseName, baseSepolia.id)),
      formatBaseEthDomain(baseName, baseSepolia.id),
    ],
  });

  const registerArgs: RegistrationArgs = {
    name: baseName,
    owner: addressId,
    duration: BigInt(31557600),
    resolver: BASE_SEPOLIA_L2_RESOLVER_ADDRESS,
    data: [addressData, nameData],
    reverseRecord: true,
  };

  console.log(`Register contract method arguments constructed: `, registerArgs);

  return registerArgs;
}

As noted earlier, the _validatePayment() function in RegistrarController.sol includes a require statement ensuring that msg.value is greater than the price of the basename. To ensure the user sends enough ETH when calling the register() function, we will create a final helper function in basename.ts called estimateMintValue(). This function will be used to estimate the amount of ETH required to pay when minting a basename.

// Estimate registration price
export async function estimateMintValue(
  baseName: string,
  duration: bigint
): Promise<bigint> {
  const publicClient = createPublicClient({
    chain: baseSepolia,
    transport: http(),
  });

  const price = await publicClient.readContract({
    address: BASE_SEPOLIA_REGISTRAR_CONTROLLER_ADDRESS,
    abi: RegistrarControllerAbi,
    functionName: "registerPrice",
    args: [baseName, duration],
  });

  console.log(`Estimated mint value for ${baseName}: `, price);

  return price;
}

Next, in register-basename.tsx component, we will utilize the Onchainkit Transaction Component to simplify the integration of basename registration on the frontend. You will need your Paymaster Endpoint that you can get from Coinbase Developer Platform.

Here's how you can set up the register-basename.tsx component:

To further customize the <Transaction /> component to suit your preferences, you may refer to the Onchainkit documentation. It provides guidance on tailoring the component to meet your specific requirements.

"use client";

import React, { useMemo, useEffect, useState } from "react";
import { encodeFunctionData } from "viem";
import { useAccount } from "wagmi";
import { Input } from "@/components/ui/input";
import {
  Transaction,
  TransactionButton,
  TransactionError,
  TransactionResponse,
  TransactionStatus,
  TransactionStatusAction,
  TransactionStatusLabel,
} from "@coinbase/onchainkit/transaction";
import {
  createRegisterContractMethodArgs,
  estimateMintValue,
  BASE_SEPOLIA_CHAIN_ID,
  BASE_SEPOLIA_REGISTRAR_CONTROLLER_ADDRESS,
  RegistrarControllerAbi,
} from "../basename";

interface RegistrationArgs {
  name: string;
  owner: `0x${string}`;
  duration: bigint;
  resolver: `0x${string}`;
  data: readonly `0x${string}`[];
  reverseRecord: boolean;
}

const RegistrationForm = () => {
  const [baseName, setBaseName] = useState("");
  const [registrationArgs, setRegistrationArgs] =
    useState<RegistrationArgs | null>(null);
  const [estimatedValue, setEstimatedValue] = useState<number | null>(null);
  const account = useAccount();

  // Handle input change
  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement>) => {
    setBaseName(event.target.value);
  };

  // Fetch registration data whenever baseName or account address changes
  useEffect(() => {
    const fetchRegistrationData = async () => {
      if (baseName && account.address) {
        const args = createRegisterContractMethodArgs(
          baseName,
          account.address
        );
        const value = await estimateMintValue(baseName, args.duration);
        setRegistrationArgs(args);
        setEstimatedValue(Number(value));
      }
    };

    fetchRegistrationData();
  }, [baseName, account.address]);

  // Prepare the transaction call
  const registerBasenameCall = useMemo(() => {
    if (
      !BASE_SEPOLIA_REGISTRAR_CONTROLLER_ADDRESS ||
      !account.address ||
      !registrationArgs ||
      estimatedValue === null
    ) {
      return [];
    }
    return [
      {
        to: BASE_SEPOLIA_REGISTRAR_CONTROLLER_ADDRESS as `0x${string}`,
        data: encodeFunctionData({
          abi: RegistrarControllerAbi,
          functionName: "register",
          args: [
            {
              name: registrationArgs.name,
              owner: registrationArgs.owner,
              duration: registrationArgs.duration,
              resolver: registrationArgs.resolver,
              data: registrationArgs.data,
              reverseRecord: registrationArgs.reverseRecord,
            },
          ],
        }),
        value: BigInt(estimatedValue),
      },
    ];
  }, [registrationArgs, account.address, estimatedValue]);

  // Handle transaction success
  const handleSuccess = async (transactionResponse: TransactionResponse) => {
    console.log("Transaction Response:", transactionResponse);
  };

  // Handle transaction error
  const handleError = (error: TransactionError) => {
    console.error("Transaction Error:", error);
  };

  return (
    <div>
      <Input
        placeholder="Enter base name"
        value={baseName}
        onChange={handleInputChange}
      />
      <Transaction
        chainId={BASE_SEPOLIA_CHAIN_ID}
        calls={registerBasenameCall}
        onError={handleError}
        onSuccess={handleSuccess}
        capabilities={{
          paymasterService: {
            url: process.env
              .NEXT_PUBLIC_CDP_PAYMASTER_AND_BUNDLER_ENDPOINT as string,
          },
        }}
      >
        <TransactionButton text="Register" />
        <TransactionStatus>
          <TransactionStatusLabel />
          <TransactionStatusAction />
        </TransactionStatus>
      </Transaction>
    </div>
  );
};

export default RegistrationForm;

This <RegistrationForm /> component will allow users to register a basename programatically. The form utilizes the Coinbase Transaction component to handle the blockchain interaction, including transaction status and error handling.

Key Functions of <RegistrationForm />

• fetchRegistrationData() - responsible for preparing the contract call arguments and estimating the gas fee required for the transaction. It is triggered whenever baseName or account.address changes. It is put in a useEffect hook and contains the helper functions estimateMintValue() and createRegisterContractMethodArgs().

• registerBasenameCall() - uses useMemo to create the transaction data only when all required information is available.

• handleSuccess() - triggered when the transaction is successfully completed. It logs the transaction response to the console. (You can add additional logic in this function)

• handleError() - triggered if the transaction fails. It logs the error details. (You can add additional logic in this function)

Putting it all together in the <Transaction /> component, this component from Onchainkit handles the process of sending the transaction to the blockchain. It uses the callback functions defined earlier to manage the success and error states.

Building the onchain economy is not just an aspiration; it’s happening now. By simplifying the process of obtaining a decentralized identity via your dApp, Basenames can unlock new opportunities for developers and users alike.

I hope this guide is able to make your developer experience on Base 1000x smoother!

Special thanks to Jesse Pollak, Will Binns, Wilson Cusack, Tina He, and the entire Onchainkit and Coinbase Developer Platform team for their invaluable guidance throughout this project.

There’s never been a better time to start building on Base 😆