Doppler

https://github.com/whetstoneresearch/doppler-docs
Admin
Doppler is an Ethereum Virtual Machine (EVM) based token launchpad and liquidity bootstrapping...
Tokens:68,443
Snippets:321
Trust Score:6.1
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install Doppler SDK and Viem

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/README.md

Install the required Doppler SDK and viem packages to begin building on Base.

```bash
npm install @whetstone-research/doppler-sdk viem
```

--------------------------------

### Install Unified SDK via npm

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/legacy-sdks-and-migration-guides/sdk-migration-guide.md

Commands to remove legacy Doppler packages and install the new unified SDK with viem.

```bash
# Remove old packages
npm uninstall @doppler/v3-sdk @doppler/v4-sdk ethers

# Install new packages
npm install @whetstone-research/doppler-sdk viem
```

--------------------------------

### Price Quoter Example

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/examples/quoting-monitoring-and-metrics.md

Demonstrates how to initialize the Doppler SDK and perform various price quote operations including exact input/output for V3, V2 single and multi-hop swaps, and V4 pool swaps.

```typescript
/**
 * Example: Price Quoter
 * 
 * This example demonstrates:
 * - Getting price quotes across Uniswap V2, V3, and V4
 * - Comparing quotes to find best prices
 * - Handling different swap types (exact input/output)
 */

// UNCOMMENT IF RUNNING LOCALLY
// import { DopplerSDK } from '@whetstone-research/doppler-sdk';
import { DopplerSDK } from '../src';

import { createPublicClient, http, parseEther, formatEther, type Address } from 'viem'
import { baseSepolia } from 'viem/chains'

const token = process.env.TOKEN as `0x${string}`;
const rpcUrl = process.env.RPC_URL || baseSepolia.rpcUrls.default.http[0] as string;

if (!token) throw new Error('TOKEN is not set');

// Example token addresses (replace with actual addresses)
const weth = '0x4200000000000000000000000000000000000006' as Address // WETH on Base
const usdc = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address // USDC on Base

async function main() {
  // Initialize SDK
  const publicClient = createPublicClient({
    chain: baseSepolia,
    transport: http(rpcUrl)
  })

  const sdk = new DopplerSDK({
    publicClient,
    chainId: baseSepolia.id
  })

  const quoter = sdk.quoter

  console.log('💱 Price Quoter Example')
  console.log('=====================')

  // Example 1: Quote exact input on V3
  console.log('\n📊 Example 1: Swap 1 ETH for USDC on V3')
  try {
    const v3Quote = await quoter.quoteExactInputV3({
      tokenIn: weth,
      tokenOut: usdc,
      amountIn: parseEther('1'),
      fee: 3000 // 0.3% fee tier
    })
    
    console.log('- Amount out:', formatEther(v3Quote.amountOut), 'USDC')
    console.log('- Price impact (ticks crossed):', v3Quote.initializedTicksCrossed)
    console.log('- Gas estimate:', v3Quote.gasEstimate.toString())
    console.log('- Final sqrtPriceX96:', v3Quote.sqrtPriceX96After.toString())
  } catch (error) {
    console.error('V3 quote failed:', error.message)
  }

  // Example 2: Quote exact output on V3
  console.log('\n📊 Example 2: Get exactly 2000 USDC, pay in ETH on V3')
  try {
    const v3QuoteOut = await quoter.quoteExactOutputV3({
      tokenIn: weth,
      tokenOut: usdc,
      amountOut: parseEther('2000'), // Want exactly 2000 USDC
      fee: 3000
    })
    
    console.log('- Amount in required:', formatEther(v3QuoteOut.amountIn), 'ETH')
    console.log('- Price impact (ticks crossed):', v3QuoteOut.initializedTicksCrossed)
    console.log('- Gas estimate:', v3QuoteOut.gasEstimate.toString())
  } catch (error) {
    console.error('V3 exact output quote failed:', error.message)
  }

  // Example 3: Quote on V2 (if available)
  console.log('\n📊 Example 3: Swap 1 ETH for USDC on V2')
  try {
    const v2Quote = await quoter.quoteExactInputV2({
      amountIn: parseEther('1'),
      path: [weth, usdc]
    })
    
    console.log('- Amount out:', formatEther(v2Quote[1]), 'USDC')
    console.log('- Simple constant product AMM pricing')
  } catch (error) {
    console.error('V2 quote failed:', error.message)
  }

  // Example 4: Multi-hop V2 quote
  console.log('\n📊 Example 4: Multi-hop swap ETH -> USDC -> TOKEN on V2')
  try {
    const multiHopQuote = await quoter.quoteExactInputV2({
      amountIn: parseEther('1'),
      path: [weth, usdc, token] // ETH -> USDC -> TOKEN
    })
    
    console.log('Hop results:')
    console.log('- Start:', formatEther(multiHopQuote[0]), 'ETH')
    console.log('- After hop 1:', formatEther(multiHopQuote[1]), 'USDC')
    console.log('- Final:', formatEther(multiHopQuote[2]), 'TOKEN')
  } catch (error) {
    console.error('Multi-hop quote failed:', error.message)
  }

  // Example 5: V4 quote (for graduated dynamic auctions)
  console.log('\n📊 Example 5: Swap on V4 pool')
  try {
    const v4PoolKey = {
      currency0: weth,
      currency1: token,
      fee: 3000,
      tickSpacing: 60,
      hooks: '0x0000000000000000000000000000000000000000' as Address // No hook for graduated pool
    }
    
    const v4Quote = await quoter.quoteExactInputV4({
      poolKey: v4PoolKey,
      zeroForOne: true, // Swapping currency0 (WETH) for currency1 (TOKEN)
      exactAmount: parseEther('1')
    })
    
    console.log('- Amount out:', formatEther(v4Quote.amountOut), 'TOKEN')
    console.log('- Gas estimate:', v4Quote.gasEstimate.toString())
  } catch (error) {
    console.error('V4 quote failed:', error.message)
  }
```

--------------------------------

### Monitor Existing Auctions

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/examples/quoting-monitoring-and-metrics.md

This example shows how to monitor static and dynamic auctions, check graduation status, and track key metrics like liquidity, price, and sale progress.

```typescript
/**
 * Example: Monitor Existing Auctions
 *
 * This example demonstrates:
 * - Monitoring static and dynamic auctions
 * - Checking graduation status
 * - Tracking key metrics and progress
 */

// UNCOMMENT IF RUNNING LOCALLY
// import { DopplerSDK } from '@whetstone-research/doppler-sdk';

import { DopplerSDK } from '../src';
import {
  http,
  formatEther,
  type Address,
  createPublicClient,
} from 'viem';
import { baseSepolia } from 'viem/chains';

// Example addresses - replace with your actual auction addresses
const staticPoolAddress = process.env.STATIC_POOL_ADDRESS as `0x${string}`;
const dynamicHookAddress = process.env.DYNAMIC_HOOK_ADDRESS as `0x${string}`;
const rpcUrl = process.env.RPC_URL || baseSepolia.rpcUrls.default.http[0] as string;

async function monitorStaticAuction(sdk: DopplerSDK, poolAddress: Address) {
  console.log('\n📊 Monitoring Static Auction...');
  console.log('Pool address:', poolAddress);

  try {
    const auction = await sdk.getStaticAuction(poolAddress);

    // Get pool information
    const poolInfo = await auction.getPoolInfo();
    console.log('\nPool Information:');
    console.log('- Token:', poolInfo.tokenAddress);
    console.log('- Numeraire:', poolInfo.numeraireAddress);
    console.log('- Fee tier:', poolInfo.fee / 10000, '%');
    console.log('- Liquidity:', formatEther(poolInfo.liquidity));
    console.log('- SqrtPriceX96:', poolInfo.sqrtPriceX96.toString());

    // Get current price
    const currentPrice = await auction.getCurrentPrice();
    console.log('\nCurrent tick price:', currentPrice.toString());

    // Check graduation status
    const hasGraduated = await auction.hasGraduated();
    console.log(
      '\nGraduation status:',
      hasGraduated ? '✅ Graduated' : '⏳ Active'
    );

    // Get token address for further info
    const tokenAddress = await auction.getTokenAddress();
    console.log('Token contract:', tokenAddress);
  } catch (error) {
    console.error('Error monitoring static auction:', error);
  }
}

async function monitorDynamicAuction(sdk: DopplerSDK, hookAddress: Address) {
  console.log('\n📊 Monitoring Dynamic Auction...');
  console.log('Hook address:', hookAddress);

  try {
    const auction = await sdk.getDynamicAuction(hookAddress);

    // Get comprehensive hook information
    const hookInfo = await auction.getHookInfo();
    console.log('\nHook Information:');
    console.log('- Token:', hookInfo.tokenAddress);
    console.log('- Numeraire:', hookInfo.numeraireAddress);
    console.log('- Pool ID:', hookInfo.poolId);
    console.log('- Current epoch:', hookInfo.currentEpoch);

    console.log('\nSale Progress:');
    console.log(
      '- Total proceeds:',
      formatEther(hookInfo.totalProceeds),
      'ETH'
    );
    console.log('- Tokens sold:', formatEther(hookInfo.totalTokensSold));
    console.log(
      '- Min proceeds:',
      formatEther(hookInfo.minimumProceeds),
      'ETH'
    );
    console.log(
      '- Max proceeds:',
      formatEther(hookInfo.maximumProceeds),
      'ETH'
    );

    console.log('\nAuction Status:');
    console.log('- Early exit:', hookInfo.earlyExit ? '✅ Yes' : '❌ No');
    console.log(
      '- Insufficient proceeds:',
      hookInfo.insufficientProceeds ? '⚠️ Yes' : '✅ No'
    );

    // Calculate time remaining
    const now = BigInt(Math.floor(Date.now() / 1000));
    if (now < hookInfo.endingTime) {
      const remaining = Number(hookInfo.endingTime - now);
      const hours = Math.floor(remaining / 3600);
      const minutes = Math.floor((remaining % 3600) / 60);
      console.log('- Time remaining:', `${hours}h ${minutes}m`);
    } else {
      console.log('- Time remaining: Auction ended');
    }
```

--------------------------------

### Token Interaction with DERC20

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/examples/quoting-monitoring-and-metrics.md

This example shows how to interact with DERC20 tokens launched via Doppler, including checking balances, retrieving token metadata, and viewing vesting information.

```typescript
/**
 * Example: Token Interaction
 *
 * This example demonstrates:
 * - Interacting with DERC20 tokens launched via Doppler
 * - Checking balances and vesting data
 * - Approving spending and releasing vested tokens
 */

// UNCOMMENT IF RUNNING LOCALLY
// import { Derc20, Eth } from '@whetstone-research/doppler-sdk';

import { Derc20, Eth } from '../src';
import {
  createPublicClient,
  createWalletClient,
  http,
  parseEther,
  formatEther,
} from 'viem';
import { baseSepolia } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

// Configuration
const spender = process.env.SPENDER as `0x${string}`;
const privateKey = process.env.PRIVATE_KEY as `0x${string}`;
const rpcUrl = process.env.RPC_URL || baseSepolia.rpcUrls.default.http[0] as string;
const tokenAddress = process.env.TOKEN_ADDRESS as `0x${string}`;

if (!privateKey) throw new Error('PRIVATE_KEY is not set');
if (!tokenAddress) throw new Error('TOKEN_ADDRESS is not set');
if (!spender) throw new Error('SPENDER is not set');

async function main() {
  // 1. Set up clients
  const account = privateKeyToAccount(privateKey);

  const publicClient = createPublicClient({
    chain: baseSepolia,
    transport: http(rpcUrl),
  });

  const walletClient = createWalletClient({
    chain: baseSepolia,
    transport: http(rpcUrl),
    account,
  });

  console.log('💰 Token Interaction Example');
  console.log('===========================');
  console.log('Account:', account.address);
  console.log('Token:', tokenAddress);

  // 2. Create token instance
  const token = new Derc20(publicClient, walletClient, tokenAddress);

  try {
    // 3. Get token information
    console.log('\n📋 Token Information:');
    const [name, symbol, decimals, totalSupply] = await Promise.all([
      token.getName(),
      token.getSymbol(),
      token.getDecimals(),
      token.getTotalSupply(),
    ]);

    console.log('- Name:', name);
    console.log('- Symbol:', symbol);
    console.log('- Decimals:', decimals);
    console.log('- Total Supply:', formatEther(totalSupply), symbol);

    // 4. Check balances
    console.log('\n💸 Balances:');
    const balance = await token.getBalanceOf(account.address);
    console.log('- Your balance:', formatEther(balance), symbol);

    // Also check ETH balance
    const eth = new Eth(publicClient);
    const ethBalance = await eth.getBalanceOf(account.address);
    console.log('- ETH balance:', formatEther(ethBalance), 'ETH');

    // 5. Check vesting information
    console.log('\n⏰ Vesting Information:');
    const [vestingDuration, vestingStart, vestedTotal] = await Promise.all([
      token.getVestingDuration(),
      token.getVestingStart(),
      token.getVestedTotalAmount(),
    ]);

    if (vestingDuration > 0n) {
      const vestingEndTime = vestingStart + vestingDuration;
      const now = BigInt(Math.floor(Date.now() / 1000));
      const isVestingActive = now < vestingEndTime;

      console.log(
        '- Vesting duration:',
        Number(vestingDuration) / 86400,
        'days'
      );
      console.log(
        '- Vesting start:',
        new Date(Number(vestingStart) * 1000).toLocaleString()
      );
      console.log('- Total vested amount:', formatEther(vestedTotal), symbol);
      console.log('- Vesting active:', isVestingActive);
```

--------------------------------

### Create a Multicurve pool with RehypeDopplerHook

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/advanced-features/rehype-pools.md

This example demonstrates how to initialize a Multicurve auction with specific fee distribution percentages using the DopplerSDK. The distribution percentages for asset buyback, numeraire buyback, beneficiary, and LP must sum to 1 WAD (100%).

```typescript
import { DopplerSDK, getAddresses } from '@whetstone-research/doppler-sdk';
import { parseEther, createPublicClient, createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const privateKey = process.env.PRIVATE_KEY as `0x${string}`;
const rpcUrl = process.env.RPC_URL ?? 'https://mainnet.base.org';

async function main() {
  const account = privateKeyToAccount(privateKey);
  const addresses = getAddresses(base.id);

  const publicClient = createPublicClient({
    chain: base,
    transport: http(rpcUrl),
  });

  const walletClient = createWalletClient({
    chain: base,
    transport: http(rpcUrl),
    account,
  });

  const sdk = new DopplerSDK({
    publicClient,
    walletClient,
    chainId: base.id,
  });

  // Get protocol owner for beneficiary requirement (min 5%)
  const protocolOwner = await sdk.getAirlockBeneficiary();

  // Beneficiaries receive the beneficiaryPercentWad portion of fees
  const beneficiaries = [
    protocolOwner, // 5% to protocol (minimum required)
    { beneficiary: account.address, shares: parseEther('0.95') }, // 95% to creator
  ];

  const BUYBACK_DESTINATION = account.address; // receives bought-back tokens

  const params = sdk
    .buildMulticurveAuction()
    .tokenConfig({
      name: 'Rehype Token',
      symbol: 'RHT',
      tokenURI: 'https://example.com/metadata.json',
    })
    .saleConfig({
      initialSupply: parseEther('1000000000'),
      numTokensToSell: parseEther('1000000000'),
      numeraire: addresses.weth,
    })
    .withCurves({
      numerairePrice: 3000, // ETH = $3000 USD
      curves: [
        { marketCap: { start: 500_000, end: 1_500_000 }, numPositions: 10, shares: parseEther('0.3') },
        { marketCap: { start: 1_000_000, end: 5_000_000 }, numPositions: 15, shares: parseEther('0.4') },
        { marketCap: { start: 4_000_000, end: 50_000_000 }, numPositions: 10, shares: parseEther('0.3') },
      ],
      beneficiaries,
    })
    .withRehypeDopplerHook({
      hookAddress: addresses.rehypeDopplerHookInitializer!,
      buybackDestination: BUYBACK_DESTINATION,
      customFee: 3000, // 0.3% swap fee
      // Distribution must sum to WAD (100%)
      assetBuybackPercentWad: parseEther('0.20'),      // 20%
      numeraireBuybackPercentWad: parseEther('0.20'), // 20%
      beneficiaryPercentWad: parseEther('0.30'),       // 30%
      lpPercentWad: parseEther('0.30'),                // 30%
    })
    .withGovernance({ type: 'noOp' })
    .withMigration({ type: 'noOp' })
    .withUserAddress(account.address)
    .withDopplerHookInitializer(addresses.dopplerHookInitializer!)
    .withNoOpMigrator(addresses.noOpMigrator!)
    .build();

  const result = await sdk.factory.createMulticurve(params);

  console.log('Pool:', result.poolId);
  console.log('Token:', result.tokenAddress);
}

main();
```

--------------------------------

### Create a Multicurve auction using market cap ranges

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/examples/multicurve.md

This example demonstrates how to configure a Multicurve auction using market cap ranges. It includes a tail curve to ensure price continuity beyond the bonding curve.

```typescript
import { DopplerSDK, getAddresses } from '@whetstone-research/doppler-sdk/evm';
import { parseEther, createPublicClient, createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { base } from 'viem/chains';

const privateKey = process.env.PRIVATE_KEY as `0x${string}`;
const rpcUrl = process.env.RPC_URL ?? base.rpcUrls.default.http[0];

async function main() {
  const account = privateKeyToAccount(privateKey);

  const publicClient = createPublicClient({
    chain: base,
    transport: http(rpcUrl),
  });

  const walletClient = createWalletClient({
    chain: base,
    transport: http(rpcUrl),
    account,
  });

  const addresses = getAddresses(base.id);

  const sdk = new DopplerSDK({
    publicClient,
    walletClient,
    chainId: base.id,
  });

  const params = sdk
    .buildMulticurveAuction()
    .tokenConfig({
      name: 'My Token',
      symbol: 'MTK',
      tokenURI: 'https://example.com/token-metadata.json',
    })
    .saleConfig({
      initialSupply: parseEther('1000000000'),
      numTokensToSell: parseEther('900000000'),
      numeraire: addresses.weth,
    })
    .withCurves({
      numerairePrice: 3000, // ETH = $3000 USD
      curves: [
        {
          marketCap: { start: 500_000, end: 1_500_000 },
          numPositions: 10,
          shares: parseEther('0.3'),  // 30%
        },
        {
          marketCap: { start: 1_000_000, end: 5_000_000 },
          numPositions: 15,
          shares: parseEther('0.4'),  // 40%
        },
        {
          marketCap: { start: 4_000_000, end: 6_000_000 },
          numPositions: 10,
          shares: parseEther('0.2'),  // 20%
        },
        // Tail curve: extends liquidity to infinity
        {
          marketCap: { start: 6_000_000, end: 'max' },
          numPositions: 1,
          shares: parseEther('0.1'),  // 10% (completes 100%)
        },
      ],
    })
    .withVesting({
      duration: BigInt(365 * 24 * 60 * 60),
      cliffDuration: 0,
    })
    .withGovernance({ type: 'noOp' })
    .withMigration({ type: 'uniswapV2' })
    .withUserAddress(account.address)
    .build();

  const result = await sdk.factory.createMulticurve(params);

  console.log('Pool ID:', result.poolId);
  console.log('Token:', result.tokenAddress);
}

main();
```

--------------------------------

### createInitializeLaunchInstruction(accounts, args)

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-reference.md

Builds the raw on-chain instruction for a new Doppler launch, requiring explicit account and argument mapping.

```APIDOC
## createInitializeLaunchInstruction(accounts, args)

### Description
Builds the on-chain instruction for a new Doppler launch using provided account mappings and arguments.

### Parameters
- **accounts** (Object) - Required - Includes config, launch, launchAuthority, baseMint, quoteMint, baseVault, quoteVault, launchFeeState, payer, authority, hookProgram, migratorProgram, cpmmConfig, baseTokenProgram, quoteTokenProgram, metadataAccount, and hookCreateRemainingAccounts.
- **args** (Object) - Required - Arguments for the initialization instruction.
```

--------------------------------

### createLaunch(input)

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-reference.md

Builds a complete initialize_launch instruction for a new Doppler launch on Solana, handling PDA derivation, CPMM migration payloads, and hook configuration.

```APIDOC
## createLaunch(input)

### Description
Builds a complete initialize_launch instruction for a new Doppler launch. It derives launch PDAs, builds CPMM migration payloads, installs the CPMM hook, and commits relevant remaining-account hashes.

### Parameters
- **deployment** (Object) - Required - Deployment object resolved via deriveSolanaCpmmDeployment.
- **launchAccounts** (Object) - Required - Contains baseMint, quoteMint, baseVault, and quoteVault.
- **payer** (AddressOrSigner) - Required - The fee payer.
- **authority** (AddressOrSigner) - Required - The launch authority.
- **supply** (Object) - Required - Token supply configuration including baseDecimals, baseTotalSupply, baseForDistribution, and baseForLiquidity.
- **curve** (Object) - Required - Curve configuration including curveVirtualBase, curveVirtualQuote, and swapFeeBps.
- **dynamicFee** (DynamicFeeScheduleArgs | null) - Optional - Fee schedule for dynamic fees.
- **cosigner** (AddressOrSigner) - Optional - Enables cosigner gating.
- **cosignGateExpiresAt** (bigint | number | null) - Optional - Expiration timestamp for cosigner gating.
- **migration** (Object) - Optional - Migration configuration including minRaiseQuote.
- **metadata** (Object | null) - Optional - Token metadata.
- **feeBeneficiaries** (Array) - Optional - List of beneficiaries with wallet and shareBps.

### Response
- **instruction** (Object) - The built on-chain instruction.
- **addresses** (Object) - Derived addresses for the launch.
```

--------------------------------

### GET /search/:query

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-usage.md

Searches for tokens by name, symbol, or address.

```APIDOC
## GET /search/:query

### Description
Searches for tokens by name, symbol, or address.

### Method
GET

### Endpoint
/search/:query

### Parameters
#### Path Parameters
- **query** (string) - Required - The search term (e.g., "MyToken", "MTK", or "0x...").

#### Query Parameters
- **chain_ids** (string) - Optional - A comma-separated list of chain IDs to filter the search (e.g., ?chain_ids=84532,130).

### Request Example
curl "http://localhost:42069/search/doppler?chain_ids=84532"
```

--------------------------------

### Create Launch with Dynamic Fees and Cosigning

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-reference.md

Build an initialize_launch instruction with both dynamic fee schedules and cosigner gating enabled.

```ts
const { instruction, addresses } = await createLaunch({
  deployment,
  launchAccounts: {
    baseMint,
    quoteMint,
    baseVault,
    quoteVault,
  },
  payer,
  authority: payer,
  supply: {
    baseDecimals: 6,
    baseTotalSupply: 1_000_000_000n * 10n ** 6n,
    baseForDistribution: 0n,
    baseForLiquidity: 0n,
  },
  curve: {
    curveVirtualBase: 1_000_000_000n * 10n ** 6n,
    curveVirtualQuote: 10n * 1_000_000_000n,
    swapFeeBps: 200,
  },
  dynamicFee: {
    startingTime: 0n,
    startFeeBps: 8_000,
    endFeeBps: 200,
    durationSeconds: 10n * 60n,
  },
  cosigner,
  cosignGateExpiresAt,
  migration: {
    minRaiseQuote: 50n * 1_000_000_000n,
  },
  metadata: null,
  feeBeneficiaries: [{ wallet: payer.address, shareBps: 10_000 }],
})
```

--------------------------------

### Get Multicurve PoolKey

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/quotes-and-swaps.md

Retrieve the pool state and extract the PoolKey for Multicurve and Multicurve Rehype pools.

```ts
const pool = await sdk.getMulticurvePool(assetAddress)
const poolState = await pool.getState()

const poolKey = poolState.poolKey
```

--------------------------------

### Get Multicurve Sell Input Currency

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/quotes-and-swaps.md

Set the input currency address to the Doppler asset for a sell operation.

```ts
const currencyInAddress = poolState.asset
```

--------------------------------

### Get Multicurve Buy Input Currency

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/quotes-and-swaps.md

Set the input currency address to the pool's numeraire for a buy operation.

```ts
const currencyInAddress = poolState.numeraire
```

--------------------------------

### Set up the Doppler SDK

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/quotes-and-swaps.md

Initialize the Doppler SDK with a public client and retrieve the chain-specific addresses.

```ts
import {
  DopplerSDK,
  getAddresses,
} from '@whetstone-research/doppler-sdk/evm'
import { createPublicClient, http } from 'viem'
import { base } from 'viem/chains'

const publicClient = createPublicClient({
  chain: base,
  transport: http(rpcUrl),
})

const sdk = new DopplerSDK({
  publicClient,
  chainId: base.id,
})

const addresses = getAddresses(base.id)
```

--------------------------------

### Configure Static Auction with Raw Ticks

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/examples/static-auctions.md

Configures a static auction using explicit start and end ticks for the pool.

```typescript
const params = sdk.buildStaticAuction()
  .tokenConfig({
    name: 'My Token',
    symbol: 'MTK',
    tokenURI: 'https://example.com/token-metadata.json',
  })
  .saleConfig({
    initialSupply: parseEther('1000000000'),
    numTokensToSell: parseEther('900000000'),
    numeraire: '0x4200000000000000000000000000000000000006',
  })
  .poolByTicks({ startTick: 175000, endTick: 225000, fee: 10000 })
  .withGovernance({ type: 'noOp' })
  .withMigration({ type: 'uniswapV2' })
  .withUserAddress(account.address)
  .build();
```

--------------------------------

### Initialize and execute a launch

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/svm-sdk-examples/launch.md

This snippet demonstrates how to create an initialization instruction for a launch, send the transaction, and log the resulting account information.

```typescript
  const initializeLaunchIx =
    await initializer.createInitializeLaunchInstruction(
      {
        config: deployment.initializerConfig,
        launch,
        launchAuthority,
        baseMint,
        quoteMint: WSOL_MINT,
        baseVault,
        quoteVault,
        launchFeeState,
        payer,
        authority: payer,
        hookProgram: deployment.cpmmHookProgram,
        migratorProgram: deployment.cpmmMigratorProgram,
        cpmmConfig: migrationAccounts.cpmmConfig,
        baseTokenProgram: TOKEN_PROGRAM_ADDRESS,
        quoteTokenProgram: TOKEN_PROGRAM_ADDRESS,
        systemProgram: SYSTEM_PROGRAM_ADDRESS,
        rent: SYSVAR_RENT_ADDRESS,
      },
      {
        namespace,
        launchId,
        baseDecimals: BASE_DECIMALS,
        baseTotalSupply: BASE_TOTAL_SUPPLY,
        baseForDistribution: 0n,
        baseForLiquidity: 0n,
        curveVirtualBase: start.curveVirtualBase,
        curveVirtualQuote: start.curveVirtualQuote,
        swapFeeBps: SWAP_FEE_BPS,
        curveKind: initializer.CURVE_KIND_XYK,
        curveParams: new Uint8Array([initializer.CURVE_PARAMS_FORMAT_XYK_V0]),
        allowBuy: true,
        allowSell: true,
        hookFlags: initializer.HF_BEFORE_SWAP,
        hookPayload: new Uint8Array(),
        hookCreateRemainingAccountsLen: 0,
        hookCreateRemainingAccountsHash: new Uint8Array(32),
        migratorInitPayload,
        migratorMigratePayload,
        hookRemainingAccountsHash:
          initializer.computeRemainingAccountsHash([namespace]),
        migratorInitRemainingAccountsHash:
          initializer.computeRemainingAccountsHash([
            migrationAccounts.cpmmMigrationState,
            migrationAccounts.cpmmConfig,
          ]),
        migratorRemainingAccountsHash: migrationAccounts.hash,
        feeBeneficiaries: [{ wallet: payer.address, shareBps: 10_000 }],
        metadataName: '',
        metadataSymbol: '',
        metadataUri: '',
      },
      deployment.initializerProgram,
    );

  const signature = await send([initializeLaunchIx]);
  const launchAccount = await initializer.fetchLaunch(rpc, launch, {
    programId: deployment.initializerProgram,
  });

  console.log('Launch created:', launch);
  console.log('Base mint:', baseMint.address);
  console.log('Transaction:', signature);
  console.log(
    'Phase:',
    launchAccount && initializer.phaseLabel(launchAccount.phase),
  );
}

main();
```

--------------------------------

### GraphQL Query: Get recent swaps for a pool

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-usage.md

Retrieves the 10 most recent swaps for a specific pool address, ordered by timestamp.

```graphql
query RecentSwaps {
  swaps(
    where: { pool: "0x..." }
    orderBy: "timestamp"
    orderDirection: "desc"
    limit: 10
  ) {
    items {
      txHash
      timestamp
      type
      amountIn
      amountOut
      swapValueUsd
    }
  }
}
```

--------------------------------

### Launch assets on Solana with Doppler SDK

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/svm-sdk-examples/launch.md

This script demonstrates how to initialize a launch, configure CPMM migration parameters, and prepare transaction payloads using the Doppler SDK. It requires the SOLANA_KEYPAIR environment variable to be set as a JSON array of 64 bytes.

```typescript
import {
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
  type Address,
  type Instruction,
} from '@solana/kit';
import {
  TOKEN_PROGRAM_ADDRESS,
  findAssociatedTokenPda,
} from '@solana-program/token';
import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
import {
  cpmm,
  cpmmMigrator,
  initializer,
  deriveSolanaCpmmDeployment,
  DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES,
} from '@whetstone-research/doppler-sdk/solana';

const keypairJson = process.env.SOLANA_KEYPAIR;
const rpcUrl = process.env.SOLANA_RPC_URL ?? 'https://api.devnet.solana.com';
const wsUrl = process.env.SOLANA_WS_URL ?? 'wss://api.devnet.solana.com';

if (!keypairJson) {
  throw new Error('SOLANA_KEYPAIR must be set (JSON array of 64 bytes)');
}

const WSOL_MINT: Address =
  'So11111111111111111111111111111111111111112' as Address;

async function getSolPriceUsd(): Promise<number> {
  const response = await fetch(
    'https://api.coingecko.com/api/v3/simple/price?ids=solana&vs_currencies=usd',
  );
  const data = await response.json();
  return data.solana.usd;
}

async function main() {
  const payer = await createKeyPairSignerFromBytes(
    new Uint8Array(JSON.parse(keypairJson as string)),
  );
  const rpc = createSolanaRpc(rpcUrl);
  const rpcSubscriptions = createSolanaRpcSubscriptions(wsUrl);
  const deployment = await deriveSolanaCpmmDeployment(
    DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES,
  );
  const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
    rpc,
    rpcSubscriptions,
  });

  async function send(instructions: Instruction[]) {
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
    const message = pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(payer, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      (tx) => appendTransactionMessageInstructions(instructions, tx),
    );
    const signedTransaction = await signTransactionMessageWithSigners(message);
    await sendAndConfirmTransaction(
      signedTransaction as Parameters<typeof sendAndConfirmTransaction>[0],
      { commitment: 'confirmed' },
    );
    return getSignatureFromTransaction(signedTransaction);
  }

  const BASE_DECIMALS = 6;
  const BASE_TOTAL_SUPPLY = 1_000_000_000n * 10n ** BigInt(BASE_DECIMALS);
  const MIN_RAISE_QUOTE = 50n * 1_000_000_000n;
  const SWAP_FEE_BPS = 200;

  const { start } = cpmm.marketCapToCurveParams({
    startMarketCapUSD: 100_000,
    endMarketCapUSD: 10_000_000,
    baseTotalSupply: BASE_TOTAL_SUPPLY,
    baseForCurve: BASE_TOTAL_SUPPLY,
    baseDecimals: BASE_DECIMALS,
    quoteDecimals: 9,
    numerairePriceUSD: await getSolPriceUsd(),
  });

  const baseMint = await generateKeyPairSigner();
  const baseVault = await generateKeyPairSigner();
  const quoteVault = await generateKeyPairSigner();

  const namespace = payer.address;
  const launchId = initializer.launchIdFromU64(BigInt(Date.now()));
  const [launch] = await initializer.getLaunchAddress(
    namespace,
    launchId,
    deployment.initializerProgram,
  );
  const [launchAuthority] = await initializer.getLaunchAuthorityAddress(
    launch,
    deployment.initializerProgram,
  );
  const [launchFeeState] = await initializer.getLaunchFeeStateAddress(
    launch,
    deployment.initializerProgram,
  );
  const [adminBaseAta] = await findAssociatedTokenPda({
    owner: payer.address,
    mint: baseMint.address,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  });
  const [adminQuoteAta] = await findAssociatedTokenPda({
    owner: payer.address,
    mint: WSOL_MINT,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  });

  const migrationAccounts =
    await cpmmMigrator.buildCpmmMigrationRemainingAccounts({
      launch,
      baseMint: baseMint.address,
      quoteMint: WSOL_MINT,
      launchAuthority,
      adminBaseAta,
      adminQuoteAta,
      recipientAtas: [],
      cpmmProgram: deployment.cpmmProgram,
      cpmmMigratorProgram: deployment.cpmmMigratorProgram,
    });

  const migratorInitPayload = cpmmMigrator.encodeRegisterLaunchPayload({
    cpmmConfig: migrationAccounts.cpmmConfig,
    initialSwapFeeBps: SWAP_FEE_BPS,
    initialFeeSplitBps: 10_000,
    recipients: [],
    minRaiseQuote: MIN_RAISE_QUOTE,
    minMigrationPriceQ64Opt: null,
    migratedPoolHookConfig: null,
  });
  const migratorMigratePayload = cpmmMigrator.encodeMigratePayload({
    baseForDistribution: 0n,
    baseForLiquidity: 0n,
  });
```

--------------------------------

### Get Dynamic Auction PoolKey

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/quotes-and-swaps.md

Retrieve the PoolKey from a Dynamic auction hook using the SDK's read contract and normalization utilities.

```ts
import {
  dopplerHookAbi,
  normalizePoolKey,
} from '@whetstone-research/doppler-sdk/evm'

const storedPoolKey = await publicClient.readContract({
  address: hookAddress,
  abi: dopplerHookAbi,
  functionName: 'poolKey',
})

const poolKey = normalizePoolKey(storedPoolKey)
```

--------------------------------

### Example token created on Zora

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/metadata-standards.md

A JSON representation of a token created on Zora, including the name, ticker, image, and content URI fields.

```json
{
  "name": "balajis",
  "ticker": "balajis",
  "image": "ipfs://bafybeibeeqdppfm2iizeaqiobdvn533xyuunjpdspdirju7xf4ykwyindq",
  "content": {
    "uri": "ipfs://bafybeibeeqdppfm2iizeaqiobdvn533xyuunjpdspdirju7xf4ykwyindq"
  }
}
```

--------------------------------

### Initialize and configure Doppler Solana launch

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/svm-sdk-examples/launch-monitor-and-e2e.md

This script sets up the environment, derives deployment addresses, and prepares the necessary accounts and parameters for a token launch and subsequent migration.

```typescript
import {
  AccountRole,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  getBase64EncodedWireTransaction,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  sendAndConfirmTransactionFactory,
  getSignatureFromTransaction,
  type Address,
  type Instruction,
} from '@solana/kit';
import {
  TOKEN_PROGRAM_ADDRESS,
  findAssociatedTokenPda,
  getCreateAssociatedTokenIdempotentInstruction,
} from '@solana-program/token';
import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
import { SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
import {
  cpmm,
  cpmmMigrator,
  initializer,
  deriveSolanaCpmmDeployment,
  DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES,
} from '@whetstone-research/doppler-sdk/solana';

const keypairJson = process.env.SOLANA_KEYPAIR;
const rpcUrl = process.env.SOLANA_RPC_URL ?? 'https://api.devnet.solana.com';
const wsUrl = process.env.SOLANA_WS_URL ?? 'wss://api.devnet.solana.com';

if (!keypairJson) {
  throw new Error('SOLANA_KEYPAIR must be set (JSON array of 64 bytes)');
}

const USDC_MINT: Address =
  '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU' as Address;

async function main() {
  const payer = await createKeyPairSignerFromBytes(
    new Uint8Array(JSON.parse(keypairJson as string)),
  );
  const rpc = createSolanaRpc(rpcUrl);
  const rpcSubscriptions = createSolanaRpcSubscriptions(wsUrl);
  const deployment = await deriveSolanaCpmmDeployment(
    DOPPLER_SOLANA_DEVNET_PROGRAM_ADDRESSES,
  );
  const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
    rpc,
    rpcSubscriptions,
  });

  async function send(instructions: Instruction[]) {
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
    const message = pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(payer, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      (tx) => appendTransactionMessageInstructions(instructions, tx),
    );
    const signedTransaction = await signTransactionMessageWithSigners(message);
    await sendAndConfirmTransaction(
      signedTransaction as Parameters<typeof sendAndConfirmTransaction>[0],
      { commitment: 'confirmed' },
    );
    return getSignatureFromTransaction(signedTransaction);
  }

  const BASE_DECIMALS = 6;
  const BASE_TOTAL_SUPPLY = 1_000_000_000n * 10n ** BigInt(BASE_DECIMALS);
  const MIN_RAISE_QUOTE = 100_000n;
  const BUY_AMOUNT_IN = 200_000n;
  const SWAP_FEE_BPS = 200;

  const { start } = cpmm.marketCapToCurveParams({
    startMarketCapUSD: 100_000,
    endMarketCapUSD: 10_000_000,
    baseTotalSupply: BASE_TOTAL_SUPPLY,
    baseForCurve: BASE_TOTAL_SUPPLY,
    baseDecimals: BASE_DECIMALS,
    quoteDecimals: 6,
    numerairePriceUSD: 1,
  });

  const baseMint = await generateKeyPairSigner();
  const baseVault = await generateKeyPairSigner();
  const quoteVault = await generateKeyPairSigner();

  const namespace = payer.address;
  const withDynamicHookAccounts = (instruction: Instruction): Instruction => ({
    ...instruction,
    accounts: [
      ...(instruction.accounts ?? []),
      { address: namespace, role: AccountRole.READONLY },
    ],
  });
  const launchId = initializer.launchIdFromU64(BigInt(Date.now()));
  const [launch] = await initializer.getLaunchAddress(
    namespace,
    launchId,
    deployment.initializerProgram,
  );
  const [launchAuthority] = await initializer.getLaunchAuthorityAddress(
    launch,
    deployment.initializerProgram,
  );
  const [launchFeeState] = await initializer.getLaunchFeeStateAddress(
    launch,
    deployment.initializerProgram,
  );
  const [payerBaseAta] = await findAssociatedTokenPda({
    owner: payer.address,
    mint: baseMint.address,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  });
  const [payerQuoteAta] = await findAssociatedTokenPda({
    owner: payer.address,
    mint: USDC_MINT,
    tokenProgram: TOKEN_PROGRAM_ADDRESS,
  });

  const migrationAccounts =
    await cpmmMigrator.buildCpmmMigrationRemainingAccounts({
      launch,
      baseMint: baseMint.address,
      quoteMint: USDC_MINT,
      launchAuthority,
      adminBaseAta: payerBaseAta,
      adminQuoteAta: payerQuoteAta,
      recipientAtas: [],
      cpmmProgram: deployment.cpmmProgram,
      cpmmMigratorProgram: deployment.cpmmMigratorProgram,
    });
```

--------------------------------

### Initialize DopplerSDK

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-reference.md

The top-level entry point for all EVM SDK operations. Requires a viem PublicClient and optionally a WalletClient for write operations.

```ts
import { DopplerSDK } from '@whetstone-research/doppler-sdk'

const sdk = new DopplerSDK({
  publicClient,   // viem PublicClient
  walletClient,   // viem WalletClient (optional for read-only)
  chainId,        // SupportedChainId
})
```

--------------------------------

### REST API: Search tokens

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-usage.md

Examples of using the search endpoint to find tokens by name or contract address, filtered by chain IDs.

```bash
# Search for "doppler" token on Base Sepolia (chain ID 84532)
curl "http://localhost:42069/search/doppler?chain_ids=84532"

# Search by contract address on Base Sepolia and Ink
curl "http://localhost:42069/search/0x123...abc?chain_ids=84532,57073"
```

--------------------------------

### DopplerSDK Initialization

Source: https://github.com/whetstoneresearch/doppler-docs/blob/main/reference/api-reference.md

The top-level entry point for all EVM SDK operations. Import from @whetstone-research/doppler-sdk.

```APIDOC
## DopplerSDK Initialization

### Description
Initializes the DopplerSDK instance with the required viem clients and chain configuration.

### Signature
`new DopplerSDK({ publicClient, walletClient, chainId })`

### Parameters
- **publicClient** (viem PublicClient) - Required - The viem public client for read operations.
- **walletClient** (viem WalletClient) - Optional - The viem wallet client for write operations.
- **chainId** (SupportedChainId) - Required - The ID of the supported chain.
```
Tokens:
Raw