> ## Documentation Index
> Fetch the complete documentation index at: https://blog.loopscale.com/llms.txt
> Use this file to discover all available pages before exploring further.

# How Loopscale Collateralizes CLMM Liquidity Positions

export const XEmbed = ({url, options = {}}) => {
  const containerRef = useRef(null);
  useEffect(() => {
    const renderTweet = () => {
      if (containerRef.current) {
        containerRef.current.innerHTML = '';
        const tweetId = url.split('/').pop().split('?')[0];
        const embedOptions = {
          theme: 'light',
          align: 'center',
          ...options
        };
        window.twttr.widgets.createTweetEmbed(tweetId, containerRef.current, embedOptions).catch(err => console.error("Failed to embed tweet ${url}:", err));
      }
    };
    const onScriptLoad = () => {
      window.twttr.ready(() => renderTweet());
    };
    if (window.twttr?.widgets) {
      onScriptLoad();
      return;
    }
    const scriptId = 'twitter-wjs';
    let script = document.getElementById(scriptId);
    document.addEventListener('twitter-widget-loaded', onScriptLoad);
    if (!script) {
      script = document.createElement('script');
      script.id = scriptId;
      script.src = 'https://platform.twitter.com/widgets.js';
      script.async = true;
      script.onload = () => {
        document.dispatchEvent(new CustomEvent('twitter-widget-loaded'));
      };
      script.onerror = error => {
        console.error('Failed to load Twitter widget script:', error);
      };
      document.head.appendChild(script);
    }
    return () => {
      document.removeEventListener('twitter-widget-loaded', onScriptLoad);
    };
  }, [url, options]);
  return <div ref={containerRef} className="x-embed" />;
};

export const MetadataCard = ({author_id, date}) => {
  const authors = {
    loopscale: {
      name: 'Loopscale',
      avatar: '/static/assets/favicon.svg'
    },
    devin: {
      name: 'Devin Black',
      avatar: '/static/assets/authors/devin.png'
    },
    mary: {
      name: 'Mary Gooneratne',
      avatar: '/static/assets/authors/mary.png'
    },
    luke: {
      name: 'Luke Truitt',
      avatar: '/static/assets/authors/luke.png'
    },
    logan: {
      name: 'Logan',
      avatar: '/static/assets/authors/logan.webp'
    }
  };
  const author = authors[author_id] || authors['loopscale'];
  return <div className="metadata-card">
      <div className="metadata-author">
        <img className="metadata-author-avatar" src={author.avatar} alt={author.name} style={{
    pointerEvents: 'none'
  }} />
        <p className="metadata-author-name">{author.name}</p>
      </div>
      <p className="metadata-date">{date}</p>
    </div>;
};

<MetadataCard author_id="devin" date="March 2, 2026" />

<img src="https://mintcdn.com/loopscale2/OSRkIwGc9o-RyV2I/static/assets/images/clmm.webp?fit=max&auto=format&n=OSRkIwGc9o-RyV2I&q=85&s=975a03da62485ee17f229666ad69810c" alt="" width="2400" height="1350" data-path="static/assets/images/clmm.webp" />

## How Loopscale Collateralizes CLMM Liquidity Positions

Concentrated liquidity positions are a significant asset class on Solana, operating within defined price ranges earning yield from trading fees. But before Loopscale, they couldn't be used as collateral anywhere.

On Loopscale, LP tokens from [Orca](https://www.orca.so/) and [Raydium](https://raydium.io/) can be posted as collateral for borrowing, something only possible because Loopscale's order book architecture prices each position on its own terms rather than running it through a pooled lending model.

<XEmbed url="https://x.com/Loopscale/status/1928453597697569059" />

## Why pool-based lending can't price LP collateral

Pool-based lending protocols set a single borrow rate based on utilization. That rate applies regardless of what collateral is backing the loan. A borrow against USDT gets the same rate as a borrow against a concentrated liquidity position, which makes no sense from a risk-pricing perspective.

LP positions are structurally different from standard tokens. A concentrated liquidity position has a price range, a fee tier, and exposure to two underlying assets. Pricing this kind of collateral requires evaluating each position individually — its composition, its range, its underlying assets. Pool-based models aren't built for that. They're built for single tokens with a single oracle price.

## How Loopscale's order book handles it

Loopscale's order book architecture matches lenders and borrowers directly, with each loan priced per collateral. A lender decides what collateral they'll accept, at what LTV, at what rate, for what duration. If a lender is comfortable with a USDT-USDC Whirlpool position as collateral — a stablecoin pair with tight range and predictable behavior — they can offer terms that reflect that specific risk profile. A different lender might price a volatile LP pair differently.

In practice, most LP lending happens through Vaults. Orca launched dedicated Vaults on Loopscale — [one for USDC](https://app.loopscale.com/vault/3Poc8EoDyTdtLXf4AUQf3dHvaxUJNb1wspRkizrbe5jR) and one for [USDG](https://app.loopscale.com/vault/31vgw6Bvg7AtiQb8RJmdYohvVVASQ9zGmGu33AhYe6pH) — that fund borrowing against Orca LP positions. The underlying mechanism is the same whether the lender is a Vault or an individual: per-collateral pricing, isolated risk, and fixed rates.

## How to borrow against LP positions

To borrow against a concentrated liquidity position, go to [app.loopscale.com/borrow](app.loopscale.com/borrow) and select the asset you want to borrow.

Available collateral types are typically scoped to the borrow asset — a USDC borrow will show USDC-paired LP positions as eligible collateral, a SOL borrow will show SOL-paired positions, and so on. Select your LP position, set your desired LTV, and confirm the transaction.

For users looking to utilize the full power of Loopscale: [these positions can be manually looped](https://docs.loopscale.com/using-loopscale/loop#manually-open) to gain leverage on a CLMM LP.

<XEmbed url="https://x.com/Loopscale/status/1986833634297586128" />

Concentrated liquidity positions are some of the most powerful on-chain primitives in DeFi. Supporting them as collateral requires a lending model that can evaluate each position individually — that's Loopscale's order book-based markets.