sam/DX-251 (#795)

* actions

* @orca-so actions sdk

* updated yarn.lock

* updated yarn lock

* addresses comments

* lock

* changeset

* new lock

* changes web3.js -> kit

* formatted

* more lint

* lint

* new yarn lock

* small readme update

* reverts lint change for whirlpools prog

* try 2 rever wpools change

* moves actions into regular sdk

* rm changeset

* changeset

* revert cargo

* eof

* new yarn lock

* added typedoc for setPayerFromBytes

* added actions to readme for wpools ts sdk

Author: parhim

.changeset/weak-coats-end.md

@@ -0,0 +1,5 @@
+---
+"@orca-so/whirlpools": minor
+---
+
+Added actions (wrapped with execution logic)

ts-sdk/whirlpool/README.md

@@ -19,27 +19,33 @@ npm install @orca-so/whirlpools @solana/kit@2
 ## Basic Usage
 
 ### 1. Wallet Creation
+
 You can [generate a file system wallet using the Solana CLI](https://docs.solanalabs.com/cli/wallets/file-system) and load it in your program.
 
 ```tsx
-import { createKeyPairSignerFromBytes } from '@solana/kit';
-import fs from 'fs';
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import fs from "fs";
 
-const keyPairBytes = new Uint8Array(JSON.parse(fs.readFileSync('path/to/solana-keypair.json', 'utf8')));
+const keyPairBytes = new Uint8Array(
+  JSON.parse(fs.readFileSync("path/to/solana-keypair.json", "utf8"))
+);
 const wallet = await createKeyPairSignerFromBytes(keyPairBytes);
 ```
 
 ### 2. Configure the Whirlpools SDK for Your Network
+
 Orca's Whirlpools SDK supports several networks: Solana Mainnet, Solana Devnet, Eclipse Mainnet, and Eclipse Testnet. To select a network, use the `setWhirlpoolsConfig` function. This ensures compatibility with the network you’re deploying on.
 
 Example: Setting the SDK Configuration to Solana Devnet.
+
 ```tsx
-import { setWhirlpoolsConfig } from '@orca-so/whirlpools';
+import { setWhirlpoolsConfig } from "@orca-so/whirlpools";
 
-await setWhirlpoolsConfig('solanaDevnet');
+await setWhirlpoolsConfig("solanaDevnet");
 ```
 
 Available networks are:
+
 - solanaMainnet
 - solanaDevnet
 - eclipseMainnet
@@ -48,34 +54,36 @@ Available networks are:
 > ℹ️ The setWhirlpoolsConfig function accepts either one of Orca's default network keys or a custom Address. This allows you to specify a custom configuration if needed.
 
 ### 3. Create the Swap Instructions
+
 After configuring the SDK, you can perform a swap. Here is an example of how to perform a token swap using the Whirlpools SDK:
 
 ```tsx
-import { swapInstructions } from '@orca-so/whirlpools';
+import { swapInstructions } from "@orca-so/whirlpools";
 const poolAddress = "POOL_ADDRESS";
 const mintAddress = "TOKEN_MINT";
 const amount = 1_000_000n;
 const slippageTolerance = 100; // 100 bps = 1%
 
 const { instructions, quote } = await swapInstructions(
-    devnetRpc,
-    {
-        inputAmount: amount,
-        mint: mintAddress
-    },
-    poolAddress,
-    slippageTolerance,
-    wallet
+  devnetRpc,
+  {
+    inputAmount: amount,
+    mint: mintAddress,
+  },
+  poolAddress,
+  slippageTolerance,
+  wallet
 );
 ```
 
 ### 4. Putting it all together
+
 ```tsx
-import { swapInstructions, setWhirlpoolsConfig } from '@orca-so/whirlpools';
-import { generateKeyPairSigner, createSolanaRpc, devnet } from '@solana/kit';
+import { swapInstructions, setWhirlpoolsConfig } from "@orca-so/whirlpools";
+import { generateKeyPairSigner, createSolanaRpc, devnet } from "@solana/kit";
 
-const devnetRpc = createSolanaRpc(devnet('https://api.devnet.solana.com'));
-await setWhirlpoolsConfig('solanaDevnet');
+const devnetRpc = createSolanaRpc(devnet("https://api.devnet.solana.com"));
+await setWhirlpoolsConfig("solanaDevnet");
 const wallet = loadWallet();
 await devnetRpc.requestAirdrop(wallet.address, lamports(1000000000n)).send();
 
@@ -92,13 +100,164 @@ const amount = 1_000_000n; // 0.001 WSOL (SOL has 9 decimals)
 const slippageTolerance = 100; // 100bps = 1%
 
 const { instructions, quote } = await swapInstructions(
-    devnetRpc,
+  devnetRpc,
+  {
+    inputAmount: amount,
+    mint: mintAddress,
+  },
+  poolAddress,
+  slippageTolerance,
+  wallet
+);
+```
+
+## ACTIONS
+
+To use actions, you need to set some configuration first.
+The only required configuration is the keypair of the payer, and the rpc url.
+
+```tsx
+import { setPayerFromBytes, setRpc } from "@orca-so/whirlpools";
+
+// Set payer from a private key byte array
+const privateKeyBytes = new Uint8Array([
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+  23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+]);
+await setPayerFromBytes(privateKeyBytes);
+
+// Set rpc url
+await setRpc("https://api.devnet.solana.com");
+```
+
+You can also optionally set up the prioritization fees and jito tip settings according to your needs.
+
+```tsx
+// Set priority fee settings
+setPriorityFeeSetting({
+  type: "dynamic",
+  maxCapLamports: BigInt(4_000_000), // 0.004 SOL
+});
+
+// Set Jito tip settings
+setJitoTipSetting({
+  type: "dynamic",
+  maxCapLamports: BigInt(4_000_000), // 0.004 SOL
+});
+
+// Set compute unit margin multiplier
+setComputeUnitMarginMultiplier(1.1);
+
+// Set priority fee percentile
+setPriorityFeePercentile("50");
+
+// Set Jito fee percentile (50ema is the default)
+setJitoFeePercentile("50ema");
+
+// Set Jito block engine URL
+await setJitoBlockEngineUrl("https://bundles.jito.wtf");
+```
+
+### 1. Create a new whirlpool
+
+```tsx
+import { createSplashPool } from "@orca-so/whirlpools";
+import { address } from "@solana/kit";
+
+// Create a new splash pool between SOL and USDC
+const { poolAddress, callback } = await createSplashPool(
+  address("So11111111111111111111111111111111111111112"), // SOL
+  address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") // USDC
+);
+
+// Execute the transaction
+const signature = await callback();
+console.log(`Pool created at ${poolAddress} in tx ${signature}`);
+```
+
+### 2. Add liquidity to a whirlpool
+
+```tsx
+import {
+  openFullRangePosition,
+  openConcentratedPosition,
+} from "@orca-so/whirlpools";
+import { address } from "@solana/kit";
+
+// Add full range liquidity to a splash pool
+const { positionAddress, callback: fullRangeCallback } =
+  await openFullRangePosition(
+    address("POOL_ADDRESS"), // The pool address
     {
-        inputAmount: amount,
-        mint: mintAddress
+      tokenA: BigInt(1_000_000), // Amount of token A to add (in native units)
     },
-    poolAddress,
-    slippageTolerance,
-    wallet
+    50 // Optional: Slippage tolerance in basis points (0.5%)
+  );
+
+// Execute the transaction
+const fullRangeSig = await fullRangeCallback();
+console.log(
+  `Full range position created at ${positionAddress} in tx ${fullRangeSig}`
 );
+
+// Add concentrated liquidity to a whirlpool
+const { positionAddress: concPosAddress, callback: concCallback } =
+  await openConcentratedPosition(
+    address("POOL_ADDRESS"), // The pool address
+    {
+      tokenA: BigInt(1_000_000), // Amount of token A to add (in native units)
+    },
+    19.5, // Lower price bound
+    20.5, // Upper price bound
+    50 // Optional: Slippage tolerance in basis points (0.5%)
+  );
+
+// Execute the transaction
+const concSig = await concCallback();
+console.log(
+  `Concentrated position created at ${concPosAddress} in tx ${concSig}`
+);
+
+// Increase liquidity in an existing position
+const { callback: increaseLiqCallback, quote } = await increasePosLiquidity(
+  address("POSITION_ADDRESS"), // The position address
+  {
+    tokenA: BigInt(1_000_000), // Amount of token A to add (in native units)
+  },
+  50 // Optional: Slippage tolerance in basis points (0.5%)
+);
+
+//optionally check quote
+if (quote.tokenMaxB < 1_000_000n) {
+  // Check if max token B amount is acceptable
+  const increaseLiqSig = await increaseLiqCallback();
+  console.log(`Added liquidity in tx ${increaseLiqSig}`);
+} else {
+  console.log(`Required token B amount ${quote.tokenMaxB} is too high`);
+}
+```
+
+### 3. Harvest rewards from all positions
+
+```tsx
+// Harvest fees and rewards from all positions owned by the wallet
+const signatures = await harvestAllPositionFees();
+console.log(`Harvested all positions in ${signatures.length} transactions`);
+
+// Harvest fees and rewards from a single position
+const {
+  callback: harvestCallback,
+  feesQuote,
+  rewardsQuote,
+} = await harvestPosition(
+  address("POSITION_ADDRESS") // The position address
+);
+
+// Check quotes
+console.log(`Fees to collect: ${feesQuote.feeOwedA}, ${feesQuote.feeOwedB}`);
+console.log(`Rewards to collect: ${rewardsQuote.rewards[0].rewardsOwed}`);
+
+// Execute the transaction
+const harvestSig = await harvestCallback();
+console.log(`Harvested position in tx ${harvestSig}`);
 ```

ts-sdk/whirlpool/src/actionHelpers.ts

@@ -0,0 +1,67 @@
+import {
+  address,
+  createNoopSigner,
+  getBase64EncodedWireTransaction,
+  type IInstruction,
+  type Rpc,
+  type Signature,
+  type SolanaRpcApi,
+  type TransactionSigner,
+} from "@solana/kit";
+import { getPayer, getRpcConfig } from "./config";
+import {
+  rpcFromUrl,
+  buildAndSendTransaction,
+  buildTransaction,
+} from "@orca-so/tx-sender";
+
+/**
+ * A generic wrapper function to reduce boilerplate when working with Whirlpool instructions
+ * @param instructionFn The Whirlpool instruction function to execute
+ * @returns A wrapped function that automatically includes rpc and owner params
+ */
+export function wrapFunctionWithExecution<T extends unknown[], R>(
+  instructionFn: (
+    rpc: Rpc<SolanaRpcApi>,
+    ...params: [...T, TransactionSigner]
+  ) => Promise<R & { instructions: IInstruction[] }>,
+): (...params: T) => Promise<R & { callback: () => Promise<Signature> }> {
+  return async (...params: T) => {
+    const { rpcUrl } = getRpcConfig();
+    const rpc = rpcFromUrl(rpcUrl);
+    const owner = getPayer();
+
+    const result = await instructionFn(rpc, ...params, owner);
+
+    return {
+      ...result,
+      callback: () => buildAndSendTransaction(result.instructions, owner),
+    };
+  };
+}
+
+/**
+ * Check if adding additional instructions would exceed transaction size limits
+ * @param currentInstructions Current list of instructions in transaction
+ * @param instructionsToAdd Instructions to check if they can be added
+ * @returns True if adding instructions would exceed size limit, false otherwise
+ */
+export async function wouldExceedTransactionSize(
+  currentInstructions: IInstruction[],
+  instructionsToAdd: IInstruction[],
+): Promise<boolean> {
+  const noopSginer = createNoopSigner(
+    address("11111111111111111111111111111111"),
+  );
+  const tx = await buildTransaction(
+    [...currentInstructions, ...instructionsToAdd],
+    noopSginer,
+  );
+  const encodedTransaction = getBase64EncodedWireTransaction(tx);
+
+  // The maximum size for a base64 encoded transaction is 1644 bytes
+  // This is derived from PACKET_DATA_SIZE (1232) with base64 encoding overhead
+  const TX_BASE64_ENCODED_SIZE_LIMIT = 1644;
+
+  return encodedTransaction.length >= TX_BASE64_ENCODED_SIZE_LIMIT;
+}

ts-sdk/whirlpool/src/config.ts

@@ -1,7 +1,23 @@
 import { getWhirlpoolsConfigExtensionAddress } from "@orca-so/whirlpools-client";
-import type { Address, TransactionSigner } from "@solana/kit";
-import { address, createNoopSigner, isAddress } from "@solana/kit";
-
+import type { Address, TransactionSigner, KeyPairSigner } from "@solana/kit";
+import {
+  address,
+  createNoopSigner,
+  isAddress,
+  createKeyPairFromBytes,
+  createSignerFromKeyPair,
+} from "@solana/kit";
+
+export {
+  setComputeUnitMarginMultiplier,
+  setJitoBlockEngineUrl,
+  setJitoTipSetting,
+  setPriorityFeeSetting,
+  setRpc,
+  setJitoFeePercentile,
+  setPriorityFeePercentile,
+  getRpcConfig,
+} from "@orca-so/tx-sender";
 /**
  * The default (null) address.
  */
@@ -170,3 +186,37 @@ export function resetConfiguration() {
   SLIPPAGE_TOLERANCE_BPS = DEFAULT_SLIPPAGE_TOLERANCE_BPS;
   NATIVE_MINT_WRAPPING_STRATEGY = DEFAULT_NATIVE_MINT_WRAPPING_STRATEGY;
 }
+
+let _payer: KeyPairSigner | undefined;
+
+/**
+ * Sets the payer from a private key byte array.
+ *
+ * @param {Uint8Array<ArrayBuffer>} pkBytes - The private key bytes to create the payer from.
+ * @returns {Promise<KeyPairSigner>} - A promise that resolves to the created signer.
+ *
+ * @example
+ * ```ts
+ * // Set payer from a private key byte array
+ * const privateKeyBytes = new Uint8Array([
+ *   55, 244, 186, 115, 93, 3, 9, 47, 12, 168,
+ *   86, 1, 5, 155, 127, 3, 44, 165, 155, 3,
+ *   112, 1, 3, 99, 3, 211, 3, 77, 153,
+ *   44, 1, 179
+ * ]);
+ * const signer = await setPayerFromBytes(privateKeyBytes);
+ * ```
+ */
+export async function setPayerFromBytes(pkBytes: Uint8Array<ArrayBuffer>) {
+  const kp = await createKeyPairFromBytes(pkBytes);
+  const signer = await createSignerFromKeyPair(kp);
+  _payer = signer;
+  return signer;
+}
+
+export function getPayer(): KeyPairSigner {
+  if (!_payer) {
+    throw new Error("Payer not set. Call setPayer() first.");
+  }
+  return _payer;
+}