diff --git a/components/bounty-detail/bounty-detail-client.tsx b/components/bounty-detail/bounty-detail-client.tsx
index cddbaabd..b98afd56 100644
--- a/components/bounty-detail/bounty-detail-client.tsx
+++ b/components/bounty-detail/bounty-detail-client.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { useState, useCallback } from "react";
 import { useRouter } from "next/navigation";
 import { AlertCircle, ArrowLeft } from "lucide-react";
 import { Button } from "@/components/ui/button";
@@ -10,13 +11,21 @@ import { BountyDetailSubmissionsCard } from "./bounty-detail-submissions-card";
 import { BountyDetailSkeleton } from "./bounty-detail-bounty-detail-skeleton";
 import { useBountyDetail } from "@/hooks/use-bounty-detail";
 import { EscrowDetailPanel } from "../bounty/escrow-detail-panel";
+import { RefundStatusTracker } from "../bounty/refund-status";
 import { FeeCalculator } from "../bounty/fee-calculator";
 import { useEscrowPool } from "@/hooks/use-escrow";
+import type { CancellationRecord } from "@/types/escrow";
 
 export function BountyDetailClient({ bountyId }: { bountyId: string }) {
   const router = useRouter();
   const { data: bounty, isPending, isError, error } = useBountyDetail(bountyId);
   const { data: pool } = useEscrowPool(bountyId);
+  const [cancellationRecord, setCancellationRecord] =
+    useState<CancellationRecord | null>(null);
+
+  const handleCancelled = useCallback((record: CancellationRecord) => {
+    setCancellationRecord(record);
+  }, []);
 
   if (isPending) return <BountyDetailSkeleton />;
 
@@ -68,26 +77,34 @@ export function BountyDetailClient({ bountyId }: { bountyId: string }) {
     );
   }
 
+  const isCancelled =
+    bounty.status === "CANCELLED" || cancellationRecord !== null;
+
   return (
     <div className="flex flex-col lg:flex-row gap-10">
       {/* Main content */}
       <div className="flex-1 min-w-0 space-y-6">
         <HeaderCard bounty={bounty} />
         <DescriptionCard description={bounty.description} />
-        {pool && <EscrowDetailPanel poolId={bountyId} />}
+        {!isCancelled && pool && <EscrowDetailPanel poolId={bountyId} />}
+        <RefundStatusTracker
+          bountyId={bountyId}
+          isCancelled={isCancelled}
+        />
         <BountyDetailSubmissionsCard bounty={bounty} />
       </div>
 
       {/* Sidebar */}
       <aside className="w-full lg:w-72 shrink-0">
         <div className="lg:sticky lg:top-24 space-y-4">
-          <SidebarCTA bounty={bounty} />
+          <SidebarCTA bounty={bounty} onCancelled={handleCancelled} />
           <FeeCalculator />
         </div>
       </aside>
 
       {/* Mobile sticky CTA */}
-      <MobileCTA bounty={bounty} />
+      <MobileCTA bounty={bounty} onCancelled={handleCancelled} />
     </div>
   );
 }
+
diff --git a/components/bounty-detail/bounty-detail-sidebar-cta.tsx b/components/bounty-detail/bounty-detail-sidebar-cta.tsx
index 7fe5fe20..ec5cdf1a 100644
--- a/components/bounty-detail/bounty-detail-sidebar-cta.tsx
+++ b/components/bounty-detail/bounty-detail-sidebar-cta.tsx
@@ -1,16 +1,57 @@
 "use client";
 
 import { useState } from "react";
-import { Github, Copy, Check, AlertCircle } from "lucide-react";
+import {
+  Github,
+  Copy,
+  Check,
+  AlertCircle,
+  XCircle,
+  Loader2,
+} from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Separator } from "@/components/ui/separator";
+import { Textarea } from "@/components/ui/textarea";
+import { Label } from "@/components/ui/label";
+import {
+  AlertDialog,
+  AlertDialogContent,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogCancel,
+} from "@/components/ui/alert-dialog";
+import { toast } from "sonner";
 
 import { BountyFieldsFragment } from "@/lib/graphql/generated";
 import { StatusBadge, TypeBadge } from "./bounty-badges";
+import { authClient } from "@/lib/auth-client";
+import type { CancellationRecord } from "@/types/escrow";
+import { useCancelBountyDialog } from "@/hooks/use-cancel-bounty-dialog";
 
-export function SidebarCTA({ bounty }: { bounty: BountyFieldsFragment }) {
+interface SidebarCTAProps {
+  bounty: BountyFieldsFragment;
+  onCancelled?: (record: CancellationRecord) => void;
+}
+
+export function SidebarCTA({ bounty, onCancelled }: SidebarCTAProps) {
   const [copied, setCopied] = useState(false);
+  const { data: session } = authClient.useSession();
+
+  const {
+    cancelDialogOpen,
+    setCancelDialogOpen,
+    cancelReason,
+    setCancelReason,
+    isCancelling,
+    handleCancel,
+  } = useCancelBountyDialog(bounty.id, onCancelled);
+
   const canAct = bounty.status === "OPEN";
+  const isCreator = session?.user?.id === bounty.createdBy;
+  const canCancel =
+    isCreator && (bounty.status === "OPEN" || bounty.status === "IN_PROGRESS");
 
   const handleCopy = async () => {
     try {
@@ -94,6 +135,22 @@ export function SidebarCTA({ bounty }: { bounty: BountyFieldsFragment }) {
           </p>
         )}
 
+        {/* Cancel Bounty - only for creator on open/in-progress */}
+        {canCancel && (
+          <>
+            <Separator className="bg-gray-800/60" />
+            <Button
+              variant="outline"
+              className="w-full border-red-500/30 text-red-400 hover:bg-red-500/10 hover:text-red-300 hover:border-red-500/50 transition-all"
+              onClick={() => setCancelDialogOpen(true)}
+              disabled={isCancelling}
+            >
+              <XCircle className="size-4 mr-2" />
+              Cancel Bounty
+            </Button>
+          </>
+        )}
+
         {/* GitHub */}
         <a
           href={bounty.githubIssueUrl}
@@ -123,12 +180,96 @@ export function SidebarCTA({ bounty }: { bounty: BountyFieldsFragment }) {
           )}
         </button>
       </div>
+
+      {/* Cancel Confirmation Dialog */}
+      <AlertDialog open={cancelDialogOpen} onOpenChange={setCancelDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle className="flex items-center gap-2 text-red-400">
+              <XCircle className="size-5" />
+              Cancel Bounty
+            </AlertDialogTitle>
+            <AlertDialogDescription className="text-muted-foreground space-y-2">
+              <span className="block">
+                Are you sure you want to cancel this bounty? This action will:
+              </span>
+              <ul className="list-disc list-inside space-y-1 text-sm">
+                <li>
+                  Mark the bounty as <strong>Cancelled</strong>
+                </li>
+                <li>Initiate a refund of escrowed funds to your wallet</li>
+                <li>
+                  Notify any contributors who have started or submitted work
+                </li>
+              </ul>
+              <span className="block text-xs text-yellow-500/80 mt-2">
+                ⚠️ This action cannot be undone. Any in-progress submissions
+                will be invalidated.
+              </span>
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+
+          <div className="space-y-3 mt-2">
+            <div className="space-y-2">
+              <Label htmlFor="cancel-reason" className="text-sm font-medium">
+                Reason for cancellation <span className="text-red-400">*</span>
+              </Label>
+              <Textarea
+                id="cancel-reason"
+                placeholder="e.g., Requirements changed, budget reallocation, issue resolved externally..."
+                value={cancelReason}
+                onChange={(e) => setCancelReason(e.target.value)}
+                className="min-h-[80px] resize-none"
+                disabled={isCancelling}
+              />
+            </div>
+          </div>
+
+          <AlertDialogFooter className="mt-4">
+            <AlertDialogCancel
+              disabled={isCancelling}
+              onClick={() => setCancelReason("")}
+            >
+              Keep Bounty
+            </AlertDialogCancel>
+            <Button
+              variant="destructive"
+              onClick={handleCancel}
+              disabled={!cancelReason.trim() || isCancelling}
+            >
+              {isCancelling && (
+                <Loader2 className="mr-2 size-4 animate-spin" />
+              )}
+              Cancel Bounty & Refund
+            </Button>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
     </div>
   );
 }
 
-export function MobileCTA({ bounty }: { bounty: BountyFieldsFragment }) {
+interface MobileCTAProps {
+  bounty: BountyFieldsFragment;
+  onCancelled?: (record: CancellationRecord) => void;
+}
+
+export function MobileCTA({ bounty, onCancelled }: MobileCTAProps) {
+  const { data: session } = authClient.useSession();
+
+  const {
+    cancelDialogOpen,
+    setCancelDialogOpen,
+    cancelReason,
+    setCancelReason,
+    isCancelling,
+    handleCancel,
+  } = useCancelBountyDialog(bounty.id, onCancelled);
+
   const canAct = bounty.status === "OPEN";
+  const isCreator = session?.user?.id === bounty.createdBy;
+  const canCancel =
+    isCreator && (bounty.status === "OPEN" || bounty.status === "IN_PROGRESS");
 
   const label = () => {
     if (!canAct) {
@@ -146,17 +287,74 @@ export function MobileCTA({ bounty }: { bounty: BountyFieldsFragment }) {
 
   return (
     <div className="lg:hidden fixed bottom-0 left-0 right-0 p-4 bg-background/90 backdrop-blur-xl border-t border-gray-800/60 z-20">
-      <Button
-        className="w-full h-11 font-bold tracking-wide"
-        disabled={!canAct}
-        size="lg"
-        onClick={() =>
-          canAct &&
-          window.open(bounty.githubIssueUrl, "_blank", "noopener,noreferrer")
-        }
-      >
-        {label()}
-      </Button>
+      <div className="flex gap-2">
+        <Button
+          className="flex-1 h-11 font-bold tracking-wide"
+          disabled={!canAct}
+          size="lg"
+          onClick={() =>
+            canAct &&
+            window.open(bounty.githubIssueUrl, "_blank", "noopener,noreferrer")
+          }
+        >
+          {label()}
+        </Button>
+        {canCancel && (
+          <Button
+            variant="outline"
+            size="lg"
+            className="h-11 border-red-500/30 text-red-400 hover:bg-red-500/10 shrink-0"
+            onClick={() => setCancelDialogOpen(true)}
+          >
+            <XCircle className="size-4" />
+          </Button>
+        )}
+      </div>
+
+      {/* Mobile Cancel Dialog */}
+      <AlertDialog open={cancelDialogOpen} onOpenChange={setCancelDialogOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle className="flex items-center gap-2 text-red-400">
+              <XCircle className="size-5" />
+              Cancel Bounty
+            </AlertDialogTitle>
+            <AlertDialogDescription>
+              This will cancel the bounty and refund escrowed funds. This action
+              cannot be undone.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <div className="space-y-2">
+            <Label htmlFor="mobile-cancel-reason">
+              Reason <span className="text-red-400">*</span>
+            </Label>
+            <Textarea
+              id="mobile-cancel-reason"
+              placeholder="Reason for cancellation..."
+              value={cancelReason}
+              onChange={(e) => setCancelReason(e.target.value)}
+              className="min-h-[80px]"
+              disabled={isCancelling}
+            />
+          </div>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={isCancelling}>
+              Keep Bounty
+            </AlertDialogCancel>
+            <Button
+              variant="destructive"
+              onClick={handleCancel}
+              disabled={!cancelReason.trim() || isCancelling}
+            >
+              {isCancelling && (
+                <Loader2 className="mr-2 size-4 animate-spin" />
+              )}
+              Cancel & Refund
+            </Button>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
     </div>
   );
 }
+
diff --git a/components/bounty/refund-status.tsx b/components/bounty/refund-status.tsx
new file mode 100644
index 00000000..8737a7c4
--- /dev/null
+++ b/components/bounty/refund-status.tsx
@@ -0,0 +1,247 @@
+"use client";
+
+import { useCancellation } from "@/hooks/use-escrow";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import {
+  RotateCcw,
+  ExternalLink,
+  CheckCircle2,
+  Clock,
+  XCircle,
+  Loader2,
+  Copy,
+  Check,
+  AlertCircle,
+} from "lucide-react";
+import { toast } from "sonner";
+import { format } from "date-fns";
+import { useState } from "react";
+import type { RefundStatus } from "@/types/escrow";
+
+interface RefundStatusTrackerProps {
+  bountyId: string;
+  /** Only fetch when bounty is actually cancelled */
+  isCancelled: boolean;
+}
+
+const STATUS_CONFIG: Record<
+  RefundStatus,
+  {
+    icon: React.ElementType;
+    label: string;
+    colorClass: string;
+    bgClass: string;
+  }
+> = {
+  pending: {
+    icon: Clock,
+    label: "Pending",
+    colorClass: "text-yellow-400",
+    bgClass: "bg-yellow-500/10 border-yellow-500/20",
+  },
+  processing: {
+    icon: Loader2,
+    label: "Processing",
+    colorClass: "text-blue-400",
+    bgClass: "bg-blue-500/10 border-blue-500/20",
+  },
+  completed: {
+    icon: CheckCircle2,
+    label: "Completed",
+    colorClass: "text-emerald-400",
+    bgClass: "bg-emerald-500/10 border-emerald-500/20",
+  },
+  failed: {
+    icon: XCircle,
+    label: "Failed",
+    colorClass: "text-red-400",
+    bgClass: "bg-red-500/10 border-red-500/20",
+  },
+};
+
+export function RefundStatusTracker({
+  bountyId,
+  isCancelled,
+}: RefundStatusTrackerProps) {
+  const { data: cancellation, isLoading } = useCancellation(
+    bountyId,
+    isCancelled,
+  );
+  const [copiedHash, setCopiedHash] = useState(false);
+
+  if (!isCancelled) return null;
+
+  if (isLoading) {
+    return (
+      <Card className="border-border/50 bg-background-card">
+        <CardContent className="flex items-center justify-center py-8">
+          <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+          <span className="ml-2 text-sm text-muted-foreground">
+            Loading refund status…
+          </span>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (!cancellation) {
+    return (
+      <Card className="border-border/50 bg-background-card overflow-hidden">
+        <CardHeader className="border-b bg-muted/20 pb-4">
+          <div className="flex items-center gap-2">
+            <RotateCcw className="h-5 w-5 text-muted-foreground" />
+            <CardTitle className="text-base">Bounty Cancelled</CardTitle>
+          </div>
+        </CardHeader>
+        <CardContent className="pt-5 flex items-center gap-3">
+          <AlertCircle className="h-5 w-5 text-muted-foreground shrink-0" />
+          <p className="text-sm text-muted-foreground">
+            This bounty was cancelled. Detailed refund and cancellation
+            information is currently unavailable.
+          </p>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (!cancellation.refund) {
+    return (
+      <Card className="border-yellow-500/30 bg-yellow-500/5">
+        <CardHeader className="pb-3">
+          <div className="flex items-center gap-2">
+            <RotateCcw className="h-5 w-5 text-yellow-400" />
+            <CardTitle className="text-base">Refund Status</CardTitle>
+          </div>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm text-muted-foreground">
+            This bounty was cancelled. Refund is being processed by the escrow
+            contract.
+          </p>
+          {cancellation.reason && (
+            <div className="mt-3 p-3 rounded-lg bg-muted/30 border border-border/50">
+              <p className="text-xs text-muted-foreground uppercase tracking-wider font-medium mb-1">
+                Cancellation Reason
+              </p>
+              <p className="text-sm text-foreground">{cancellation.reason}</p>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    );
+  }
+
+  const { refund } = cancellation;
+  const config = STATUS_CONFIG[refund.status];
+  const StatusIcon = config.icon;
+
+  const handleCopyHash = async () => {
+    try {
+      await navigator.clipboard.writeText(refund.transactionHash);
+      setCopiedHash(true);
+      setTimeout(() => setCopiedHash(false), 2000);
+    } catch (err) {
+      console.error("Failed to copy hash:", err);
+      toast.error("Failed to copy transaction hash");
+      setCopiedHash(false);
+    }
+  };
+
+  const truncateHash = (hash: string) =>
+    `${hash.slice(0, 8)}…${hash.slice(-8)}`;
+
+  return (
+    <Card className="border-border/50 bg-background-card overflow-hidden">
+      <CardHeader className="border-b bg-muted/20 pb-4">
+        <div className="flex flex-col sm:flex-row sm:items-center justify-between gap-3">
+          <div className="flex items-center gap-2">
+            <RotateCcw className="h-5 w-5 text-red-400" />
+            <CardTitle className="text-base">Refund Status</CardTitle>
+          </div>
+          <Badge
+            className={`flex items-center gap-1.5 text-xs font-medium px-2.5 py-1 border ${config.bgClass} ${config.colorClass}`}
+          >
+            <StatusIcon
+              className={`h-3 w-3 ${config.colorClass} ${
+                refund.status === "processing" ? "animate-spin" : ""
+              }`}
+            />
+            {config.label}
+          </Badge>
+        </div>
+      </CardHeader>
+
+      <CardContent className="p-0">
+        {/* Refund summary grid */}
+        <div className="grid grid-cols-1 sm:grid-cols-2 divide-y sm:divide-y-0 sm:divide-x border-b">
+          <div className="p-5 flex flex-col justify-center">
+            <span className="text-xs text-muted-foreground uppercase font-semibold mb-1">
+              Amount Refunded
+            </span>
+            <div className="text-2xl font-bold flex items-baseline gap-1">
+              {refund.refundedAmount.toLocaleString()}
+              <span className="text-sm font-medium text-muted-foreground">
+                {refund.asset}
+              </span>
+            </div>
+          </div>
+          <div className="p-5 flex flex-col justify-center">
+            <span className="text-xs text-muted-foreground uppercase font-semibold mb-1">
+              Refund Date
+            </span>
+            <p className="text-sm font-medium text-foreground">
+              {format(new Date(refund.timestamp), "PPP 'at' p")}
+            </p>
+          </div>
+        </div>
+
+        {/* Transaction hash */}
+        <div className="p-5 border-b">
+          <p className="text-xs text-muted-foreground uppercase font-semibold mb-2">
+            Transaction Hash
+          </p>
+          <div className="flex items-center gap-2 p-3 rounded-lg bg-muted/30 border border-border/50">
+            <code className="text-xs font-mono text-foreground flex-1 break-all">
+              {truncateHash(refund.transactionHash)}
+            </code>
+            <button
+              onClick={handleCopyHash}
+              className="shrink-0 p-1.5 rounded-md hover:bg-muted/50 transition-colors"
+              title="Copy transaction hash"
+            >
+              {copiedHash ? (
+                <Check className="h-3.5 w-3.5 text-emerald-400" />
+              ) : (
+                <Copy className="h-3.5 w-3.5 text-muted-foreground" />
+              )}
+            </button>
+          </div>
+        </div>
+
+        {/* Cancellation reason */}
+        {cancellation.reason && (
+          <div className="p-5 border-b">
+            <p className="text-xs text-muted-foreground uppercase font-semibold mb-2">
+              Cancellation Reason
+            </p>
+            <p className="text-sm text-foreground">{cancellation.reason}</p>
+          </div>
+        )}
+
+        {/* Explorer link */}
+        <div className="p-4 bg-muted/20 border-t flex justify-end">
+          <a
+            href={refund.explorerUrl}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="text-xs text-primary hover:underline flex items-center gap-1"
+          >
+            View on Stellar Explorer
+            <ExternalLink className="h-3 w-3" />
+          </a>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
diff --git a/hooks/__tests__/use-cancel-bounty.test.ts b/hooks/__tests__/use-cancel-bounty.test.ts
new file mode 100644
index 00000000..aa0b25aa
--- /dev/null
+++ b/hooks/__tests__/use-cancel-bounty.test.ts
@@ -0,0 +1,101 @@
+import { EscrowService } from "@/lib/services/escrow";
+
+describe("EscrowService - Cancellation & Refund", () => {
+  beforeEach(() => {
+    EscrowService.__resetForTesting();
+  });
+
+  describe("cancelBounty", () => {
+    it("should cancel a bounty and return a full refund for Escrowed pools", async () => {
+      const record = await EscrowService.cancelBounty(
+        "1",
+        "user-123",
+        "Requirements changed",
+      );
+
+      expect(record.bountyId).toBe("1");
+      expect(record.cancelledBy).toBe("user-123");
+      expect(record.reason).toBe("Requirements changed");
+      expect(record.cancelledAt).toBeDefined();
+      expect(record.refund).not.toBeNull();
+      expect(record.refund!.refundedAmount).toBe(500); // full amount
+      expect(record.refund!.asset).toBe("USDC");
+      expect(record.refund!.status).toBe("completed");
+      expect(record.refund!.transactionHash).toHaveLength(64);
+      expect(record.refund!.explorerUrl).toContain("stellar.expert");
+    });
+
+    it("should update pool status to Refunded after cancellation", async () => {
+      await EscrowService.cancelBounty("1", "user-123", "Reason");
+      const pool = await EscrowService.getPool("1");
+      expect(pool?.status).toBe("Refunded");
+      expect(pool?.isLocked).toBe(false);
+    });
+
+    it("should throw when cancelling an already refunded pool", async () => {
+      await EscrowService.cancelBounty("1", "user-123", "First");
+      await expect(
+        EscrowService.cancelBounty("1", "user-123", "Second"),
+      ).rejects.toThrow("already been refunded");
+    });
+
+    it("should throw when cancelling a fully released pool", async () => {
+      await expect(
+        EscrowService.cancelBounty("3", "user-123", "test"),
+      ).rejects.toThrow("already been released");
+    });
+
+    it("should throw for a non-existent pool", async () => {
+      await expect(
+        EscrowService.cancelBounty("999", "user-123", "test"),
+      ).rejects.toThrow("No escrow pool found");
+    });
+  });
+
+  describe("refundAll", () => {
+    it("should refund remaining amount for a partially released pool", async () => {
+      const result = await EscrowService.refundAll("2");
+
+      expect(result.refundedAmount).toBe(150); // totalAmount - releasedAmount
+      expect(result.asset).toBe("USDC");
+      expect(result.status).toBe("completed");
+      expect(result.transactionHash).toHaveLength(64);
+    });
+
+    it("should throw for already refunded pool", async () => {
+      await EscrowService.refundAll("2");
+      await expect(EscrowService.refundAll("2")).rejects.toThrow(
+        "already been refunded",
+      );
+    });
+  });
+
+  describe("refundRemaining", () => {
+    it("should throw for fully released pool", async () => {
+      await expect(EscrowService.refundRemaining("3")).rejects.toThrow(
+        "No remaining funds",
+      );
+    });
+
+    it("should throw for non-existent pool", async () => {
+      await expect(EscrowService.refundRemaining("999")).rejects.toThrow(
+        "No escrow pool found",
+      );
+    });
+  });
+
+  describe("getCancellation", () => {
+    it("should return cancellation record for cancelled bounty", async () => {
+      await EscrowService.cancelBounty("1", "user-123", "Requirements changed");
+      const record = await EscrowService.getCancellation("1");
+      expect(record).not.toBeNull();
+      expect(record!.bountyId).toBe("1");
+      expect(record!.reason).toBe("Requirements changed");
+    });
+
+    it("should return null for non-cancelled bounty", async () => {
+      const record = await EscrowService.getCancellation("999");
+      expect(record).toBeNull();
+    });
+  });
+});
diff --git a/hooks/use-bounty-mutations.ts b/hooks/use-bounty-mutations.ts
index fa6ffce5..2c90b387 100644
--- a/hooks/use-bounty-mutations.ts
+++ b/hooks/use-bounty-mutations.ts
@@ -240,3 +240,77 @@ export function useClaimBounty() {
       mutation.mutateAsync({ input: { id, status: "IN_PROGRESS" } }, options),
   };
 }
+
+/**
+ * Hook to cancel a bounty and update its status in the registry.
+ * This hook handles the GraphQL status update to "CANCELLED".
+ * Escrow cancellation/refund is handled separately via EscrowService.cancelBounty.
+ *
+ * @returns Mutation object with:
+ *  - cancel: (id: string, reason?: string) => void
+ *  - cancelAsync: (id: string, reason?: string) => Promise<any>
+ *  - isPending: boolean (standard TanStack Query state)
+ *
+ * @example
+ * const { cancel, isPending } = useCancelBounty();
+ * cancel({ id: "123", reason: "Budget changed" });
+ */
+export function useCancelBounty() {
+  const queryClient = useQueryClient();
+
+  const mutation = useUpdateBountyMutation({
+    onMutate: async (variables) => {
+      const { id } = variables.input;
+      await queryClient.cancelQueries({ queryKey: bountyKeys.detail(id) });
+      const previous = queryClient.getQueryData<BountyQuery>(
+        bountyKeys.detail(id),
+      );
+
+      if (previous?.bounty) {
+        queryClient.setQueryData<BountyQuery>(bountyKeys.detail(id), {
+          ...previous,
+          bounty: {
+            ...previous.bounty,
+            status: "CANCELLED",
+            updatedAt: new Date().toISOString(),
+          },
+        });
+      }
+
+      return { previous, id };
+    },
+    onError: (_err, _vars, context) => {
+      if (context?.previous) {
+        queryClient.setQueryData(
+          bountyKeys.detail(context.id),
+          context.previous,
+        );
+      }
+    },
+    onSettled: (_data, _err, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: bountyKeys.detail(variables.input.id),
+      });
+      queryClient.invalidateQueries({ queryKey: bountyKeys.lists() });
+    },
+  });
+
+  return {
+    ...mutation,
+    cancel: (
+      { id, reason }: { id: string; reason?: string },
+      options?: UpdateBountyMutateOptions,
+    ) =>
+      // 'reason' is intentionally ignored in the GraphQL mutation because
+      // UpdateBountyInput does not support it. It is consumed by EscrowService.cancelBounty.
+      mutation.mutate({ input: { id, status: "CANCELLED" } }, options),
+    cancelAsync: (
+      { id, reason }: { id: string; reason?: string },
+      options?: UpdateBountyMutateOptions,
+    ) =>
+      // 'reason' is intentionally ignored in the GraphQL mutation because
+      // UpdateBountyInput does not support it. It is consumed by EscrowService.cancelBounty.
+      mutation.mutateAsync({ input: { id, status: "CANCELLED" } }, options),
+  };
+}
+
diff --git a/hooks/use-cancel-bounty-dialog.ts b/hooks/use-cancel-bounty-dialog.ts
new file mode 100644
index 00000000..4f7b92f2
--- /dev/null
+++ b/hooks/use-cancel-bounty-dialog.ts
@@ -0,0 +1,73 @@
+import { useState } from "react";
+import { toast } from "sonner";
+import { useCancelBounty } from "@/hooks/use-bounty-mutations";
+import { EscrowService } from "@/lib/services/escrow";
+import { authClient } from "@/lib/auth-client";
+import type { CancellationRecord } from "@/types/escrow";
+
+export function useCancelBountyDialog(
+  bountyId: string,
+  onCancelled?: (record: CancellationRecord) => void,
+) {
+  const [cancelDialogOpen, setCancelDialogOpen] = useState(false);
+  const [cancelReason, setCancelReason] = useState("");
+  const [isCancelling, setIsCancelling] = useState(false);
+
+  const { data: session } = authClient.useSession();
+  const cancelBountyMutation = useCancelBounty();
+
+  const handleCancel = async () => {
+    if (!cancelReason.trim()) {
+      toast.error("Please provide a reason for cancellation");
+      return;
+    }
+
+    setIsCancelling(true);
+    let record: CancellationRecord | null = null;
+
+    try {
+      // 1. Trigger escrow refund first (simulates on-chain call)
+      record = await EscrowService.cancelBounty(
+        bountyId,
+        session?.user?.id ?? "",
+        cancelReason.trim(),
+      );
+
+      // 2. Update bounty status via GraphQL
+      // If this fails, we must revert the escrow state
+      try {
+        await cancelBountyMutation.cancelAsync({
+          id: bountyId,
+          reason: cancelReason.trim(),
+        });
+      } catch (mutationErr) {
+        console.error("GraphQL mutation failed, reverting escrow:", mutationErr);
+        await EscrowService.revertCancel(bountyId);
+        throw mutationErr;
+      }
+
+      toast.success("Bounty cancelled and refund initiated", {
+        description: `${record.refund?.refundedAmount ?? 0} ${record.refund?.asset ?? ""} refunded`,
+      });
+
+      onCancelled?.(record);
+      setCancelDialogOpen(false);
+      setCancelReason("");
+    } catch (err) {
+      toast.error(
+        err instanceof Error ? err.message : "Failed to cancel bounty",
+      );
+    } finally {
+      setIsCancelling(false);
+    }
+  };
+
+  return {
+    cancelDialogOpen,
+    setCancelDialogOpen,
+    cancelReason,
+    setCancelReason,
+    isCancelling,
+    handleCancel,
+  };
+}
diff --git a/hooks/use-escrow.ts b/hooks/use-escrow.ts
index 2a6190e8..e62e8026 100644
--- a/hooks/use-escrow.ts
+++ b/hooks/use-escrow.ts
@@ -7,6 +7,8 @@ export const escrowKeys = {
   slots: (poolId: string) => [...escrowKeys.all, "slots", poolId] as const,
   fee: (amount: number, subType: string) =>
     [...escrowKeys.all, "fee", amount, subType] as const,
+  cancellation: (bountyId: string) =>
+    [...escrowKeys.all, "cancellation", bountyId] as const,
 };
 
 /**
@@ -41,3 +43,16 @@ export function useFeeCalculation(amount: number, subType: string) {
     enabled: amount > 0 && !!subType,
   });
 }
+
+/**
+ * Fetch the cancellation record for a bounty.
+ * Only enabled when the bounty status is CANCELLED.
+ */
+export function useCancellation(bountyId: string, enabled = true) {
+  return useQuery({
+    queryKey: escrowKeys.cancellation(bountyId),
+    queryFn: () => EscrowService.getCancellation(bountyId),
+    enabled: !!bountyId && enabled,
+  });
+}
+
diff --git a/lib/services/escrow.ts b/lib/services/escrow.ts
index 62571923..b1ec5c5c 100644
--- a/lib/services/escrow.ts
+++ b/lib/services/escrow.ts
@@ -1,4 +1,10 @@
-import { EscrowPool, EscrowSlot, FeeBreakdown } from "@/types/escrow";
+import {
+  EscrowPool,
+  EscrowSlot,
+  FeeBreakdown,
+  RefundResult,
+  CancellationRecord,
+} from "@/types/escrow";
 
 export class EscrowService {
   // Mock data mapping bountyId/poolId to EscrowPool and Slots
@@ -68,6 +74,46 @@ export class EscrowService {
     ],
   };
 
+  private static cancellations: Record<string, CancellationRecord> = {};
+
+  /**
+   * TEST-ONLY: Resets static properties to initial state to ensure tests
+   * do not bleed into each other due to static mutation.
+   */
+  static __resetForTesting() {
+    this.pools = {
+      "1": {
+        poolId: "1",
+        totalAmount: 500,
+        asset: "USDC",
+        isLocked: true,
+        expiry: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+        releasedAmount: 0,
+        status: "Escrowed",
+      },
+      "2": {
+        poolId: "2",
+        totalAmount: 300,
+        asset: "USDC",
+        isLocked: true,
+        expiry: new Date(Date.now() + 15 * 24 * 60 * 60 * 1000).toISOString(),
+        releasedAmount: 150,
+        status: "Partially Released",
+      },
+      "3": {
+        poolId: "3",
+        totalAmount: 200,
+        asset: "USDC",
+        isLocked: false,
+        expiry: null,
+        releasedAmount: 200,
+        status: "Fully Released",
+      },
+    };
+    // Note: slots are not modified by cancellation logic currently
+    this.cancellations = {};
+  }
+
   /**
    * Get the escrow pool details for a given pool ID (usually bounty ID in our mock).
    */
@@ -119,7 +165,181 @@ export class EscrowService {
     };
   }
 
-  private static async simulateDelay(): Promise<void> {
-    await new Promise((resolve) => setTimeout(resolve, 300));
+  /**
+   * Cancel a bounty and initiate the escrow refund.
+   * Maps to BountyRegistry.cancel_bounty(creator, bounty_id) on-chain.
+   * Returns the cancellation record including refund details.
+   */
+  static async cancelBounty(
+    bountyId: string,
+    cancelledBy: string,
+    reason: string,
+  ): Promise<CancellationRecord> {
+    await this.simulateDelay(800);
+
+    const pool = this.pools[bountyId];
+    if (!pool) {
+      throw new Error(`No escrow pool found for bounty ${bountyId}`);
+    }
+
+    if (pool.status === "Fully Released") {
+      throw new Error(
+        "Cannot cancel: all funds have already been released to recipients",
+      );
+    }
+
+    if (pool.status === "Refunded") {
+      throw new Error("This bounty has already been refunded");
+    }
+
+    // Determine refund amount (total minus already released)
+    const refundableAmount = pool.totalAmount - pool.releasedAmount;
+    const txHash = this.generateMockTxHash();
+
+    const refund: RefundResult = {
+      transactionHash: txHash,
+      poolId: pool.poolId,
+      refundedAmount: refundableAmount,
+      asset: pool.asset,
+      status: "completed",
+      timestamp: new Date().toISOString(),
+      explorerUrl: `https://stellar.expert/explorer/testnet/tx/${txHash}`,
+    };
+
+    // Update pool state
+    this.pools[bountyId] = {
+      ...pool,
+      isLocked: false,
+      status: "Refunded",
+    };
+
+    const record: CancellationRecord = {
+      bountyId,
+      cancelledBy,
+      reason,
+      cancelledAt: new Date().toISOString(),
+      refund,
+    };
+
+    this.cancellations[bountyId] = record;
+    return record;
+  }
+
+  /**
+   * Reverts a cancellation by restoring the pool to its previous state.
+   */
+  static async revertCancel(bountyId: string): Promise<void> {
+    await this.simulateDelay(400);
+
+    const pool = this.pools[bountyId];
+    if (!pool) return;
+
+    // Restore status based on existing releasedAmount
+    const status = pool.releasedAmount > 0 ? "Partially Released" : "Escrowed";
+
+    this.pools[bountyId] = {
+      ...pool,
+      isLocked: true,
+      status,
+    };
+
+    delete this.cancellations[bountyId];
+  }
+
+  /**
+   * Refund all funds in an escrow pool.
+   * Maps to CoreEscrow.refund_all(pool_id) on-chain.
+   */
+  static async refundAll(poolId: string): Promise<RefundResult> {
+    await this.simulateDelay(600);
+
+    const pool = this.pools[poolId];
+    if (!pool) {
+      throw new Error(`No escrow pool found: ${poolId}`);
+    }
+
+    if (pool.status === "Refunded") {
+      throw new Error("Pool has already been refunded");
+    }
+
+    const txHash = this.generateMockTxHash();
+    const refundedAmount = pool.totalAmount - pool.releasedAmount;
+
+    this.pools[poolId] = {
+      ...pool,
+      isLocked: false,
+      status: "Refunded",
+    };
+
+    return {
+      transactionHash: txHash,
+      poolId,
+      refundedAmount,
+      asset: pool.asset,
+      status: "completed",
+      timestamp: new Date().toISOString(),
+      explorerUrl: `https://stellar.expert/explorer/testnet/tx/${txHash}`,
+    };
+  }
+
+  /**
+   * Refund remaining (unreleased) funds in an escrow pool.
+   * Maps to CoreEscrow.refund_remaining(pool_id) on-chain.
+   */
+  static async refundRemaining(poolId: string): Promise<RefundResult> {
+    await this.simulateDelay(600);
+
+    const pool = this.pools[poolId];
+    if (!pool) {
+      throw new Error(`No escrow pool found: ${poolId}`);
+    }
+
+    if (pool.status === "Refunded") {
+      throw new Error("Pool has already been refunded");
+    }
+
+    if (pool.status === "Fully Released") {
+      throw new Error("No remaining funds to refund");
+    }
+
+    const txHash = this.generateMockTxHash();
+    const refundedAmount = pool.totalAmount - pool.releasedAmount;
+
+    this.pools[poolId] = {
+      ...pool,
+      isLocked: false,
+      status: pool.releasedAmount > 0 ? "Partially Released" : "Refunded",
+    };
+
+    return {
+      transactionHash: txHash,
+      poolId,
+      refundedAmount,
+      asset: pool.asset,
+      status: "completed",
+      timestamp: new Date().toISOString(),
+      explorerUrl: `https://stellar.expert/explorer/testnet/tx/${txHash}`,
+    };
+  }
+
+  /**
+   * Get cancellation record for a bounty, if it exists.
+   */
+  static async getCancellation(
+    bountyId: string,
+  ): Promise<CancellationRecord | null> {
+    await this.simulateDelay();
+    return this.cancellations[bountyId] || null;
+  }
+
+  private static simulateDelay(ms = 300): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  private static generateMockTxHash(): string {
+    const chars = "abcdef0123456789";
+    return Array.from({ length: 64 }, () =>
+      chars.charAt(Math.floor(Math.random() * chars.length)),
+    ).join("");
   }
 }
diff --git a/types/escrow.ts b/types/escrow.ts
index e2cd7e42..83e24319 100644
--- a/types/escrow.ts
+++ b/types/escrow.ts
@@ -29,3 +29,23 @@ export interface FeeBreakdown {
   insuranceFee: number;
   netPayout: number;
 }
+
+export type RefundStatus = "pending" | "processing" | "completed" | "failed";
+
+export interface RefundResult {
+  transactionHash: string;
+  poolId: string;
+  refundedAmount: number;
+  asset: string;
+  status: RefundStatus;
+  timestamp: string;
+  explorerUrl: string;
+}
+
+export interface CancellationRecord {
+  bountyId: string;
+  cancelledBy: string;
+  reason: string;
+  cancelledAt: string;
+  refund: RefundResult | null;
+}