Doppler

https://docs.doppler.lol/
Admin
Doppler is an EVM-based token launchpad and liquidity bootstrapping protocol supporting static and...
Tokens:57,572
Snippets:179
Trust Score:5.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Quick Example: Launching Token with Doppler V4 SDK

Source: https://docs.doppler.lol/v4-sdk/custom-fees

A concise example demonstrating the setup of beneficiaries, creation of V4 migrator configuration, and launching a token with optional no-op governance using the Doppler V4 SDK.

```typescript
import { 
  ReadWriteFactory, 
  BeneficiaryData, 
  V4MigratorData,
  DEAD_ADDRESS
} from 'doppler-v4-sdk';

const beneficiaries: BeneficiaryData[] = [
  { beneficiary: protocolAddress, shares: BigInt(0.1e18) }, // 10%
  { beneficiary: teamAddress, shares: BigInt(0.9e18) }, // 90%
];

const v4Config: V4MigratorData = {
  fee: 3000,
  tickSpacing: 60,
  lockDuration: 180 * 24 * 60 * 60, // 180 days
  beneficiaries: factory.sortBeneficiaries(beneficiaries),
};

const config = await factory.buildConfig({
  // ... token parameters
  liquidityMigratorData: factory.encodeV4MigratorData(v4Config),
}, addresses, {
  useGovernance: false // For no-op governance
});

const tx = await factory.create(config.createParams);
```

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

### Install Doppler V3 SDK

Source: https://docs.doppler.lol/v3-sdk/getting-started

Installs the Doppler V3 SDK, Viem, and Drift packages using npm or yarn.

```bash
npminstalldoppler-v3-sdkviem@delvtech/drift@delvtech/drift-viem
# or
yarnadddoppler-v3-sdkviem@delvtech/drift@delvtech/drift-viem
```

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

### Install Doppler Indexer Dependencies

Source: https://docs.doppler.lol/indexer/getting-started

Clones the Doppler v3 indexer repository and installs its dependencies using pnpm.

```bash
git clone <repository_url>
cd doppler-v3-indexer
pnpm install
```

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

### Install Doppler V4 SDK and Dependencies

Source: https://docs.doppler.lol/v4-sdk/getting-started

Installs the Doppler V4 SDK, Viem, and Drift packages using either npm or yarn.

```bash
npminstalldoppler-v4-sdkviem@delvtech/drift@delvtech/drift-viem
```

```bash
yarnadddoppler-v4-sdkviem@delvtech/drift@delvtech/drift-viem
```

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

### Multi-Beneficiary Setup Example

Source: https://docs.doppler.lol/v3-sdk/custom-fees

An example demonstrating how to set up multiple beneficiaries with their respective shares for fee distribution in a Doppler V4 pool. It includes defining beneficiary data and creating a V4 migrator configuration with a specified lock duration.

```javascript
// Example: Protocol with multiple stakeholders
const beneficiaries: BeneficiaryData[] = [
  {
    beneficiary: "0x123...", // DAO Treasury
    shares: WAD * 40n / 100n // 40%
  },
  {
    beneficiary: "0x456...", // Core Team
    shares: WAD * 25n / 100n // 25%
  },
  {
    beneficiary: "0x789...", // Ecosystem Fund
    shares: WAD * 20n / 100n // 20%
  },
  {
    beneficiary: "0xabc...", // Bug Bounty Reserve
    shares: WAD * 10n / 100n // 10%
  },
  {
    beneficiary: "0xdef...", // Community Incentives
    shares: WAD * 5n / 100n  // 5%
  }
];
// Create configuration with 2-year lock
const config: V4MigratorData = {
  fee: 10000,              // 1% fee for exotic pair
  tickSpacing: 200,        // Corresponding tick spacing
  lockDuration: 2 * 365 * 24 * 60 * 60, // 2 years
  beneficiaries: factory.sortBeneficiaries(beneficiaries)
};
```

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

### Doppler SDK Example Usage

Source: https://docs.doppler.lol/v4-sdk/factory

An example demonstrating how to use the Doppler SDK to create a new pool. It includes building the configuration, simulating the creation, and executing the creation transaction.

```javascript
import { ReadWriteFactory } from "doppler-v4-sdk";
// Create factory instance
const factory = new ReadWriteFactory(airlockAddress, drift);
// Build complete configuration
const { createParams, hook, token } = factory.buildConfig(
  {
    name: "MyToken",
    symbol: "MYT",
    totalSupply: parseEther("1000000000"), // 1b tokens
    numTokensToSell: parseEther("600000000"), // 600m tokens
    tokenURI: "some_ipfs_cid",
    blockTimestamp: Math.floor(Date.now() / 1000),
    startTimeOffset: 1,
    duration: 1 / 4, // 6 hour duration, must be divisible by epochLength
    epochLength: 200, // 200 seconds
    gamma: 800,
    tickRange: {
      startTick: 174_312,
      endTick: 186_840,
    },
    tickSpacing: 2,
    fee: 20_000, // 2% 
    minProceeds: parseEther("2"),
    maxProceeds: parseEther("4"),
    yearlyMintRate: 0n,
    vestingDuration: BigInt(24 * 60 * 60 * 365),
    recipients: [someRecipientAddress],
    amounts: [parseEther("50000000")], // 5% of totalSupply
    numPdSlugs: 15,
    integrator: yourIntegratorAddress,
  },
  addresses
);
// Simulate creation to estimate gas
const simulation = await factory.simulateCreate(createParams);
console.log(`Estimated gas: ${simulation.request.gas}`);
// Create the pool
const txHash = await factory.create(createParams, {
  gasLimit: 5000000n,
});
// Later, migrate liquidity after price discovery ends
const migrationTx = await factory.migrate(token);
```

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

### Run Doppler Indexer Database and Server

Source: https://docs.doppler.lol/indexer/getting-started

Starts the PostgreSQL database using Docker Compose and then runs the Doppler indexer development server.

```bash
docker-compose up -d doppler-indexer-database
pnpm dev
```

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

### Example Usage (TypeScript)

Source: https://docs.doppler.lol/v3-sdk/quoter

Demonstrates how to instantiate the ReadQuoter class and use its methods to get price quotes for both V3 and V2 exact input/output swaps, including example parameters.

```TypeScript
const quoter = new ReadQuoter("0xQuoterV2Address", "0xUniV2RouterAddress");
// V3 Exact Input Quote
const v3InputQuote = await quoter.quoteExactInputV3({
  tokenIn: "0x...",
  tokenOut: "0x...",
  amountIn: 1000000n,
  fee: 3000,
  sqrtPriceLimitX96: 0n,
});
// V2 Exact Output Quote
const v2OutputQuote = await quoter.quoteExactOutputV2({
  amountOut: 500000n,
  path: ["0x...", "0x..."],
  to: "0x...",
  deadline: Math.floor(Date.now() / 1000) + 300,
});
```

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

### Doppler V4 SDK Setup and Initialization

Source: https://docs.doppler.lol/v4-sdk/examples

This snippet demonstrates how to set up clients and initialize the Doppler V4 SDK for use with custom fees and governance. It covers importing necessary modules, configuring viem clients, setting up Drift, and initializing the factory with Doppler V4 addresses.

```typescript
import {
  ReadWriteFactory,
  BeneficiaryData,
  V4MigratorData,
  DEAD_ADDRESS,
  DOPPLER_V4_ADDRESSES
} from'doppler-v4-sdk';
import { createPublicClient, createWalletClient, http, parseEther } from'viem';
import { base } from'viem/chains';
import { Drift } from'@delvtech/drift';
import { viemAdapter } from'@delvtech/drift-viem';

// Setup clients
const publicClient = createPublicClient({
  chain: base,
  transport: http()
});

const walletClient = createWalletClient({
  chain: base,
  transport: http(),
  account: privateKeyToAccount('0x...') // Your private key
});

// Setup Drift
import { createDrift } from'@delvtech/drift';
const drift = createDrift({ adapter: viemAdapter({ publicClient, walletClient }) });

// Get addresses for your chain
const addresses = DOPPLER_V4_ADDRESSES[base.id];

// Initialize factory
const factory = new ReadWriteFactory(addresses.airlock, drift);
```

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

### ReadFactory Example Usage

Source: https://docs.doppler.lol/v4-sdk/factory

Example demonstrating how to use the ReadFactory to check module states and retrieve asset data.

```javascript
import { ReadFactory, ModuleState } from "doppler-v4-sdk";
// Create factory instance
const factory = new ReadFactory(airlockAddress);
// Check module state
const state = await factory.getModuleState(moduleAddress);
if (state === ModuleState.TokenFactory) {
  console.log("Module is a valid token factory");
}
// Get asset information
const assetData = await factory.getAssetData(tokenAddress);
console.log("Asset details:", {
  numeraire: assetData.numeraire,
  governance: assetData.governance,
  pool: assetData.pool,
  migrationPool: assetData.migrationPool,
  totalSupply: assetData.totalSupply.toString(),
  tokensForSale: assetData.numTokensToSell.toString(),
});
```

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

### Read Protocol Data Example

Source: https://docs.doppler.lol/v3-sdk/getting-started

Demonstrates how to use the ReadFactory to query protocol state and retrieve asset data.

```javascript
// Create a read factory instance
const factory = new ReadFactory(
  airlockAddress,
  drift,
);
// Get information about a deployed asset
const assetData = await factory.getAssetData(tokenAddress);
console.log('Asset details:', {
  numeraire: assetData.numeraire,
  governance: assetData.governance,
  pool: assetData.pool,
  totalSupply: assetData.totalSupply.toString()
});
// Check module state
const moduleState = await factory.getModuleState(moduleAddress);
console.log('Module state:', moduleState);
```

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

### Create Streamable V3 Pool - TypeScript SDK

Source: https://docs.doppler.lol/v3-sdk/streamable-v3

Example demonstrating how to create a Uniswap V3 pool with streamable fees using the Doppler V3 SDK. It covers wallet setup, factory configuration, beneficiary sorting, and pool creation parameters.

```TypeScript
import { parseEther } from 'viem';
import { ReadWriteFactory, DOPPLER_V3_ADDRESSES } from '@doppler-v3-sdk';
// Set up wallet (use your preferred method - WalletConnect, injected, etc.)
const walletClient = createWalletClient({
  // ... your wallet configuration
});
// Set up factory
const chainId = 8453; // Base mainnet
const factory = new ReadWriteFactory(
  DOPPLER_V3_ADDRESSES[chainId].airlock,
  DOPPLER_V3_ADDRESSES[chainId].bundler,
  drift // your configured drift instance
);
// Get the Airlock owner address
const airlockOwner = await factory.owner();
// Configure beneficiaries
const beneficiaries = [
  {
    beneficiary: airlockOwner,
    shares: parseEther("0.05")  // 5% protocol fee (required)
  },
  {
    beneficiary: "0xProjectTreasury...",
    shares: parseEther("0.50")  // 50% to project treasury
  },
  {
    beneficiary: "0xDevelopmentFund...",
    shares: parseEther("0.30")  // 30% to development
  },
  {
    beneficiary: "0xCommunityRewards...",
    shares: parseEther("0.15")  // 15% to community
  }
];
// Sort beneficiaries (required)
const sortedBeneficiaries = factory.sortBeneficiaries(beneficiaries);
// Create pool with streamable fees
const params = {
  // ... other parameters
  contracts: {
    tokenFactory: DOPPLER_V3_ADDRESSES[chainId].tokenFactory,
    governanceFactory: DOPPLER_V3_ADDRESSES[chainId].governanceFactory,
    v3Initializer: DOPPLER_V3_ADDRESSES[chainId].lockableV3Initializer, // Use lockable initializer
    liquidityMigrator: DOPPLER_V3_ADDRESSES[chainId].liquidityMigrator,
  },
  v3PoolConfig: {
    // ... standard config
    beneficiaries: sortedBeneficiaries // Add beneficiaries for streamable fees
  }
};
// Encode and create the pool
const { createParams } = factory.encode(params);
const txHash = await factory.create(createParams);
```

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

### Doppler V4 SDK Quoter Example Usage

Source: https://docs.doppler.lol/v4-sdk/quoter

Demonstrates how to instantiate the ReadQuoter and use its methods to get price quotes for exact input and output swaps on Uniswap V4.

```TypeScript
import { ReadQuoter } from "doppler-v4-sdk";

// Create quoter instance
const quoter = new ReadQuoter("0x...");

// Get quote for exact input
const inputQuote = await quoter.quoteExactInputV4({
  tokenIn: "0x...",
  tokenOut: "0x...",
  amountIn: 1000000n,
  fee: 3000,
  sqrtPriceLimitX96: 0n,
});

// Get quote for exact output
const outputQuote = await quoter.quoteExactOutputV4({
  tokenIn: "0x...",
  tokenOut: "0x...",
  amountOut: 1000000n,
  fee: 3000,
  sqrtPriceLimitX96: 0n,
});
```

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

### Distribute and Claim Fees with StreamableFeesLocker

Source: https://docs.doppler.lol/v4-sdk/examples

This example shows how to interact with the StreamableFeesLocker after launching a token. It covers distributing fees, checking the claimable balance for a beneficiary, and a beneficiary claiming their fees.

```typescript
async function distributeAndClaimFees(tokenId: bigint) {
  // 1. Anyone can distribute fees
  const distributeTx = await walletClient.writeContract({
    address: addresses.streamableFeesLocker,
    abi: streamableFeesLockerAbi,
    functionName: 'distributeFees',
    args: [tokenId]
  });
  
  console.log("Fees distributed:", distributeTx);
  
  // 2. Check claimable balance for a beneficiary
  const claimable = await publicClient.readContract({
    address: addresses.streamableFeesLocker,
    abi: streamableFeesLockerAbi,
    functionName: 'beneficiariesClaims',
    args: [beneficiaryAddress, currencyAddress]
  });
  
  console.log("Claimable amount:", claimable);
  
  // 3. Beneficiary claims fees
  const claimTx = await walletClient.writeContract({
    address: addresses.streamableFeesLocker,
    abi: streamableFeesLockerAbi,
    functionName: 'releaseFees',
    args: [tokenId]
  });
  
  console.log("Fees claimed:", claimTx);
}
```

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

### Launch Token with Custom Quote Token (USDC)

Source: https://docs.doppler.lol/v4-sdk/examples

This example demonstrates how to launch a token using a custom quote token, such as USDC, instead of ETH. It covers setting up beneficiaries, configuring the V4 migrator, and building the launch configuration with specific parameters for price range, proceeds, and other sale details.

```typescript
async function launchTokenCustomQuote() {
  const usdcAddress = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'; // USDC on mainnet
  
  // 1. Set up beneficiaries
  const beneficiaries: BeneficiaryData[] = [
    {
      beneficiary: addresses.airlock,
      shares: BigInt(0.1e18), // 10% to protocol
    },
    {
      beneficiary: '0xTREASURY...',
      shares: BigInt(0.9e18), // 90% to treasury
    }
  ];
  
  const sortedBeneficiaries = factory.sortBeneficiaries(beneficiaries);
  
  // 2. Configure V4 migrator
  const v4Config: V4MigratorData = {
    fee: 500, // 0.05% for stable pairs
    tickSpacing: 10, // Tight spacing for stables
    lockDuration: 90 * 24 * 60 * 60, // 90 days
    beneficiaries: sortedBeneficiaries
  };
  
  const liquidityMigratorData = factory.encodeV4MigratorData(v4Config);
  
  // 3. Build configuration with USDC as quote
  const { createParams, hook, token } = await factory.buildConfig({
    name: "Stable Token",
    symbol: "STBL",
    totalSupply: parseEther("100000000"), // 100M tokens
    numTokensToSell: parseEther("50000000"), // 50M for sale
    tokenURI: "",
    
    blockTimestamp: Math.floor(Date.now() / 1000),
    startTimeOffset: 2, // Start in 2 days (NOTE: Currently not used by SDK - uses fixed 30 second offset)
    duration: 7, // 7 day sale
    epochLength: 7200, // 2 hour epochs
    
    // IMPORTANT: Use numeraire for custom quote token
    numeraire: usdcAddress,
    
    // Price in USDC (6 decimals)
    priceRange: { 
      startPrice: 0.1,  // $0.10
      endPrice: 1.0     // $1.00
    },
    tickSpacing: 10,
    fee: 500,
    
    // Proceeds in USDC (6 decimals)
    minProceeds: BigInt(100000 * 1e6), // 100k USDC
    maxProceeds: BigInt(10000000 * 1e6), // 10M USDC
    
    yearlyMintRate: BigInt(0),
    vestingDuration: BigInt(0),
    recipients: [],
    amounts: [],
    
    liquidityMigratorData: liquidityMigratorData,
    integrator: '0x123...',
  }, addresses);
  
  console.log("Token paired with USDC:", usdcAddress);
  
  const tx = await factory.create(createParams);
  return { token, hook, tx };
}
```

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

### Error Handling Example

Source: https://docs.doppler.lol/v3-sdk/getting-started

Illustrates how to implement error handling when interacting with the Doppler SDK, specifically when fetching asset data. It shows a try-catch block to manage potential errors, distinguishing between 'Asset not found' and other unexpected errors.

```javascript
try {
  const assetData = await factory.getAssetData(tokenAddress);
} catch (error) {
  if (error.message.includes('Asset not found')) {
    console.log('Token not deployed on Doppler');
  } else {
    console.error('Unexpected error:', error);
  }
}
```

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

### Implement No-Op Governance with Doppler V3 SDK

Source: https://docs.doppler.lol/v3-sdk/governance-options

Demonstrates how to configure token creation using the NoOpGovernanceFactory in the Doppler V3 SDK for gas-efficient deployments. It includes prerequisites, implementation steps, and code examples for setting up parameters and creating the token.

```typescript
import { ReadWriteFactory, CreateV3PoolParams } from'doppler-v3-sdk';
import { DOPPLER_V3_ADDRESSES } from'doppler-v3-sdk';
// Get addresses for your chain
constchainId=84532; // Base Sepolia
constaddresses=DOPPLER_V3_ADDRESSES[chainId];
// Check if NoOpGovernanceFactory is available
if (!addresses.noOpGovernanceFactory) {
thrownewError('NoOpGovernanceFactory not deployed on this chain');
}
// Create parameters with NoOpGovernanceFactory
constcreateParams:CreateV3PoolParams= {
  integrator:'0x...',// Your integrator address
  userAddress:'0x...',// User creating the token
  numeraire:'0x...',// Base token (e.g., WETH)
  contracts: {
    tokenFactory:addresses.tokenFactory,
// Use NoOpGovernanceFactory instead of standard governanceFactory
    governanceFactory:addresses.noOpGovernanceFactory,
    v3Initializer:addresses.v3Initializer,
    liquidityMigrator:addresses.liquidityMigrator,
  },
  tokenConfig: {
    name:'My Token',
    symbol:'MTK',
    tokenURI:'https://example.com/metadata.json',
  },
  vestingConfig:'default',
// Optional: Configure V4 migration
  liquidityMigratorData:'0x...',// See V4 migrator docs
};
// Create the factory instance
constfactory=newReadWriteFactory(addresses.airlock, driftClient);
// Encode and create the token
constcreateData=awaitfactory.encodeCreateData(createParams);
```

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

### Doppler v3 SDK

Source: https://docs.doppler.lol/index

Get started with the Doppler v3 SDK for static bonding curves. This SDK provides familiar interfaces for interacting with the onchain smart contracts.

```TypeScript
Get started with the Doppler v3 SDK for static bonding curves
```

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

### Doppler v4 SDK

Source: https://docs.doppler.lol/index

Get started with the Doppler v4 SDK for dynamic bonding curves. This SDK provides familiar interfaces for interacting with the onchain smart contracts.

```TypeScript
Get started with the Doppler v4 SDK for dynamic bonding curves
```

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

### Doppler Lens Quoter Example Usage

Source: https://docs.doppler.lol/v4-sdk/lens

Demonstrates how to instantiate the ReadDopplerLens, retrieve pool manager and state view addresses, and use quoteDopplerLensData to get current pool state.

```javascript
import { ReadDopplerLens } from "doppler-v4-sdk";
// Create lens instance
const lens = new ReadDopplerLens(lensAddress);
// Get pool manager and state view addresses
const poolManager = await lens.poolManager();
const stateView = await lens.stateView();
// Quote current pool state
const poolKey = {
  currency0: numeraireAddress,
  currency1: tokenAddress,
  fee: 20_000,
  tickSpacing: 2,
  hooks: dopplerHookAddress,
};
const quoteData = await lens.quoteDopplerLensData({
  poolKey,
  zeroForOne: true,
  exactAmount: 1, // Simulate swapping 1 wei
  hookData: "0x",
});
console.log("Current pool state:", {
  price: quoteData.sqrtPriceX96,
  tick: quoteData.tick,
  token0Amount: quoteData.amount0.toString(),
  token1Amount: quoteData.amount1.toString(),
});
```

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

### Initialize Drift Client (Read-write with Viem Adapter)

Source: https://docs.doppler.lol/v4-sdk/getting-started

Initializes a Drift client for read-write operations using Viem, including public and wallet clients.

```javascript
import { createDrift } from "@delvtech/drift";
import { createPublicClient, createWalletClient, http, PublicClient } from "viem";
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http('https://sepolia.base.org'),
});
const walletClient = createWalletClient({
  chain: baseSepolia,
  transport: http('https://sepolia.base.org'),
  account: privateKeyToAccount(WALLET_PRIVATE_KEY),
});
// For read-write operations (with wallet)
const driftWithWallet = createDrift({
  adapter: viemAdapter({ publicClient, walletClient }),
});
```

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

### Initialize Drift Client (Read-write)

Source: https://docs.doppler.lol/v3-sdk/getting-started

Initializes a read-write Drift client using Viem and a wallet client for signing transactions.

```javascript
import { createDrift } from "@delvtech/drift";
import { createPublicClient, createWalletClient, http, PublicClient } from "viem";
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http('https://sepolia.base.org'),
});
const walletClient = createWalletClient({
  chain: baseSepolia,
  transport: http('https://sepolia.base.org'),
  account: privateKeyToAccount(WALLET_PRIVATE_KEY),
});
// For read-write operations (with wallet)
const driftWithWallet = createDrift({
  adapter: viemAdapter({ publicClient, walletClient }),
});
```

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

### Create Token with Hooks

Source: https://docs.doppler.lol/v4-sdk/getting-started

Demonstrates how to create a new token using the Doppler V4 SDK, including defining pre-deployment configuration, simulating, and executing the creation transaction. It also shows how to retrieve the deployed token address from the transaction receipt.

```TypeScript
const addresses = DOPPLER_V4_ADDRESSES[chainId];
const airlockAddress = addresses.airlock;
const bundlerAddress = addresses.bundler;
const tokenURI = "https://example.com/token-metadata.json";
const integrator: Address = "0x...";
// Create a read-write factory instance
const factory = new ReadWriteFactory(
  airlockAddress,
  bundlerAddress,
  driftWithWallet
);
// Define pre-deployment configuration
const preDeploymentConfig: DopplerPreDeploymentConfig = {
  name: tokenName,
  symbol: tokenSymbol,
  totalSupply: parseEther('1_000_000_000'),
  numTokensToSell: parseEther('600_000_000'),
  tokenURI,
  blockTimestamp: Math.floor(Date.now() / 1000),
  startTimeOffset: 1,
  duration: 1 / 4,
  epochLength: 200,
  gamma: 800,
  tickRange: {
    startTick: 174_312,
    endTick: 186_840,
  },
  tickSpacing: 2,
  fee: 20_000, // 2%
  minProceeds: parseEther('2'),
  maxProceeds: parseEther('4'),
  yearlyMintRate: 0n,
  vestingDuration: BigInt(24 * 60 * 60 * 365), // Seconds in a year
  recipients: [wallet.account.address],
  amounts: [parseEther('50_000_000')],
  numPdSlugs: 15,
  integrator,
};
// Build the complete configuration
const { createParams, hook, token } = factory.buildConfig(
  preDeploymentConfig,
  addresses
);
// Simulate the creation transaction
const simulation = await factory.simulateCreate(createParams);
console.log('Gas estimate:', simulation.gasEstimate);
// Execute the creation transaction
const txHash = await factory.create(createParams);
console.log('Transaction hash:', txHash);
// Wait for transaction confirmation and get the deployed asset address
const receipt = await drift.waitForTransactionReceipt({ hash: txHash });
const createEvent = receipt.logs.find(log => 
  log.topics[0] === '0x...' // Create event signature
);
const deployedTokenAddress = `0x${createEvent.topics[1].slice(26)}`;
console.log('Deployed token address:', deployedTokenAddress);
```

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

### Build Configuration with Doppler Factory

Source: https://docs.doppler.lol/v4-sdk

Demonstrates building a configuration for token deployment using Doppler's factory. It involves pre-deployment configuration, parameter building, and hook integration.

```javascript
const preDeploymentConfig: DopplerPreDeploymentConfig = { ... };
const { createParams, hook, token } = factory.buildConfig(
  preDeploymentConfig,
  addresses
);
```

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

### Configure Environment Variables

Source: https://docs.doppler.lol/v3-sdk/getting-started

Sets up required environment variables for the Doppler SDK, including RPC endpoint, private key, and chain ID.

```bash
# RPC Endpoint
RPC_URL="https://sepolia.base.org"
# Wallet Private Key (for automated transactions)
PRIVATE_KEY="your-private-key"
# Network Configuration
CHAIN_ID=84532
```

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

### REST API: Search Examples

Source: https://docs.doppler.lol/indexer/api-usage

Examples of using the REST API to search for tokens by name or contract address, with filtering by chain ID.

```Shell
# Search for "doppler" token on Base (chain ID 8453)
curl "http://localhost:42069/search/doppler?chain_ids=8453"
# Search by contract address on Base and Ink
curl "http://localhost:42069/search/0x123...abc?chain_ids=8453,57073"
```

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

### Required Environment Variables for Doppler V4 SDK

Source: https://docs.doppler.lol/v4-sdk/getting-started

Sets up essential environment variables for the Doppler V4 SDK, including the RPC endpoint, wallet private key, and chain ID.

```bash
# RPC Endpoint
RPC_URL="https://sepolia.base.org"
# Wallet Private Key (for automated transactions)
PRIVATE_KEY="your-private-key"
# Network Configuration
CHAIN_ID=84532
```

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

### Configure Doppler Indexer Environment Variables

Source: https://docs.doppler.lol/indexer/getting-started

Sets up the .env.local file with necessary RPC URLs for various networks and Pinata gateway details.

```shell
cp .env.example .env.local

# Mainnet (for ETH price oracle)
PONDER_RPC_URL_1="https://eth.drpc.org"
# Base
PONDER_RPC_URL_8453="https://base.drpc.org"
# Unichain
PONDER_RPC_URL_130="<your_unichain_rpc_url>"
# Ink
PONDER_RPC_URL_57073="<your_ink_rpc_url>"
# Base Sepolia (Testnet)
PONDER_RPC_URL_84532="https://sepolia.base.org"
# Pinata Gateway (for fetching token metadata)
PINATA_GATEWAY_URL="<your_pinata_gateway_url>"
PINATA_GATEWAY_KEY="<your_pinata_gateway_key>"
```

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

### Get Protocol Addresses

Source: https://docs.doppler.lol/v3-sdk/getting-started

Retrieves protocol addresses for a given chain ID, including the Airlock address.

```javascript
// Get addresses for the current network
const chainId = 84532; // Base Sepolia (change to 8453 for Base Mainnet, 130 for Unichain Mainnet, etc.)
const addresses = DOPPLER_V3_ADDRESSES[chainId];
const airlockAddress = addresses.airlock;
```

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

### Create a New Token

Source: https://docs.doppler.lol/v3-sdk/getting-started

Demonstrates how to create a new token using the Doppler SDK. It involves initializing a ReadWriteFactory, defining token creation parameters, encoding them, simulating the transaction, executing it, and retrieving the deployed token address.

```javascript
const addresses = DOPPLER_V3_ADDRESSES[chainId];
const airlockAddress = addresses.airlock;
const bundlerAddress = addresses.bundler;
// Create a read-write factory instance
const factory = new ReadWriteFactory(
  airlockAddress,
  bundlerAddress,
  driftWithWallet
);
// Define token creation parameters
const createParams = {
  integrator: integratorAddress,
  userAddress: userAddress,
  numeraire: numeraireAddress, // USDC, WETH, etc.
  contracts: {
    tokenFactory: addresses.tokenFactory,
    governanceFactory: addresses.governanceFactory,
    poolInitializer: addresses.poolInitializer,
    liquidityMigrator: addresses.liquidityMigrator
  },
  tokenConfig: {
    name: "My Token",
    symbol: "MTK",
    decimals: 18
  },
  vestingConfig: "default" // or custom configuration
};
// Encode the creation parameters
const { createParams: encodedParams } = factory.encode(createParams);
// Simulate the creation transaction
const simulation = await factory.simulateCreate(encodedParams);
console.log('Gas estimate:', simulation.gasEstimate);
// Execute the creation transaction
const txHash = await factory.create(encodedParams);
console.log('Transaction hash:', txHash);
// Wait for transaction confirmation and get the deployed asset address
const receipt = await drift.waitForTransactionReceipt({ hash: txHash });
const createEvent = receipt.logs.find(log => 
  log.topics[0] === '0x...' // Create event signature
);
const deployedTokenAddress = `0x${createEvent.topics[1].slice(26)}`;
console.log('Deployed token address:', deployedTokenAddress);
```

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

### Import Doppler V3 SDK

Source: https://docs.doppler.lol/v3-sdk/getting-started

Imports necessary components from the Doppler V3 SDK for interacting with the protocol.

```javascript
import { 
  ReadFactory, 
  ReadWriteFactory, 
  ReadUniswapV3Pool,
  DOPPLER_V3_ADDRESSES 
} from 'doppler-v3-sdk';
```

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

### Get Doppler Protocol Addresses

Source: https://docs.doppler.lol/v4-sdk/getting-started

Retrieves protocol addresses for a specified chain ID, including the Airlock address.

```javascript
// Get addresses for the current network
const chainId = 84532; // Base Sepolia (change to 8453 for Base Mainnet, 130 for Unichain Mainnet, etc.)
const addresses = DOPPLER_V4_ADDRESSES[chainId];
const airlockAddress = addresses.airlock;
```

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

### GraphQL API: Get Recent Swaps

Source: https://docs.doppler.lol/indexer/api-usage

Retrieves recent swap events for a given pool, including transaction hash, timestamp, type, amounts, and USD price.

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

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

### Doppler V3 SDK: Core Concepts

Source: https://docs.doppler.lol/v3-sdk

Explains the fundamental concepts of the Doppler V3 SDK, including supported networks, factory classes for interaction patterns, and the asset lifecycle management.

```APIDOC
Supported Networks:
  - Base Mainnet (Chain ID: 8453)
  - Unichain Mainnet (Chain ID: 130)
  - Ink (Chain ID: 57073)
  - Base Sepolia (Chain ID: 84532)

Factory Classes:
  - ReadFactory: For querying protocol state and reading data.
  - ReadWriteFactory: For creating tokens and managing deployments.

Asset Lifecycle Management:
  1. Token Creation: Deploy new DERC20 tokens.
  2. Price Discovery: Manage initial liquidity and price discovery.
  3. Migration: Handle liquidity migration to Uniswap V2/V4.
  4. Pool Operations: Interact with price discovery and migrated pools.
```

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

### Doppler v4 Demo Application

Source: https://docs.doppler.lol/index

The Doppler v4 demo application is written in React and TypeScript. It is the easiest way to get familiar with what applications built on top of Doppler look like.

```link
https://github.com/whetstoneresearch/doppler-v4-miniapp
```

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

### Doppler v3 Demo Application

Source: https://docs.doppler.lol/index

The Doppler v3 demo application is written in React and TypeScript. It is the easiest way to get familiar with what applications built on top of Doppler look like.

```link
https://github.com/whetstoneresearch/doppler-v3-miniapp
```

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

### Doppler Token Creation Process

Source: https://docs.doppler.lol/how-it-works/publish-your-docs

Explains the 5-step process of creating tokens on Doppler, from initial creation with customized inputs to final integration into DeFi protocols.

```APIDOC
1. Tokens get created:
   Any application can permissionlessly create tokens by passing customized inputs into the Doppler smart contracts. These tokens can be memecoins, RWAs, governance tokens - whatever your specific application uniquely focuses on.

2. Price discovery:
   Tokens go through a price discovery period, fully onchain, bootstrapping their own liquidity. Doppler v3 uses a static bonding curve while Doppler v4 uses a dynamic bonding curve, based on a dynamic dutch auction.

3. Migration:
   Once the parameterized amount of tokens have been purchased or swapped, the tokens and LP positions get migrated to Uniswap (v2, to grow liquidity overtime through fees), or to Uniswap v4 (with support for custom fees), and triggering other contract interactions.

4. Treasury management & governance:
   Tokens can optionally be created with OpenZeppelin Governor Treasuries to give communities a home for their ecosystem and way to propose and vote on actions as a collective.

5. Complete:
   This newly created token is freely swappable across all Uniswap supported interfaces and able to be utilized throughout your favorite applications, DeFi protocols, and interfaces.
```

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

### Doppler V3 SDK: How Doppler v3 Works

Source: https://docs.doppler.lol/v3-sdk

Explains the different configurations of Doppler v3, including migration to Uniswap v2, Uniswap v4, or remaining within Uniswap v3 positions.

```APIDOC
Doppler v3 Configurations:
  - With "migration" to Uniswap v2: Accumulate more fees over time.
  - With "migration" to Uniswap v4: Support application-specific fee tiers.
  - Without "migration": Remain within positions on Uniswap v3.
```

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

### Doppler V3 SDK: Core Concepts

Source: https://docs.doppler.lol/v3-sdk/overview

Explains the fundamental concepts of the Doppler V3 SDK, including supported networks, factory classes for interaction patterns, and the asset lifecycle management.

```APIDOC
Supported Networks:
  - Base Mainnet (Chain ID: 8453)
  - Unichain Mainnet (Chain ID: 130)
  - Ink (Chain ID: 57073)
  - Base Sepolia (Chain ID: 84532)

Factory Classes:
  - ReadFactory: For querying protocol state and reading data.
  - ReadWriteFactory: For creating tokens and managing deployments.

Asset Lifecycle Management:
  1. Token Creation: Deploy new DERC20 tokens.
  2. Price Discovery: Manage initial liquidity and price discovery.
  3. Migration: Handle liquidity migration to Uniswap V2/V4.
  4. Pool Operations: Interact with price discovery and migrated pools.
```

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

### Adding a New Chain to Doppler

Source: https://docs.doppler.lol/indexer/development

Provides a step-by-step guide for integrating a new blockchain into the Doppler project. This involves creating configuration files, adding contract addresses, exporting the config, and setting up environment variables.

```typescript
1. Create a new file `src/config/chains/newchain.ts` with the `ChainConfig` structure.
2. Add all relevant contract addresses for the new chain.
3. Export the config and add it to the `chainConfigs` object in `src/config/chains/index.ts`.
4. Add the corresponding RPC environment variable to `.env.example` and your local `.env.local`.
```

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

### Doppler V3 SDK: How Doppler v3 Works

Source: https://docs.doppler.lol/v3-sdk/overview

Explains the different configurations of Doppler v3, including migration to Uniswap v2, Uniswap v4, or remaining within Uniswap v3 positions.

```APIDOC
Doppler v3 Configurations:
  - With "migration" to Uniswap v2: Accumulate more fees over time.
  - With "migration" to Uniswap v4: Support application-specific fee tiers.
  - Without "migration": Remain within positions on Uniswap v3.
```

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

### Configure and Encode V4 Migrator Data

Source: https://docs.doppler.lol/v3-sdk/custom-fees

Provides a step-by-step guide on configuring beneficiaries, sorting them, defining V4 migrator parameters (fee, tick spacing, lock duration), and encoding this configuration using the Doppler V3 SDK.

```javascript
import { BeneficiaryData, WAD } from "doppler-v3-sdk";

// Shares must sum to exactly WAD (1e18)
const beneficiaries: BeneficiaryData[] = [
  {
    beneficiary: "0x...", // Treasury address
    shares: WAD * 70n / 100n  // 70% of fees
  },
  {
    beneficiary: "0x...", // Development fund
    shares: WAD * 20n / 100n  // 20% of fees
  },
  {
    beneficiary: "0x...", // Community rewards
    shares: WAD * 10n / 100n  // 10% of fees
  }
];

import { ReadWriteFactory } from "doppler-v3-sdk";
const factory = new ReadWriteFactory(airlockAddress, bundlerAddress);
const sortedBeneficiaries = factory.sortBeneficiaries(beneficiaries);

import { V4MigratorData } from "doppler-v3-sdk";
const migratorConfig: V4MigratorData = {
  fee: 3000,                        // 0.3% fee tier
  tickSpacing: 60,                  // Tick spacing for the V4 pool
  lockDuration: 365 * 24 * 60 * 60, // 1 year lock
  beneficiaries: sortedBeneficiaries
};

const encodedMigratorData = factory.encodeV4MigratorData(migratorConfig);
```

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

### Configure Standard Governance in Doppler V3 SDK

Source: https://docs.doppler.lol/v3-sdk/governance-options

Shows how to set up token creation with standard on-chain governance using the Doppler V3 SDK. It includes an example of customizing governance parameters like voting delay, voting period, and proposal threshold.

```typescript
const createParams: CreateV3PoolParams = {
  // ... other parameters ...
  contracts: {
    tokenFactory: addresses.tokenFactory,
    // Use standard governanceFactory
    governanceFactory: addresses.governanceFactory,
    v3Initializer: addresses.v3Initializer,
    liquidityMigrator: addresses.liquidityMigrator,
  },
  // Optional: Customize governance parameters
  governanceConfig: {
    initialVotingDelay: 3600, // 1 hour
    initialVotingPeriod: 172800, // 48 hours
    initialProposalThreshold: 1000000n, // 1% of supply
  },
};
```

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

### Doppler V3 SDK: Key Features

Source: https://docs.doppler.lol/v3-sdk/overview

Details the key features of the Doppler V3 SDK, focusing on token creation, pool interaction, and Uniswap V4 migration capabilities.

```APIDOC
Token Creation & Configuration:
  - Flexible Configuration: Custom parameters, sale configurations, governance settings.
  - Configuration Types: Utilize `DefaultConfigs`.
  - Parameter Validation: Automatic validation of creation parameters.
  - Gas Estimation: Built-in simulation for gas estimation.

Pool Interaction:
  - Pool State Queries: Access slot0, token info, fee structures.
  - Event Tracking: Retrieve mint, burn, swap events.
  - Multi-Protocol Support: Handle V3, V2/V4 pools.
  - Real-time Data: Live access to liquidity, prices, trading activity.

V4 Migration Support:
  - Fee Streaming Configuration: Set up fee distribution.
  - Beneficiary Management: Automatic sorting and validation.
  - Migration Validation: Ensure proper configuration before execution.
```

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

### Query Pool Data with Doppler Lens

Source: https://docs.doppler.lol/v4-sdk/getting-started

Shows how to use the DopplerLensQuoter to retrieve detailed information about a created token's pool. It involves getting asset data, initializing the Doppler Lens, defining the pool key, and querying comprehensive pool state data.

```TypeScript
// Get the asset data to find the pool information
const assetData = await factory.getAssetData(deployedTokenAddress);
// Create a doppler lens instance
const lens = new ReadDopplerLens(addresses.dopplerLensQuoter, drift);
// Define pool key for the created token
const poolKey = {
  currency0: assetData.numeraire,
  currency1: deployedTokenAddress,
  fee: 20_000, // 2% fee tier
  tickSpacing: 2,
  hooks: assetData.hook // Hook address from asset data
};
// Get comprehensive pool state data
const poolData = await lens.quoteDopplerLensData({
  poolKey,
  zeroForOne: true,
  exactAmount: 1n, // Minimal amount for state query
  hookData: "0x"
});
console.log('Pool state:', {
  sqrtPriceX96: poolData.sqrtPriceX96.toString(),
  tick: poolData.tick,
  totalToken0: poolData.amount0.toString(),
  totalToken1: poolData.amount1.toString()
});
```

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

### Doppler Token Creation Process

Source: https://docs.doppler.lol/how-it-works

Explains the 5-step process of creating tokens on Doppler, from initial creation with customized inputs to final integration into DeFi protocols.

```APIDOC
1. Tokens get created:
   Any application can permissionlessly create tokens by passing customized inputs into the Doppler smart contracts. These tokens can be memecoins, RWAs, governance tokens - whatever your specific application uniquely focuses on.

2. Price discovery:
   Tokens go through a price discovery period, fully onchain, bootstrapping their own liquidity. Doppler v3 uses a static bonding curve while Doppler v4 uses a dynamic bonding curve, based on a dynamic dutch auction.

3. Migration:
   Once the parameterized amount of tokens have been purchased or swapped, the tokens and LP positions get migrated to Uniswap (v2, to grow liquidity overtime through fees), or to Uniswap v4 (with support for custom fees), and triggering other contract interactions.

4. Treasury management & governance:
   Tokens can optionally be created with OpenZeppelin Governor Treasuries to give communities a home for their ecosystem and way to propose and vote on actions as a collective.

5. Complete:
   This newly created token is freely swappable across all Uniswap supported interfaces and able to be utilized throughout your favorite applications, DeFi protocols, and interfaces.
```
Tokens:
Raw