diff --git a/.changeset/afraid-worms-pump.md b/.changeset/afraid-worms-pump.md
new file mode 100644
index 000000000..a36021199
--- /dev/null
+++ b/.changeset/afraid-worms-pump.md
@@ -0,0 +1,7 @@
+---
+"@frak-labs/nexus-example": patch
+"@frak-labs/nexus-wallet": patch
+"@frak-labs/nexus-sdk": patch
+---
+
+Add referral workflow
diff --git a/bun.lockb b/bun.lockb
index 049ba56d8..b3e30eb36 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/packages/example/src/module/article/component/Popup/index.module.css b/packages/example/src/module/article/component/Popup/index.module.css
new file mode 100644
index 000000000..632214a27
--- /dev/null
+++ b/packages/example/src/module/article/component/Popup/index.module.css
@@ -0,0 +1,39 @@
+.popup {
+    align-items: center;
+    color: #383f4e;
+    display: flex;
+    justify-content: center;
+    left: 0;
+    overflow: hidden;
+    position: fixed;
+    scroll-behavior: smooth;
+    bottom: 0;
+    width: 100%;
+    z-index: 10000001;
+    font-size: 16px;
+    line-height: 24px;
+}
+
+.popup__content {
+    background-color: #fff;
+    display: flex;
+    flex-direction: column;
+    max-height: calc(100% - 80px);
+    max-width: 978px;
+    overflow: visible;
+    margin: 10px;
+    padding: 10px;
+    position: relative;
+    width: 100%;
+    border-radius: 10px;
+    border: 1px solid #e5e5e5;
+}
+
+.popup__explanation {
+    color: #2a303b;
+    font-size: 18px;
+    line-height: 24px;
+    margin-bottom: 20px;
+    font-weight: 600;
+    text-align: center;
+}
diff --git a/packages/example/src/module/article/component/Popup/index.tsx b/packages/example/src/module/article/component/Popup/index.tsx
new file mode 100644
index 000000000..6874fd32e
--- /dev/null
+++ b/packages/example/src/module/article/component/Popup/index.tsx
@@ -0,0 +1,37 @@
+import css from "!!raw-loader!./index.module.css";
+import { frakWalletSdkConfig } from "@/context/frak-wallet/config";
+import { Button } from "@/module/common/component/Button";
+import type { Article } from "@/type/Article";
+
+export const cssRaw = css;
+
+function buildRedirectUrl(redirectUrl: string) {
+    const outputUrl = new URL(frakWalletSdkConfig.walletUrl);
+    outputUrl.pathname = "/register";
+    outputUrl.searchParams.set("redirectUrl", encodeURIComponent(redirectUrl));
+    return outputUrl.toString();
+}
+
+export function Popup({ article }: { article: Article }) {
+    return (
+        <div className={"popup"}>
+            <div className={"popup__content"}>
+                <p className={"popup__explanation"}>
+                    A Nexus user shared this link with you, create a Nexus
+                    account to instantly get 50rFRK
+                </p>
+                <Button
+                    variant={article.provider}
+                    size={"small"}
+                    onClick={() => {
+                        window.location.href = buildRedirectUrl(
+                            `${window.location.origin}/article?id=${article.id}`
+                        );
+                    }}
+                >
+                    Connect or create a Nexus Wallet
+                </Button>
+            </div>
+        </div>
+    );
+}
diff --git a/packages/example/src/module/article/component/Read/InjectBannerComponent.tsx b/packages/example/src/module/article/component/Read/InjectBannerComponent.tsx
index f120b671a..b1170a40d 100644
--- a/packages/example/src/module/article/component/Read/InjectBannerComponent.tsx
+++ b/packages/example/src/module/article/component/Read/InjectBannerComponent.tsx
@@ -20,7 +20,7 @@ export function InjectBannerComponent({
     const articleIframeDocument = articleIframe?.contentWindow?.document;
 
     useEffect(() => {
-        const containerName = "frak-paywall";
+        const containerName = "frak-banner";
         let containerRoot =
             articleIframeDocument?.getElementById(containerName);
 
diff --git a/packages/example/src/module/article/component/Read/InjectPopupComponent.tsx b/packages/example/src/module/article/component/Read/InjectPopupComponent.tsx
new file mode 100644
index 000000000..31bbaa48a
--- /dev/null
+++ b/packages/example/src/module/article/component/Read/InjectPopupComponent.tsx
@@ -0,0 +1,71 @@
+import { Popup } from "@/module/article/component/Popup";
+import { cssRaw as cssRawButton } from "@/module/common/component/Button";
+import type { Article } from "@/type/Article";
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { cssRaw } from "../Popup";
+
+export function InjectPopupComponent({
+    article,
+}: {
+    article: Article;
+}) {
+    const [containerRoot, setContainerRoot] = useState<Element | undefined>();
+
+    // Get the article's iframe
+    const articleIframeName = "frak-article-iframe";
+    const articleIframe = document.querySelector(
+        `#${articleIframeName}`
+    ) as HTMLIFrameElement;
+    const articleIframeDocument = articleIframe?.contentWindow?.document;
+
+    useEffect(() => {
+        const containerName = "frak-popup";
+        let containerRoot =
+            articleIframeDocument?.getElementById(containerName);
+
+        // If the container does not exist, create it
+        if (!containerRoot) {
+            const appRoot = document.createElement("div");
+            appRoot.id = containerName;
+            articleIframeDocument?.body?.insertAdjacentElement(
+                "beforeend",
+                appRoot
+            );
+            containerRoot =
+                articleIframeDocument?.getElementById(containerName);
+
+            if (containerRoot) {
+                containerRoot.style.width = "100%";
+                setContainerRoot(containerRoot);
+            }
+        }
+    }, [articleIframeDocument]);
+
+    if (
+        !(
+            articleIframe &&
+            articleIframeDocument &&
+            articleIframe.contentDocument
+        )
+    ) {
+        console.log(`iframe ${articleIframeName} not found`);
+        return null;
+    }
+
+    return (
+        containerRoot && (
+            <>
+                {createPortal(<Popup article={article} />, containerRoot)}
+                {/* Inject the styles into the iframe */}
+                {createPortal(
+                    <style>
+                        {cssRaw.toString()}
+                        {cssRawButton.toString()}
+                    </style>,
+                    articleIframe.contentDocument.head
+                )}
+            </>
+        )
+    );
+}
diff --git a/packages/example/src/module/article/component/Read/index.tsx b/packages/example/src/module/article/component/Read/index.tsx
index 0e0052f20..18702e6c1 100644
--- a/packages/example/src/module/article/component/Read/index.tsx
+++ b/packages/example/src/module/article/component/Read/index.tsx
@@ -1,10 +1,12 @@
 import { InjectBannerComponent } from "@/module/article/component/Read/InjectBannerComponent";
+import { InjectPopupComponent } from "@/module/article/component/Read/InjectPopupComponent";
 import { InjectUnlockComponent } from "@/module/article/component/Read/InjectUnlockComponent";
 import { Skeleton } from "@/module/common/component/Skeleton";
 import type { Article } from "@/type/Article";
 import {
     useArticleUnlockOptions,
     useArticleUnlockStatus,
+    useNexusReferral,
     useWalletStatus,
 } from "@frak-labs/nexus-sdk/react";
 import { useEffect, useState } from "react";
@@ -24,6 +26,11 @@ export function ReadArticle({
     // The iframe reference
     const [iframeRef, setIframeRef] = useState<HTMLIFrameElement | null>(null);
 
+    // The nexus referral
+    const { data: referral } = useNexusReferral({
+        contentId: article.contentId as Hex,
+    });
+
     // The unlock options for the article
     const { data: unlockOptions } = useArticleUnlockOptions({
         articleId: article.id as Hex,
@@ -71,6 +78,9 @@ export function ReadArticle({
                 walletStatus?.key === "not-connected" && (
                     <InjectBannerComponent article={article} />
                 )}
+            {injecting > 0 && referral?.key === "referred-history" && (
+                <InjectPopupComponent article={article} />
+            )}
             {articleUnlockStatus &&
             articleUnlockStatus?.key !== "waiting-response" ? (
                 <iframe
diff --git a/packages/sdk/src/core/actions/index.ts b/packages/sdk/src/core/actions/index.ts
index 87ac9ae4a..e9b39c097 100644
--- a/packages/sdk/src/core/actions/index.ts
+++ b/packages/sdk/src/core/actions/index.ts
@@ -7,3 +7,4 @@ export {
     getStartArticleUnlockUrl,
     decodeStartUnlockReturn,
 } from "./startUnlock";
+export { setUserReferred } from "./setUserReferred";
diff --git a/packages/sdk/src/core/actions/setUserReferred.ts b/packages/sdk/src/core/actions/setUserReferred.ts
new file mode 100644
index 000000000..31d5114ca
--- /dev/null
+++ b/packages/sdk/src/core/actions/setUserReferred.ts
@@ -0,0 +1,31 @@
+import type { Address, Hex } from "viem";
+import type { NexusClient, SetUserReferredReturnType } from "../types";
+
+/**
+ * Type used to get the user referred options
+ */
+export type SetUserReferredParams = {
+    contentId: Hex;
+    walletAddress: Address;
+};
+
+/**
+ * Function used to watch a current user referred
+ * @param client
+ * @param contentId
+ * @param walletAddress
+ * @param callback
+ */
+export function setUserReferred(
+    client: NexusClient,
+    { contentId, walletAddress }: SetUserReferredParams,
+    callback: (status: SetUserReferredReturnType) => void
+) {
+    return client.listenerRequest(
+        {
+            method: "frak_listenToSetUserReferred",
+            params: [contentId, walletAddress],
+        },
+        callback
+    );
+}
diff --git a/packages/sdk/src/core/index.ts b/packages/sdk/src/core/index.ts
index bceb6b7ab..dcd284e21 100644
--- a/packages/sdk/src/core/index.ts
+++ b/packages/sdk/src/core/index.ts
@@ -22,6 +22,8 @@ export type {
     RedirectRpcSchema,
     StartArticleUnlockParams,
     StartArticleUnlockReturnType,
+    SetUserReferredParams,
+    SetUserReferredReturnType,
     // Client
     NexusClient,
     // Transport
diff --git a/packages/sdk/src/core/types/index.ts b/packages/sdk/src/core/types/index.ts
index 623f80f22..1f60926fe 100644
--- a/packages/sdk/src/core/types/index.ts
+++ b/packages/sdk/src/core/types/index.ts
@@ -6,6 +6,10 @@ export type {
     StartArticleUnlockParams,
     StartArticleUnlockReturnType,
 } from "./rpc/startUnlock";
+export type {
+    SetUserReferredParams,
+    SetUserReferredReturnType,
+} from "./rpc/setUserReferred";
 export type { IFrameRpcSchema, RedirectRpcSchema } from "./rpc";
 // Client related
 export type { NexusClient } from "./client";
diff --git a/packages/sdk/src/core/types/rpc.ts b/packages/sdk/src/core/types/rpc.ts
index c6b3fdb1f..66e2daff1 100644
--- a/packages/sdk/src/core/types/rpc.ts
+++ b/packages/sdk/src/core/types/rpc.ts
@@ -1,4 +1,5 @@
-import type { Hex } from "viem";
+import type { Address, Hex } from "viem";
+import type { SetUserReferredReturnType } from "./rpc/setUserReferred";
 import type {
     StartArticleUnlockParams,
     StartArticleUnlockReturnType,
@@ -35,6 +36,14 @@ export type IFrameRpcSchema = [
         Parameters: [contentId: Hex, articleId: Hex];
         ReturnType: ArticleUnlockStatusReturnType;
     },
+    /**
+     * Method used to set the referred user
+     */
+    {
+        Method: "frak_listenToSetUserReferred";
+        Parameters: [contentId: Hex, walletAddress: Address];
+        ReturnType: SetUserReferredReturnType;
+    },
 ];
 
 /**
diff --git a/packages/sdk/src/core/types/rpc/setUserReferred.ts b/packages/sdk/src/core/types/rpc/setUserReferred.ts
new file mode 100644
index 000000000..493af3b70
--- /dev/null
+++ b/packages/sdk/src/core/types/rpc/setUserReferred.ts
@@ -0,0 +1,28 @@
+import type { Hex } from "viem";
+
+/**
+ * Parameters of the referred request
+ */
+export type SetUserReferredParams = Readonly<{
+    contentId: Hex;
+}>;
+
+/**
+ * Return type of the referred request
+ */
+export type SetUserReferredReturnType =
+    | UserIsSameWallet
+    | UserReferredSuccessful
+    | UserReferredHistory;
+
+type UserIsSameWallet = {
+    key: "same-wallet";
+};
+
+type UserReferredSuccessful = {
+    key: "referred-successful";
+};
+
+type UserReferredHistory = {
+    key: "referred-history";
+};
diff --git a/packages/sdk/src/core/utils/compression/iframeRpcKeyProvider.ts b/packages/sdk/src/core/utils/compression/iframeRpcKeyProvider.ts
index ef3c20d1f..da0b669dc 100644
--- a/packages/sdk/src/core/utils/compression/iframeRpcKeyProvider.ts
+++ b/packages/sdk/src/core/utils/compression/iframeRpcKeyProvider.ts
@@ -1,12 +1,13 @@
-import type { KeyProvider } from "../../types/compression";
-import type { IFrameRpcSchema } from "../../types/rpc";
-import type { UnlockOptionsReturnType } from "../../types/rpc/unlockOption";
-import type { ArticleUnlockStatusReturnType } from "../../types/rpc/unlockStatus";
-import type { WalletStatusReturnType } from "../../types/rpc/walletStatus";
 import type {
+    ArticleUnlockStatusReturnType,
     ExtractedParametersFromRpc,
     ExtractedReturnTypeFromRpc,
-} from "../../types/transport";
+    IFrameRpcSchema,
+    KeyProvider,
+    SetUserReferredReturnType,
+    UnlockOptionsReturnType,
+    WalletStatusReturnType,
+} from "../../types";
 
 /**
  * Get the right request key provider for the given args
@@ -30,6 +31,11 @@ export const iFrameRequestKeyProvider: KeyProvider<
         return ["article-unlock-status", args.params[0], args.params[1]];
     }
 
+    // Referred user key
+    if (args.method === "frak_listenToSetUserReferred") {
+        return ["user-referred", args.params[0], args.params[1]];
+    }
+
     // Not found
     throw new Error(`No key provider found for the arguments ${args}`);
 };
@@ -87,5 +93,13 @@ export function getIFrameResponseKeyProvider<
         ]) as RpcResponseKeyProvider<TParameters>;
     }
 
+    // Referred user key
+    if (param.method === "frak_listenToSetUserReferred") {
+        return ((response: SetUserReferredReturnType) => [
+            "user-referred",
+            response.key,
+        ]) as RpcResponseKeyProvider<TParameters>;
+    }
+
     throw new Error(`No key provider found for the request ${param}`);
 }
diff --git a/packages/sdk/src/react/hook/index.ts b/packages/sdk/src/react/hook/index.ts
index 528e0469d..7cf3fac2f 100644
--- a/packages/sdk/src/react/hook/index.ts
+++ b/packages/sdk/src/react/hook/index.ts
@@ -5,3 +5,4 @@ export { useWalletStatus } from "./useWalletStatus";
 export type { WalletStatusQueryReturnType } from "./useWalletStatus";
 export { useArticleUnlockStatus } from "./useArticleUnlockStatus";
 export type { ArticleUnlockStatusQueryReturnType } from "./useArticleUnlockStatus";
+export { useNexusReferral } from "./useNexusReferral";
diff --git a/packages/sdk/src/react/hook/useMounted.ts b/packages/sdk/src/react/hook/useMounted.ts
new file mode 100644
index 000000000..e72da5478
--- /dev/null
+++ b/packages/sdk/src/react/hook/useMounted.ts
@@ -0,0 +1,11 @@
+import { useEffect, useState } from "react";
+
+export function useMounted() {
+    const [mounted, setMounted] = useState(false);
+
+    useEffect(() => {
+        setMounted(true);
+    }, []);
+
+    return mounted;
+}
diff --git a/packages/sdk/src/react/hook/useNexusReferral.ts b/packages/sdk/src/react/hook/useNexusReferral.ts
new file mode 100644
index 000000000..ffbbf0c85
--- /dev/null
+++ b/packages/sdk/src/react/hook/useNexusReferral.ts
@@ -0,0 +1,114 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect, useState } from "react";
+import { isAddressEqual } from "viem";
+import type { Address } from "viem";
+import type {
+    SetUserReferredParams,
+    SetUserReferredReturnType,
+} from "../../core";
+import { setUserReferred } from "../../core/actions";
+import { useNexusClient } from "./useNexusClient";
+import { useWalletStatus } from "./useWalletStatus";
+import { useWindowLocation } from "./useWindowLocation";
+
+export type SetUserReferredQueryReturnType =
+    | SetUserReferredReturnType
+    | {
+          key: "waiting-response";
+      }
+    | {
+          key: "no-referrer";
+      };
+
+/**
+ * Use the current nexus referral
+ */
+export function useNexusReferral({ contentId }: SetUserReferredParams) {
+    const { href } = useWindowLocation();
+    const queryClient = useQueryClient();
+    const client = useNexusClient();
+    const { data: walletStatus } = useWalletStatus();
+    const [referrerAddress, setReferrerAddress] = useState<Address>();
+
+    const newStatusUpdated = useCallback(
+        (event: SetUserReferredReturnType) => {
+            queryClient.setQueryData(
+                ["setUserReferredQueryReturnTypeListener"],
+                event
+            );
+
+            // In case the user is referred successfully
+            if (
+                event.key === "referred-successful" ||
+                event.key === "referred-history"
+            ) {
+                if (!href) return;
+                const url = new URL(href);
+
+                // If user is connected, set the context in the url
+                if (walletStatus?.key === "connected") {
+                    url.searchParams.set("nexusContext", walletStatus?.wallet);
+                }
+
+                // If user is not connected, remove the context from the url
+                if (walletStatus?.key === "not-connected") {
+                    url.searchParams.delete("nexusContext");
+                }
+
+                window.history.replaceState(null, "", url.toString());
+            }
+        },
+        [queryClient, href, walletStatus]
+    );
+
+    useEffect(() => {
+        if (!href) return;
+
+        const url = new URL(href);
+        const context = url.searchParams.get("nexusContext");
+
+        // If user is connected, set the context in the url
+        if (!context && walletStatus?.key === "connected") {
+            url.searchParams.set("nexusContext", walletStatus?.wallet);
+            window.history.replaceState(null, "", url.toString());
+        }
+
+        // If context is set, set the referrer address
+        if (context) {
+            setReferrerAddress(context as Address);
+        }
+    }, [href, walletStatus]);
+
+    return useQuery<SetUserReferredQueryReturnType>({
+        gcTime: 0,
+        queryKey: ["setUserReferredQueryReturnTypeListener"],
+        queryFn: async () => {
+            if (!(contentId && referrerAddress)) {
+                return { key: "no-referrer" };
+            }
+
+            if (
+                walletStatus?.key === "connected" &&
+                walletStatus?.wallet &&
+                isAddressEqual(walletStatus?.wallet, referrerAddress)
+            ) {
+                return { key: "same-wallet" };
+            }
+
+            // Setup the listener
+            await setUserReferred(
+                client,
+                { contentId, walletAddress: referrerAddress },
+                newStatusUpdated
+            );
+
+            // Wait for the first response
+            return { key: "waiting-response" };
+        },
+        enabled:
+            !!contentId &&
+            !!referrerAddress &&
+            walletStatus?.key !== undefined &&
+            walletStatus?.key !== "waiting-response",
+    });
+}
diff --git a/packages/sdk/src/react/hook/useWindowLocation.ts b/packages/sdk/src/react/hook/useWindowLocation.ts
new file mode 100644
index 000000000..73f438cba
--- /dev/null
+++ b/packages/sdk/src/react/hook/useWindowLocation.ts
@@ -0,0 +1,36 @@
+import { useEffect, useState } from "react";
+import { useMounted } from "./useMounted";
+
+export const useWindowLocation = (): {
+    location: Location | undefined;
+    href: string | undefined;
+} => {
+    const isMounted = useMounted();
+    const [location, setLocation] = useState<Location | undefined>(
+        isMounted ? window.location : undefined
+    );
+    const [href, setHref] = useState<string | undefined>(
+        isMounted ? window.location.href : undefined
+    );
+
+    useEffect(() => {
+        if (!isMounted) return;
+
+        const setWindowLocation = () => {
+            setLocation(window.location);
+            setHref(window.location.href);
+        };
+
+        if (!location) {
+            setWindowLocation();
+        }
+
+        window.addEventListener("popstate", setWindowLocation);
+
+        return () => {
+            window.removeEventListener("popstate", setWindowLocation);
+        };
+    }, [isMounted, location]);
+
+    return { location, href };
+};
diff --git a/packages/sdk/src/react/index.ts b/packages/sdk/src/react/index.ts
index 9c64da1ab..eeac4d6a4 100644
--- a/packages/sdk/src/react/index.ts
+++ b/packages/sdk/src/react/index.ts
@@ -17,6 +17,7 @@ export {
     useArticleUnlockOptions,
     useWalletStatus,
     useArticleUnlockStatus,
+    useNexusReferral,
 } from "./hook";
 export type {
     WalletStatusQueryReturnType,
diff --git a/packages/wallet/src/context/common/blockchain/addresses.ts b/packages/wallet/src/context/common/blockchain/addresses.ts
index 0890bae3d..ee484096b 100644
--- a/packages/wallet/src/context/common/blockchain/addresses.ts
+++ b/packages/wallet/src/context/common/blockchain/addresses.ts
@@ -6,6 +6,8 @@ export const addresses = {
     paywallToken: "0x9584A61F70cC4BEF5b8B5f588A1d35740f0C7ae2",
     paywall: "0x9218521020EF26924B77188f4ddE0d0f7C405f21",
     communityToken: "0xf98BA1b2fc7C55A01Efa6C8872Bcee85c6eC54e7",
+    referralToken: "0x1Eca7AA9ABF2e53E773B4523B6Dc103002d22e7D",
+    nexusDiscoverCampaign: "0x8a37d1B3a17559F2BC4e6613834b1F13d0A623aC",
 } as const;
 
 /**
diff --git a/packages/wallet/src/context/history/action/fetchHistory.ts b/packages/wallet/src/context/history/action/fetchHistory.ts
index 4150da13a..0079e7f6a 100644
--- a/packages/wallet/src/context/history/action/fetchHistory.ts
+++ b/packages/wallet/src/context/history/action/fetchHistory.ts
@@ -86,7 +86,7 @@ async function _fetchWalletHistory({
     // Get the frk received or sent events for a user
     function getFrkEvents(args: { to?: Address; from?: Address }) {
         return getLogs(viemClient, {
-            address: addresses.paywallToken,
+            address: [addresses.paywallToken, addresses.referralToken],
             event: frkTransferEvent,
             args,
             strict: true,
diff --git a/packages/wallet/src/context/referral/abi/campaign-abis.ts b/packages/wallet/src/context/referral/abi/campaign-abis.ts
new file mode 100644
index 000000000..0d91fbc01
--- /dev/null
+++ b/packages/wallet/src/context/referral/abi/campaign-abis.ts
@@ -0,0 +1,826 @@
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// NexusDiscoverCampaign
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const nexusDiscoverCampaignAbi = [
+    {
+        type: "constructor",
+        inputs: [
+            { name: "_token", internalType: "address", type: "address" },
+            { name: "_owner", internalType: "address", type: "address" },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "cancelOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "pendingOwner", internalType: "address", type: "address" },
+        ],
+        name: "completeOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "_referee", internalType: "address", type: "address" },
+            { name: "_referrer", internalType: "address", type: "address" },
+            { name: "_contentId", internalType: "uint256", type: "uint256" },
+        ],
+        name: "distributeContentDiscoveryReward",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "_referee", internalType: "address", type: "address" },
+            { name: "_referrer", internalType: "address", type: "address" },
+        ],
+        name: "distributeInstallationReward",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "eip712Domain",
+        outputs: [
+            { name: "fields", internalType: "bytes1", type: "bytes1" },
+            { name: "name", internalType: "string", type: "string" },
+            { name: "version", internalType: "string", type: "string" },
+            { name: "chainId", internalType: "uint256", type: "uint256" },
+            {
+                name: "verifyingContract",
+                internalType: "address",
+                type: "address",
+            },
+            { name: "salt", internalType: "bytes32", type: "bytes32" },
+            {
+                name: "extensions",
+                internalType: "uint256[]",
+                type: "uint256[]",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "_selector", internalType: "bytes32", type: "bytes32" },
+            { name: "_referee", internalType: "address", type: "address" },
+        ],
+        name: "getAllReferrers",
+        outputs: [
+            {
+                name: "referrerChains",
+                internalType: "address[]",
+                type: "address[]",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "contentId", internalType: "uint256", type: "uint256" },
+        ],
+        name: "getContentDiscoveryTree",
+        outputs: [{ name: "", internalType: "bytes32", type: "bytes32" }],
+        stateMutability: "pure",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "_user", internalType: "address", type: "address" }],
+        name: "getPendingAmount",
+        outputs: [{ name: "", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "getPushPullConfig",
+        outputs: [
+            {
+                name: "",
+                internalType: "struct PushPullConfig",
+                type: "tuple",
+                components: [
+                    { name: "token", internalType: "address", type: "address" },
+                ],
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "getReferralCampaignConfig",
+        outputs: [
+            {
+                name: "",
+                internalType: "struct CampaignConfig",
+                type: "tuple",
+                components: [
+                    {
+                        name: "maxLevel",
+                        internalType: "uint256",
+                        type: "uint256",
+                    },
+                    {
+                        name: "perLevelPercentage",
+                        internalType: "uint256",
+                        type: "uint256",
+                    },
+                    { name: "token", internalType: "address", type: "address" },
+                ],
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "_selector", internalType: "bytes32", type: "bytes32" },
+            { name: "_referee", internalType: "address", type: "address" },
+        ],
+        name: "getReferrer",
+        outputs: [
+            { name: "referrer", internalType: "address", type: "address" },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "grantRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "hasAllRoles",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "hasAnyRole",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "owner",
+        outputs: [{ name: "result", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "pendingOwner", internalType: "address", type: "address" },
+        ],
+        name: "ownershipHandoverExpiresAt",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "pauseCampaign",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "_user", internalType: "address", type: "address" }],
+        name: "pullReward",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "pullReward",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "roles", internalType: "uint256", type: "uint256" }],
+        name: "renounceRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "requestOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "resumeCampaign",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "revokeRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "user", internalType: "address", type: "address" }],
+        name: "rolesOf",
+        outputs: [{ name: "roles", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "newOwner", internalType: "address", type: "address" },
+        ],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "contentId",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: false,
+            },
+        ],
+        name: "ContentDiscoveryAirdropDistributed",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "pendingOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipHandoverCanceled",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "pendingOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipHandoverRequested",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "oldOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "newOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipTransferred",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "RegistrationAirdropDistributed",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "amount",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: false,
+            },
+        ],
+        name: "RewardAdded",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "amount",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: false,
+            },
+        ],
+        name: "RewardClaimed",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "roles",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: true,
+            },
+        ],
+        name: "RolesUpdated",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "tree",
+                internalType: "bytes32",
+                type: "bytes32",
+                indexed: true,
+            },
+            {
+                name: "referer",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "referee",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "UserReferred",
+    },
+    {
+        type: "error",
+        inputs: [
+            { name: "tree", internalType: "bytes32", type: "bytes32" },
+            {
+                name: "currentReferrer",
+                internalType: "address",
+                type: "address",
+            },
+        ],
+        name: "AlreadyHaveReferer",
+    },
+    {
+        type: "error",
+        inputs: [{ name: "tree", internalType: "bytes32", type: "bytes32" }],
+        name: "AlreadyInRefererChain",
+    },
+    { type: "error", inputs: [], name: "AlreadyInitialized" },
+    { type: "error", inputs: [], name: "InactiveCampaign" },
+    { type: "error", inputs: [], name: "InvalidConfig" },
+    { type: "error", inputs: [], name: "NewOwnerIsZeroAddress" },
+    { type: "error", inputs: [], name: "NoHandoverRequest" },
+    { type: "error", inputs: [], name: "NotEnoughToken" },
+    { type: "error", inputs: [], name: "Reentrancy" },
+    { type: "error", inputs: [], name: "Unauthorized" },
+] as const;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// ReferralToken
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+export const referralTokenAbi = [
+    {
+        type: "constructor",
+        inputs: [{ name: "_owner", internalType: "address", type: "address" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "DOMAIN_SEPARATOR",
+        outputs: [{ name: "result", internalType: "bytes32", type: "bytes32" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "owner", internalType: "address", type: "address" },
+            { name: "spender", internalType: "address", type: "address" },
+        ],
+        name: "allowance",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "spender", internalType: "address", type: "address" },
+            { name: "amount", internalType: "uint256", type: "uint256" },
+        ],
+        name: "approve",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "owner", internalType: "address", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "cancelOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "pendingOwner", internalType: "address", type: "address" },
+        ],
+        name: "completeOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "decimals",
+        outputs: [{ name: "", internalType: "uint8", type: "uint8" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "grantRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "hasAllRoles",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "hasAnyRole",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "_to", internalType: "address", type: "address" },
+            { name: "_amount", internalType: "uint256", type: "uint256" },
+        ],
+        name: "mint",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "name",
+        outputs: [{ name: "", internalType: "string", type: "string" }],
+        stateMutability: "pure",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "owner", internalType: "address", type: "address" }],
+        name: "nonces",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "owner",
+        outputs: [{ name: "result", internalType: "address", type: "address" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "pendingOwner", internalType: "address", type: "address" },
+        ],
+        name: "ownershipHandoverExpiresAt",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "owner", internalType: "address", type: "address" },
+            { name: "spender", internalType: "address", type: "address" },
+            { name: "value", internalType: "uint256", type: "uint256" },
+            { name: "deadline", internalType: "uint256", type: "uint256" },
+            { name: "v", internalType: "uint8", type: "uint8" },
+            { name: "r", internalType: "bytes32", type: "bytes32" },
+            { name: "s", internalType: "bytes32", type: "bytes32" },
+        ],
+        name: "permit",
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "renounceOwnership",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "roles", internalType: "uint256", type: "uint256" }],
+        name: "renounceRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "requestOwnershipHandover",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "user", internalType: "address", type: "address" },
+            { name: "roles", internalType: "uint256", type: "uint256" },
+        ],
+        name: "revokeRoles",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "function",
+        inputs: [{ name: "user", internalType: "address", type: "address" }],
+        name: "rolesOf",
+        outputs: [{ name: "roles", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "symbol",
+        outputs: [{ name: "", internalType: "string", type: "string" }],
+        stateMutability: "pure",
+    },
+    {
+        type: "function",
+        inputs: [],
+        name: "totalSupply",
+        outputs: [{ name: "result", internalType: "uint256", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "to", internalType: "address", type: "address" },
+            { name: "amount", internalType: "uint256", type: "uint256" },
+        ],
+        name: "transfer",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "from", internalType: "address", type: "address" },
+            { name: "to", internalType: "address", type: "address" },
+            { name: "amount", internalType: "uint256", type: "uint256" },
+        ],
+        name: "transferFrom",
+        outputs: [{ name: "", internalType: "bool", type: "bool" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        inputs: [
+            { name: "newOwner", internalType: "address", type: "address" },
+        ],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "payable",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "owner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "spender",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "amount",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: false,
+            },
+        ],
+        name: "Approval",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "pendingOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipHandoverCanceled",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "pendingOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipHandoverRequested",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "oldOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "newOwner",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+        ],
+        name: "OwnershipTransferred",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "user",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "roles",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: true,
+            },
+        ],
+        name: "RolesUpdated",
+    },
+    {
+        type: "event",
+        anonymous: false,
+        inputs: [
+            {
+                name: "from",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "to",
+                internalType: "address",
+                type: "address",
+                indexed: true,
+            },
+            {
+                name: "amount",
+                internalType: "uint256",
+                type: "uint256",
+                indexed: false,
+            },
+        ],
+        name: "Transfer",
+    },
+    { type: "error", inputs: [], name: "AllowanceOverflow" },
+    { type: "error", inputs: [], name: "AllowanceUnderflow" },
+    { type: "error", inputs: [], name: "AlreadyInitialized" },
+    { type: "error", inputs: [], name: "InsufficientAllowance" },
+    { type: "error", inputs: [], name: "InsufficientBalance" },
+    { type: "error", inputs: [], name: "InvalidPermit" },
+    { type: "error", inputs: [], name: "NewOwnerIsZeroAddress" },
+    { type: "error", inputs: [], name: "NoHandoverRequest" },
+    { type: "error", inputs: [], name: "PermitExpired" },
+    { type: "error", inputs: [], name: "TotalSupplyOverflow" },
+    { type: "error", inputs: [], name: "Unauthorized" },
+] as const;
diff --git a/packages/wallet/src/context/referral/action/pendingReferral.ts b/packages/wallet/src/context/referral/action/pendingReferral.ts
new file mode 100644
index 000000000..862121e1a
--- /dev/null
+++ b/packages/wallet/src/context/referral/action/pendingReferral.ts
@@ -0,0 +1,30 @@
+"use server";
+
+import { addresses } from "@/context/common/blockchain/addresses";
+import { frakChainPocClient } from "@/context/common/blockchain/provider";
+import { nexusDiscoverCampaignAbi } from "@/context/referral/abi/campaign-abis";
+import { type Address, formatEther } from "viem";
+import { readContract } from "viem/actions";
+
+/**
+ * Tell that a user has been referred by another user
+ * @param user
+ * @param referrer
+ */
+export async function getPendingWalletReferralReward({
+    user,
+}: { user: Address }) {
+    const pendingAmount = await readContract(frakChainPocClient, {
+        address: addresses.nexusDiscoverCampaign,
+        abi: nexusDiscoverCampaignAbi,
+        functionName: "getPendingAmount",
+        args: [user],
+    });
+    if (!pendingAmount) {
+        return null;
+    }
+    return {
+        rFrkPendingRaw: pendingAmount,
+        rFrkPendingFormatted: formatEther(pendingAmount),
+    };
+}
diff --git a/packages/wallet/src/context/referral/action/userReferred.ts b/packages/wallet/src/context/referral/action/userReferred.ts
new file mode 100644
index 000000000..1c29c5e5e
--- /dev/null
+++ b/packages/wallet/src/context/referral/action/userReferred.ts
@@ -0,0 +1,67 @@
+"use server";
+
+import { addresses } from "@/context/common/blockchain/addresses";
+import { frakChainPocClient } from "@/context/common/blockchain/provider";
+import { nexusDiscoverCampaignAbi } from "@/context/referral/abi/campaign-abis";
+import { isReferralPossible } from "@/context/referral/utils/isReferralPossible";
+import { tryit } from "radash";
+import { type Address, type Hex, encodeFunctionData } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { prepareTransactionRequest, sendTransaction } from "viem/actions";
+import { arbitrumSepolia } from "viem/chains";
+
+/**
+ * Tree for the nexus referral campaign
+ */
+const NEXUS_REFERRAL_TREE: Hex =
+    "0x3775089540b3adee32fd34ba601a5eca0a0ba73151fb33bafb852eee7a47d4ee";
+
+/**
+ * Tell that a user has been referred by another user
+ * @param user
+ * @param referrer
+ */
+export async function setUserReferred({
+    user,
+    referrer,
+}: { user: Address; referrer: Address }) {
+    const isPossible = await isReferralPossible({
+        user,
+        referrer,
+        tree: NEXUS_REFERRAL_TREE,
+    });
+    if (!isPossible) {
+        return undefined;
+    }
+
+    // Get the airdropper private key
+    const airdropperPrivateKey = process.env.AIRDROP_PRIVATE_KEY;
+    if (!airdropperPrivateKey) {
+        throw new Error("Missing AIRDROP_PRIVATE_KEY env variable");
+    }
+
+    // Build our airdrop account
+    const airdropperAccount = privateKeyToAccount(airdropperPrivateKey as Hex);
+
+    // Prepare the transaction
+    const [, preparationResult] = await tryit(() =>
+        prepareTransactionRequest(frakChainPocClient, {
+            account: airdropperAccount,
+            chain: arbitrumSepolia,
+            to: addresses.nexusDiscoverCampaign,
+            data: encodeFunctionData({
+                abi: nexusDiscoverCampaignAbi,
+                functionName: "distributeInstallationReward",
+                args: [user, referrer],
+            }),
+        })
+    )();
+    if (!preparationResult) {
+        return undefined;
+    }
+
+    // Send the tx
+    const txHash = await sendTransaction(frakChainPocClient, preparationResult);
+    console.log("User referred by another user", { user, referrer, txHash });
+    return txHash;
+}
diff --git a/packages/wallet/src/context/referral/action/userReferredOnContent.ts b/packages/wallet/src/context/referral/action/userReferredOnContent.ts
new file mode 100644
index 000000000..5c49ba9fe
--- /dev/null
+++ b/packages/wallet/src/context/referral/action/userReferredOnContent.ts
@@ -0,0 +1,87 @@
+"use server";
+
+import { addresses } from "@/context/common/blockchain/addresses";
+import { frakChainPocClient } from "@/context/common/blockchain/provider";
+import { nexusDiscoverCampaignAbi } from "@/context/referral/abi/campaign-abis";
+import { isReferralPossible } from "@/context/referral/utils/isReferralPossible";
+import { tryit } from "radash";
+import {
+    type Address,
+    type Hex,
+    encodeFunctionData,
+    encodePacked,
+    keccak256,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { prepareTransactionRequest, sendTransaction } from "viem/actions";
+import { arbitrumSepolia } from "viem/chains";
+
+/**
+ * Get the referral tree for the given content
+ * @param contentId
+ */
+function getContentReferralTree(contentId: Hex): Hex {
+    return keccak256(
+        encodePacked(
+            ["string", "uint256"],
+            ["ContentDiscoveryTree", BigInt(contentId)]
+        )
+    );
+}
+
+/**
+ * Tell that a user has been referred by another user on a given content
+ * @param user
+ * @param referrer
+ * @param contentId
+ */
+export async function setUserReferredOnContent({
+    user,
+    referrer,
+    contentId,
+}: { user: Address; referrer: Address; contentId: Hex }) {
+    const isPossible = await isReferralPossible({
+        user,
+        referrer,
+        tree: getContentReferralTree(contentId),
+    });
+    if (!isPossible) {
+        return undefined;
+    }
+
+    // Get the airdropper private key
+    const airdropperPrivateKey = process.env.AIRDROP_PRIVATE_KEY;
+    if (!airdropperPrivateKey) {
+        throw new Error("Missing AIRDROP_PRIVATE_KEY env variable");
+    }
+
+    // Build our airdrop account
+    const airdropperAccount = privateKeyToAccount(airdropperPrivateKey as Hex);
+
+    // Prepare the transaction
+    const [, preparationResult] = await tryit(() =>
+        prepareTransactionRequest(frakChainPocClient, {
+            account: airdropperAccount,
+            chain: arbitrumSepolia,
+            to: addresses.nexusDiscoverCampaign,
+            data: encodeFunctionData({
+                abi: nexusDiscoverCampaignAbi,
+                functionName: "distributeContentDiscoveryReward",
+                args: [user, referrer, BigInt(contentId)],
+            }),
+        })
+    )();
+    if (!preparationResult) {
+        return undefined;
+    }
+
+    // Send the tx
+    const txHash = await sendTransaction(frakChainPocClient, preparationResult);
+    console.log("User referred by another user on the given content", {
+        user,
+        referrer,
+        contentId,
+        txHash,
+    });
+    return txHash;
+}
diff --git a/packages/wallet/src/context/referral/utils/isReferralPossible.ts b/packages/wallet/src/context/referral/utils/isReferralPossible.ts
new file mode 100644
index 000000000..f3946a4d3
--- /dev/null
+++ b/packages/wallet/src/context/referral/utils/isReferralPossible.ts
@@ -0,0 +1,42 @@
+import { addresses } from "@/context/common/blockchain/addresses";
+import { frakChainPocClient } from "@/context/common/blockchain/provider";
+import { nexusDiscoverCampaignAbi } from "@/context/referral/abi/campaign-abis";
+import { type Address, type Hex, isAddressEqual, zeroAddress } from "viem";
+import { readContract } from "viem/actions";
+
+/**
+ * Check if a referral is possible
+ * @param user
+ * @param referrer
+ * @param tree
+ */
+export async function isReferralPossible({
+    user,
+    referrer,
+    tree,
+}: { user: Address; referrer: Address; tree: Hex }) {
+    // Ensure we got everything
+    if (!(user && referrer)) {
+        return false;
+    }
+
+    // Ensure the referrer is not the user, and none address is the zero one
+    if (
+        isAddressEqual(user, referrer) ||
+        isAddressEqual(referrer, zeroAddress) ||
+        isAddressEqual(user, zeroAddress)
+    ) {
+        return false;
+    }
+
+    // Check if user already referred on this content
+    const currentReferrer = await readContract(frakChainPocClient, {
+        address: addresses.nexusDiscoverCampaign,
+        abi: nexusDiscoverCampaignAbi,
+        functionName: "getReferrer",
+        args: [tree, user],
+    });
+
+    // If the user is already referred, do nothing
+    return isAddressEqual(currentReferrer, zeroAddress);
+}
diff --git a/packages/wallet/src/context/sdk/utils/iFrameRequestResolver.ts b/packages/wallet/src/context/sdk/utils/iFrameRequestResolver.ts
index ca724a04f..134e52361 100644
--- a/packages/wallet/src/context/sdk/utils/iFrameRequestResolver.ts
+++ b/packages/wallet/src/context/sdk/utils/iFrameRequestResolver.ts
@@ -172,5 +172,19 @@ export function getIframeRequestKeyProvider(
         ]) as KeyProvider<ExtractedParametersFromRpc<IFrameRpcSchema>>;
     }
 
+    // Referred user key
+    if (event.topic === "frak_listenToSetUserReferred") {
+        return ((
+            request: Extract<
+                ExtractedParametersFromRpc<IFrameRpcSchema>,
+                { method: "frak_listenToSetUserReferred" }
+            >
+        ) => [
+            "user-referred",
+            request.params[0],
+            request.params[1],
+        ]) as KeyProvider<ExtractedParametersFromRpc<IFrameRpcSchema>>;
+    }
+
     throw new Error(`No key provider found for the event ${event}`);
 }
diff --git a/packages/wallet/src/context/tokens/action/getTokenAsset.ts b/packages/wallet/src/context/tokens/action/getTokenAsset.ts
index 2b90cb738..ba1f91546 100644
--- a/packages/wallet/src/context/tokens/action/getTokenAsset.ts
+++ b/packages/wallet/src/context/tokens/action/getTokenAsset.ts
@@ -8,7 +8,7 @@ import {
     getTokenMetadata,
 } from "@/context/common/blockchain/viemActions/getTokenMetadata";
 import { CachesTags } from "@/context/common/caching";
-import { unstable_cache } from "next/cache";
+import { revalidateTag, unstable_cache } from "next/cache";
 import { parallel } from "radash";
 import { formatUnits } from "viem";
 import type { Address } from "viem";
@@ -78,6 +78,14 @@ export const getUserErc20Tokens = unstable_cache(
     }
 );
 
+/**
+ * Invalidate the user erc20 tokens
+ */
+export async function invalidateUserErc20Tokens() {
+    revalidateTag(CachesTags.WALLET_ERC20_ASSETS);
+    revalidateTag(CachesTags.WALLET_ERC20_BALANCE);
+}
+
 /**
  * Get the metadata of a token, cached version
  * @param address
diff --git a/packages/wallet/src/module/authentication/component/ButtonAuth/index.tsx b/packages/wallet/src/module/authentication/component/ButtonAuth/index.tsx
new file mode 100644
index 000000000..4c560b76f
--- /dev/null
+++ b/packages/wallet/src/module/authentication/component/ButtonAuth/index.tsx
@@ -0,0 +1,48 @@
+import { postAuthRedirectAtom } from "@/module/authentication/atoms/redirection";
+import { AuthFingerprint } from "@/module/common/component/AuthFingerprint";
+import { hasPaywallContextAtom } from "@/module/paywall/atoms/paywall";
+import { useTriggerReferral } from "@/module/referral/hook/useTriggerReferral";
+import type { WebAuthNWallet } from "@/types/WebAuthN";
+import { useAtom, useAtomValue } from "jotai";
+import { useRouter } from "next/navigation";
+import { useState, useTransition } from "react";
+import type { PropsWithChildren } from "react";
+
+export function ButtonAuth({
+    trigger,
+    disabled,
+    children,
+}: PropsWithChildren<{
+    trigger: () => Promise<WebAuthNWallet>;
+    disabled?: boolean;
+}>) {
+    const router = useRouter();
+    const [, startTransition] = useTransition();
+    const [disabledButton, setDisabledButton] = useState(false);
+    const { triggerReferral } = useTriggerReferral();
+    const [redirectUrl, setRedirectUrl] = useAtom(postAuthRedirectAtom);
+    const hasPaywallContext = useAtomValue(hasPaywallContextAtom);
+
+    return (
+        <AuthFingerprint
+            action={async () => {
+                setDisabledButton(true);
+                const wallet = await trigger();
+                await triggerReferral(wallet);
+                startTransition(() => {
+                    if (redirectUrl) {
+                        setRedirectUrl(null);
+                        window.location.href = decodeURIComponent(redirectUrl);
+                        return;
+                    }
+
+                    router.push(hasPaywallContext ? "/unlock" : "/wallet");
+                    setDisabledButton(false);
+                });
+            }}
+            disabled={disabledButton || disabled}
+        >
+            {children}
+        </AuthFingerprint>
+    );
+}
diff --git a/packages/wallet/src/module/authentication/component/Login/index.tsx b/packages/wallet/src/module/authentication/component/Login/index.tsx
index f718213ef..602718af7 100644
--- a/packages/wallet/src/module/authentication/component/Login/index.tsx
+++ b/packages/wallet/src/module/authentication/component/Login/index.tsx
@@ -1,46 +1,26 @@
 "use client";
 
-import { postAuthRedirectAtom } from "@/module/authentication/atoms/redirection";
+import { ButtonAuth } from "@/module/authentication/component/ButtonAuth";
 import { LoginList } from "@/module/authentication/component/LoginList";
 import { useLogin } from "@/module/authentication/hook/useLogin";
-import { AuthFingerprint } from "@/module/common/component/AuthFingerprint";
 import { Back } from "@/module/common/component/Back";
 import { Grid } from "@/module/common/component/Grid";
-import { hasPaywallContextAtom } from "@/module/paywall/atoms/paywall";
-import { useAtom, useAtomValue } from "jotai/index";
 import { CloudUpload } from "lucide-react";
 import Link from "next/link";
-import { useRouter } from "next/navigation";
-import { useCallback, useState, useTransition } from "react";
+import { useCallback } from "react";
 import styles from "./index.module.css";
 
 /**
  * Login from previous authentication
- * TODO: Flow for account recovery will be pretty simlar, just not listing previous authentications, just inputting the username
  * @constructor
  */
 export function Login() {
     const { login } = useLogin();
-    const hasPaywallContext = useAtomValue(hasPaywallContextAtom);
-    const router = useRouter();
-    const [, startTransition] = useTransition();
-    const [disabled, setDisabled] = useState(false);
-    const [redirectUrl, setRedirectUrl] = useAtom(postAuthRedirectAtom);
 
-    const triggerAction = useCallback(async () => {
-        setDisabled(true);
-        await login({});
-        startTransition(() => {
-            if (redirectUrl) {
-                setRedirectUrl(null);
-                window.location.href = decodeURIComponent(redirectUrl);
-                return;
-            }
-
-            router.push(hasPaywallContext ? "/unlock" : "/wallet");
-            setDisabled(false);
-        });
-    }, [hasPaywallContext, redirectUrl, setRedirectUrl, router, login]);
+    const triggerLogin = useCallback(async () => {
+        const { wallet } = await login({});
+        return wallet;
+    }, [login]);
 
     return (
         <>
@@ -56,9 +36,9 @@ export function Login() {
                     </>
                 }
             >
-                <AuthFingerprint action={triggerAction} disabled={disabled}>
+                <ButtonAuth trigger={triggerLogin}>
                     Recover your <strong>NEXUS</strong>
-                </AuthFingerprint>
+                </ButtonAuth>
             </Grid>
         </>
     );
diff --git a/packages/wallet/src/module/authentication/component/Register/index.tsx b/packages/wallet/src/module/authentication/component/Register/index.tsx
index dcd460014..260fe6fb6 100644
--- a/packages/wallet/src/module/authentication/component/Register/index.tsx
+++ b/packages/wallet/src/module/authentication/component/Register/index.tsx
@@ -1,29 +1,19 @@
 "use client";
 
 import { postAuthRedirectAtom } from "@/module/authentication/atoms/redirection";
+import { ButtonAuth } from "@/module/authentication/component/ButtonAuth";
 import { useRegister } from "@/module/authentication/hook/useRegister";
-import { AuthFingerprint } from "@/module/common/component/AuthFingerprint";
 import { Grid } from "@/module/common/component/Grid";
 import { Notice } from "@/module/common/component/Notice";
-import { hasPaywallContextAtom } from "@/module/paywall/atoms/paywall";
-import { useAtom } from "jotai";
-import { useAtomValue } from "jotai/index";
+import { useSetAtom } from "jotai";
 import Link from "next/link";
 import { useRouter } from "next/navigation";
 import { useSearchParams } from "next/navigation";
-import {
-    useCallback,
-    useEffect,
-    useMemo,
-    useState,
-    useTransition,
-} from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 import styles from "./index.module.css";
 
 export function Register() {
-    const hasPaywallContext = useAtomValue(hasPaywallContextAtom);
     const router = useRouter();
-    const [, startTransition] = useTransition();
     const { register, error, isRegisterInProgress } = useRegister();
     const [disabled, setDisabled] = useState(false);
 
@@ -31,13 +21,12 @@ export function Register() {
      * Get the redirectUrl from the URL and set it in storage if needed
      */
     const searchParams = useSearchParams();
-    const [redirectUrl, setRedirectUrl] = useAtom(postAuthRedirectAtom);
+    const redirectUrl = searchParams.get("redirectUrl");
+    const setRedirectUrl = useSetAtom(postAuthRedirectAtom);
     useEffect(() => {
-        const redirectUrl = searchParams.get("redirectUrl");
-        if (redirectUrl) {
-            setRedirectUrl(redirectUrl);
-        }
-    }, [searchParams.get, setRedirectUrl]);
+        if (!redirectUrl) return;
+        setRedirectUrl(redirectUrl);
+    }, [redirectUrl, setRedirectUrl]);
 
     /**
      * Boolean used to know if the error is about a previously used authenticator
@@ -87,20 +76,10 @@ export function Register() {
         );
     }, [isPreviouslyUsedAuthenticatorError, error, isRegisterInProgress]);
 
-    const triggerAction = useCallback(async () => {
-        setDisabled(true);
-        await register();
-        startTransition(() => {
-            if (redirectUrl) {
-                setRedirectUrl(null);
-                window.location.href = decodeURIComponent(redirectUrl);
-                return;
-            }
-
-            router.push(hasPaywallContext ? "/unlock" : "/wallet");
-        });
-        setDisabled(false);
-    }, [redirectUrl, setRedirectUrl, router, register, hasPaywallContext]);
+    const triggerRegister = useCallback(async () => {
+        const { wallet } = await register();
+        return wallet;
+    }, [register]);
 
     useEffect(() => {
         if (!error) return;
@@ -132,12 +111,12 @@ export function Register() {
                 </>
             }
         >
-            <AuthFingerprint
-                action={triggerAction}
+            <ButtonAuth
+                trigger={triggerRegister}
                 disabled={disabled || isPreviouslyUsedAuthenticatorError}
             >
                 {message}
-            </AuthFingerprint>
+            </ButtonAuth>
         </Grid>
     );
 }
diff --git a/packages/wallet/src/module/authentication/hook/useRegister.ts b/packages/wallet/src/module/authentication/hook/useRegister.ts
index 4e4fafe36..ea847c553 100644
--- a/packages/wallet/src/module/authentication/hook/useRegister.ts
+++ b/packages/wallet/src/module/authentication/hook/useRegister.ts
@@ -63,6 +63,8 @@ export function useRegister() {
 
             // Set the session
             setSession({ wallet });
+
+            return { wallet };
         },
     });
 
diff --git a/packages/wallet/src/module/listener/atoms/referralHistory.ts b/packages/wallet/src/module/listener/atoms/referralHistory.ts
new file mode 100644
index 000000000..ea5cd5f3b
--- /dev/null
+++ b/packages/wallet/src/module/listener/atoms/referralHistory.ts
@@ -0,0 +1,41 @@
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import { type Address, type Hex, zeroAddress } from "viem";
+
+type ContentId = Hex;
+type ReferralHistory = {
+    contents: { [key: ContentId]: Address };
+    lastReferrer: Address;
+};
+
+/**
+ * Atom representing the referral history
+ */
+export const referralHistoryAtom = atomWithStorage<ReferralHistory>(
+    "referralHistory",
+    {
+        contents: {},
+        lastReferrer: zeroAddress,
+    }
+);
+
+/**
+ * Add a referrer to the history atom
+ */
+export const addReferrerToHistoryAtom = atom(
+    null,
+    (
+        _get,
+        set,
+        { referrer, contentId }: { referrer: Address; contentId: Hex }
+    ) => {
+        set(referralHistoryAtom, (prev) => ({
+            ...prev,
+            contents: {
+                ...prev.contents,
+                [contentId]: referrer,
+            },
+            lastReferrer: referrer,
+        }));
+    }
+);
diff --git a/packages/wallet/src/module/listener/component/index.tsx b/packages/wallet/src/module/listener/component/index.tsx
index bf5e4e767..f73cc48d0 100644
--- a/packages/wallet/src/module/listener/component/index.tsx
+++ b/packages/wallet/src/module/listener/component/index.tsx
@@ -3,6 +3,7 @@
 import { createIFrameRequestResolver } from "@/context/sdk/utils/iFrameRequestResolver";
 import { useArticleUnlockStatusListener } from "@/module/listener/hooks/useArticleUnlockStatusListener";
 import { useGetArticleUnlockOptionsListener } from "@/module/listener/hooks/useGetArticleUnlockOptionsListener";
+import { useSetUserReferredListener } from "@/module/listener/hooks/useSetUserReferredListener";
 import { useWalletStatusListener } from "@/module/listener/hooks/useWalletStatusListener";
 import { useEffect, useState } from "react";
 
@@ -26,6 +27,9 @@ export function ListenerUI() {
     const { onArticleUnlockStatusListenerRequest } =
         useArticleUnlockStatusListener();
 
+    // Hook used when a user referred is requested
+    const { onUserReferredListenRequest } = useSetUserReferredListener();
+
     // Create the resolver
     useEffect(() => {
         const newResolver = createIFrameRequestResolver({
@@ -46,6 +50,11 @@ export function ListenerUI() {
              * @param emitter
              */
             frak_getArticleUnlockOptions: onGetArticleUnlockOptions,
+
+            /**
+             * Listen request on the user referred
+             */
+            frak_listenToSetUserReferred: onUserReferredListenRequest,
         });
 
         // Set our new resolver
@@ -59,6 +68,7 @@ export function ListenerUI() {
         onWalletListenRequest,
         onGetArticleUnlockOptions,
         onArticleUnlockStatusListenerRequest,
+        onUserReferredListenRequest,
     ]);
 
     /**
diff --git a/packages/wallet/src/module/listener/hooks/useSetUserReferredListener.ts b/packages/wallet/src/module/listener/hooks/useSetUserReferredListener.ts
new file mode 100644
index 000000000..73ed3b335
--- /dev/null
+++ b/packages/wallet/src/module/listener/hooks/useSetUserReferredListener.ts
@@ -0,0 +1,91 @@
+import { setUserReferredOnContent } from "@/context/referral/action/userReferredOnContent";
+import type { IFrameRequestResolver } from "@/context/sdk/utils/iFrameRequestResolver";
+import { sessionAtom } from "@/module/common/atoms/session";
+import { addReferrerToHistoryAtom } from "@/module/listener/atoms/referralHistory";
+import type {
+    ExtractedParametersFromRpc,
+    IFrameRpcSchema,
+} from "@frak-labs/nexus-sdk/core";
+import { useAtomValue, useSetAtom } from "jotai";
+import { useCallback } from "react";
+import { isAddressEqual } from "viem";
+
+type OnListenToUserReferred = IFrameRequestResolver<
+    Extract<
+        ExtractedParametersFromRpc<IFrameRpcSchema>,
+        { method: "frak_listenToSetUserReferred" }
+    >
+>;
+
+/**
+ * Hook use to listen to the user referred
+ */
+export function useSetUserReferredListener() {
+    /**
+     * Get the current user session
+     */
+    const session = useAtomValue(sessionAtom);
+
+    /**
+     * Set the referral history atom
+     */
+    const addReferrerToHistory = useSetAtom(addReferrerToHistoryAtom);
+
+    /**
+     * The function that will be called when a user referred is requested
+     * @param request
+     * @param emitter
+     */
+    const onUserReferredListenRequest: OnListenToUserReferred = useCallback(
+        async (request, emitter) => {
+            // Extract the contentId and walletAddress
+            const contentId = request.params[0];
+            const referrerAddress = request.params[1];
+            const userAddress = session?.wallet?.address;
+
+            // If no contentId or articleId, return
+            if (!(contentId && referrerAddress)) {
+                return;
+            }
+
+            // If no current wallet present
+            if (!userAddress) {
+                addReferrerToHistory({
+                    referrer: referrerAddress,
+                    contentId,
+                });
+                // Send the response
+                await emitter({
+                    key: "referred-history",
+                });
+                // And exit
+                return;
+            }
+
+            // If the referrer is the same as the current wallet address, do nothing
+            if (isAddressEqual(userAddress, referrerAddress)) {
+                // Send the response
+                await emitter({
+                    key: "same-wallet",
+                });
+                return;
+            }
+
+            // Otherwise, just set the user referred on content
+            await setUserReferredOnContent({
+                user: userAddress,
+                referrer: referrerAddress,
+                contentId,
+            });
+            // Send the response
+            await emitter({
+                key: "referred-successful",
+            });
+        },
+        [session?.wallet?.address, addReferrerToHistory]
+    );
+
+    return {
+        onUserReferredListenRequest,
+    };
+}
diff --git a/packages/wallet/src/module/referral/hook/useTriggerReferral.ts b/packages/wallet/src/module/referral/hook/useTriggerReferral.ts
new file mode 100644
index 000000000..0f552269c
--- /dev/null
+++ b/packages/wallet/src/module/referral/hook/useTriggerReferral.ts
@@ -0,0 +1,81 @@
+import { setUserReferred } from "@/context/referral/action/userReferred";
+import { setUserReferredOnContent } from "@/context/referral/action/userReferredOnContent";
+import { referralHistoryAtom } from "@/module/listener/atoms/referralHistory";
+import type { WebAuthNWallet } from "@/types/WebAuthN";
+import { useAtom } from "jotai";
+import { useCallback } from "react";
+import type { Hex } from "viem";
+
+/**
+ * Wallet governance address
+ */
+const FRAK_WALLET_GOVERNANCE: Hex =
+    "0xB5cbdba1Db3618a68921e7c00e38617c9AfDf220";
+
+/**
+ * Hook to trigger the referral
+ */
+export function useTriggerReferral() {
+    /**
+     * Referral history atom
+     */
+    const [referralHistory, setReferralHistory] = useAtom(referralHistoryAtom);
+
+    /**
+     * Referral from Frak when the user is not referred
+     */
+    const referralFromFrak = useCallback(
+        async (wallet: WebAuthNWallet) =>
+            await setUserReferred({
+                user: wallet.address,
+                referrer: FRAK_WALLET_GOVERNANCE,
+            }),
+        []
+    );
+
+    /**
+     * Referral from the last referred user
+     */
+    const referralFromUser = useCallback(
+        async (wallet: WebAuthNWallet) => {
+            // Set the user referred
+            await setUserReferred({
+                user: wallet.address,
+                referrer: referralHistory.lastReferrer,
+            });
+
+            // Set the user referred on each content
+            for (const contentId of Object.keys(referralHistory.contents)) {
+                const walletAddress =
+                    referralHistory.contents[contentId as Hex];
+                await setUserReferredOnContent({
+                    user: wallet.address,
+                    referrer: walletAddress,
+                    contentId: contentId as Hex,
+                });
+            }
+        },
+        [referralHistory]
+    );
+
+    /**
+     * Trigger the referral
+     */
+    const triggerReferral = useCallback(
+        async (wallet: WebAuthNWallet) => {
+            const referralMethod = Object.keys(referralHistory.contents).length
+                ? referralFromUser
+                : referralFromFrak;
+            await referralMethod(wallet);
+            setReferralHistory({ contents: {}, lastReferrer: "0x00" });
+        },
+        [
+            referralHistory,
+            referralFromFrak,
+            referralFromUser,
+            setReferralHistory,
+        ]
+    );
+
+    return { triggerReferral };
+}
diff --git a/packages/wallet/src/module/tokens/hook/useGetUserTokens.ts b/packages/wallet/src/module/tokens/hook/useGetUserTokens.ts
index f9953b92a..d77096d9e 100644
--- a/packages/wallet/src/module/tokens/hook/useGetUserTokens.ts
+++ b/packages/wallet/src/module/tokens/hook/useGetUserTokens.ts
@@ -1,7 +1,11 @@
 "use client";
 
-import { getUserErc20Tokens } from "@/context/tokens/action/getTokenAsset";
-import { useQuery } from "@tanstack/react-query";
+import {
+    getUserErc20Tokens,
+    invalidateUserErc20Tokens,
+} from "@/context/tokens/action/getTokenAsset";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
 import { useAccount, useChainId } from "wagmi";
 
 export function useGetUserTokens() {
@@ -33,3 +37,18 @@ export function useGetUserTokens() {
         refetch,
     };
 }
+
+export function useInvalidateUserTokens() {
+    const queryClient = useQueryClient();
+
+    return useCallback(async () => {
+        // Invalidate the user tokens server side
+        await invalidateUserErc20Tokens();
+
+        // Invalidate the user tokens client side
+        await queryClient.invalidateQueries({
+            queryKey: ["getUserTokens"],
+            exact: false,
+        });
+    }, [queryClient]);
+}
diff --git a/packages/wallet/src/module/wallet/component/Home/index.tsx b/packages/wallet/src/module/wallet/component/Home/index.tsx
index 9ac1b8cb7..4b6b90d5a 100644
--- a/packages/wallet/src/module/wallet/component/Home/index.tsx
+++ b/packages/wallet/src/module/wallet/component/Home/index.tsx
@@ -5,6 +5,7 @@ import { Tokens } from "@/module/tokens/component/Tokens";
 import { PendingWalletConnectRequests } from "@/module/wallet-connect/component/PendingRequests";
 import { CreateWalletConnectConnection } from "@/module/wallet-connect/component/StartConnect";
 import { InstallApp } from "@/module/wallet/component/InstallApp";
+import { PendingReferral } from "@/module/wallet/component/PendingReferral";
 
 export function WalletHomePage() {
     return (
@@ -13,6 +14,7 @@ export function WalletHomePage() {
             <PendingWalletConnectRequests />
             <Tokens />
             <CreateWalletConnectConnection />
+            <PendingReferral />
         </Grid>
     );
 }
diff --git a/packages/wallet/src/module/wallet/component/PendingReferral/index.module.css b/packages/wallet/src/module/wallet/component/PendingReferral/index.module.css
new file mode 100644
index 000000000..eabb60c3d
--- /dev/null
+++ b/packages/wallet/src/module/wallet/component/PendingReferral/index.module.css
@@ -0,0 +1,7 @@
+.pendingReferral__button {
+    margin-top: 10px;
+}
+
+.pendingReferral__success {
+    color: var(--frak-color-green);
+}
diff --git a/packages/wallet/src/module/wallet/component/PendingReferral/index.tsx b/packages/wallet/src/module/wallet/component/PendingReferral/index.tsx
new file mode 100644
index 000000000..d3c1932d0
--- /dev/null
+++ b/packages/wallet/src/module/wallet/component/PendingReferral/index.tsx
@@ -0,0 +1,86 @@
+import { addresses } from "@/context/common/blockchain/addresses";
+import { nexusDiscoverCampaignAbi } from "@/context/referral/abi/campaign-abis";
+import { getPendingWalletReferralReward } from "@/context/referral/action/pendingReferral";
+import { sessionAtom } from "@/module/common/atoms/session";
+import { ButtonRipple } from "@/module/common/component/ButtonRipple";
+import { Panel } from "@/module/common/component/Panel";
+import { Title } from "@/module/common/component/Title";
+import { useInvalidateUserTokens } from "@/module/tokens/hook/useGetUserTokens";
+import { useQuery } from "@tanstack/react-query";
+import { useAtomValue } from "jotai";
+import { CircleDollarSign } from "lucide-react";
+import { useWriteContract } from "wagmi";
+import styles from "./index.module.css";
+
+export function PendingReferral() {
+    // Invalidate the user tokens
+    const invalidateUserTokens = useInvalidateUserTokens();
+
+    // Fetch the current user session
+    const session = useAtomValue(sessionAtom);
+
+    // Get the user wallet address
+    const address = session?.wallet?.address;
+
+    // Fetch the pending reward
+    const { data: pendingReward, refetch: refetchPendingReward } = useQuery({
+        queryKey: ["getPendingWalletReferralReward"],
+        queryFn: async () => {
+            if (!address) return null;
+            return await getPendingWalletReferralReward({
+                user: address,
+            });
+        },
+        enabled: !!address,
+    });
+
+    // Get the write contract function
+    const { writeContractAsync, isPending, isSuccess } = useWriteContract({
+        mutation: {
+            onSuccess: async () => {
+                // Invalidate the user tokens
+                await invalidateUserTokens();
+
+                // Refetch the pending reward
+                await refetchPendingReward();
+            },
+        },
+    });
+
+    return pendingReward?.rFrkPendingRaw ? (
+        <Panel size={"small"}>
+            <Title icon={<CircleDollarSign width={32} height={32} />}>
+                Pending referral reward
+            </Title>
+            {isSuccess && (
+                <p className={styles.pendingReferral__success}>
+                    You have claimed your reward successfully!
+                </p>
+            )}
+            {!isSuccess && (
+                <>
+                    <p>
+                        You got {pendingReward?.rFrkPendingFormatted} rFRK
+                        pending thanks to your referral activities!
+                    </p>
+                    <ButtonRipple
+                        className={styles.pendingReferral__button}
+                        size={"small"}
+                        isLoading={isPending}
+                        disabled={isPending || isSuccess}
+                        onClick={async () => {
+                            // Launch the transaction
+                            await writeContractAsync({
+                                abi: nexusDiscoverCampaignAbi,
+                                address: addresses.nexusDiscoverCampaign,
+                                functionName: "pullReward",
+                            });
+                        }}
+                    >
+                        Claim
+                    </ButtonRipple>
+                </>
+            )}
+        </Panel>
+    ) : null;
+}