Position Partial Sell

This allows users to sell a portion of their leveraged position while keeping the rest active.

How It Works:

The partial sell feature uses two API endpoints, which can be bundled together using Jito on the front-end:

1. Split Position - Divides a position into two separate positions

2. Sell Manual Build - Sells one of the split positions

API Endpoints:

1. Split Position

POST /positions/split

Request Body:

{
"positionId": string,        // Position address to split
"userPubKey": string,        // User's wallet public key
"splitRatioBps": number,     // Split ratio in basis points (2500 = 25%)
"quoteToken": string         // Quote token mint address
}

Example Request:

{
  "positionId": "AezAHf5e6Cfiyyvu35KkWKEuZKLsEAN4XWzA36NvvCBw",
  "userPubKey": "CL7LTBpFgEcMrDkTfQpet9VvsGJas1iTxRJ6m1tXrTA9",
  "splitRatioBps": 2500,
  "quoteToken": "So11111111111111111111111111111111111111112"
}

Response:

{
  "transaction": string,  // Base58 encoded transaction to sign
  "newPosition1": {      // Position to be sold (splitRatioBps %)
    "splitRatioBps": number,
    "positionData": {
      "publicKey": string,
      "account": {
        "collateralAmount": number,
        "collateralType": string,
        "seed": string,
        "userPaid": number,
        "amount": number
      }
    }
  },
  "newPosition2": {      // Remaining position (100 - splitRatioBps %)
    // Same structure as newPosition1
  }
}

Example Response:

{
  "transaction": "base58_encoded_transaction",
  "newPosition1": {
    "splitRatioBps": 2500,
    "positionData": {
      "publicKey": "3QsgyW8ahzSbhCyxZW6WdsfC4ufHdnAVoPwxQnnqbuoh",
      "account": {
        "collateralAmount": 1421706,
        "collateralType": "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
        "seed": "HyzvdsBihv7Hd8skcX9xvBNufqzf7sikCjRSYHByk4Bj",
        "userPaid": 625000,
        "amount": 62500
      }
    }
  },
  "newPosition2": { */* remaining 75% position data */* }
}

2. Sell Manual Build

POST /positions/sell-manual-build

Request Body:

{
  "position": {                             *// Required - from split response*
    "publicKey": string,
    "account": {
      "collateralAmount": number,
      "collateralType": string,
      "seed": string,
      "userPaid": number,
      "amount": number
    }
  },
  "offerId": string,                        *// Required - loan offer address*
  "quoteToken": string,                     *// Required - quote token mint*
  "slippage": number,                       *// Required - in bps (500 = 5%)*
  "userPubKey": string,                     *// Required - user's wallet*
  "partnerFeeRecipient"?: string,           *// Optional - partner wallet*
  "partnerFeeMarkupBps"?: number,           *// Optional - partner fee (max 2000)*
  "priorityFeeMicroLamports"?: number,      *// Optional - priority fee*
}

Example Request Body:

{
  "position": {
    "publicKey": "3QsgyW8ahzSbhCyxZW6WdsfC4ufHdnAVoPwxQnnqbuoh",
    "account": {
      "collateralAmount": 1421706,
      "collateralType": "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
      "seed": "HyzvdsBihv7Hd8skcX9xvBNufqzf7sikCjRSYHByk4Bj",
      "userPaid": 625000,
      "amount": 62500
    }
  },
  "offerId": "7XX7mgzGgoMu12gYUZrzC7eARHDUZL38cLAU2hKbgAEw",
  "quoteToken": "So11111111111111111111111111111111111111112",
  "slippage": 500,  *// 5% slippage tolerance*
  "userPubKey": "CL7LTBpFgEcMrDkTfQpet9VvsGJas1iTxRJ6m1tXrTA9",
}

Response:

{
  "transaction": string,     *// Base58 encoded transaction to sign*
  "quoteResponse": object    *// Jupiter swap quote details*
}

Implementation Steps:

1. Get Split Transaction & Position Data

   • Call /positions/split with desired split ratio (in basis points)

   • Receive the transaction and new position details

2. Get Sell Transaction

   • Use the newPosition1 data from split response

   • Call /positions/sell-manual-build with the position details

3. Bundle with Jito

   • Get latest blockhash

   • Deserialize both transactions

   • Add Jito tip transaction (recommended: use 1.5x of 99th percentile tip floor)

   • Sign all three transactions

   • Submit bundle to Jito

Jito Bundle Implementation Example:

*// Step 1: Call split endpoint, get transaction + new position data*
const splitResponse = await fetch('/positions/split', {...});
const splitData = await splitResponse.json();

*// Step 2: Call sell-manual-build with the split position*
const sellResponse = await fetch('/positions/sell-manual-build', {
  body: JSON.stringify({
    position: splitData.newPosition1.positionData,
    *// ... other params*
  })
});
const sellData = await sellResponse.json();

*// Step 3: Prepare transactions for Jito bundle*
const latestBlockhash = await connection.getLatestBlockhash();

const splitTx = VersionedTransaction.deserialize(base58.decode(splitData.transaction));
splitTx.message.recentBlockhash = latestBlockhash.blockhash;

const sellTx = VersionedTransaction.deserialize(base58.decode(sellData.transaction));
sellTx.message.recentBlockhash = latestBlockhash.blockhash;

*// Step 4: Create Jito tip transaction*
const tipResponse = await axios.get('<https://bundles.jito.wtf/api/v1/bundles/tip_floor>');
const tipAmount = Number((Number(tipEstimates.data[0].landed_tips_99th_percentile) * 1.5 * 1000000000).toFixed(0))

const tipTx = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: wallet.publicKey,
    toPubkey: new PublicKey(<Jito tip account>),
    lamports: tipAmount
  })
);
tipTx.recentBlockhash = latestBlockhash.blockhash;
tipTx.feePayer = wallet.publicKey;

*// Step 5: Sign all transactions*
const signed = await wallet.signAllTransactions([tipTx, splitTx, sellTx]);

*// Step 6: Submit bundle to Jito*
await axios.post('<https://mainnet.block-engine.jito.wtf/api/v1/bundles>', {
  jsonrpc: '2.0',
  id: 1,
  method: 'sendBundle',
  params: [
    [
      Buffer.from(signed[0].serialize()).toString('base64'),  *// tip*
      Buffer.from(signed[1].serialize()).toString('base64'),  *// split*
      Buffer.from(signed[2].serialize()).toString('base64')   *// sell*
    ],
    { encoding: 'base64' }
  ]
});