@coinbarrel/sdk 1.0.1 → 1.2.0

package/README.md

@@ -116,6 +116,55 @@ const sellMaxIx = await sdk.pool.buildSwapTokenToSolMaxInstruction({
 });
 ```
 
+## Token Creation
+
+### Create a New Token
+
+```typescript
+// Build create token instruction
+const { instructions, mintKeypair } = sdk.buildCreateTokenInstruction({
+	payer: wallet.publicKey,
+	name: 'My Token',
+	symbol: 'MTK',
+	uri: 'https://arweave.net/...', // Metadata JSON URI
+	creatorFeeRecipient: wallet.publicKey,
+	traderRewardsShareBps: 3000, // 30% of fees to holders (optional, default 2500)
+});
+
+// Build and send transaction
+const tx = new Transaction().add(...instructions);
+const signature = await sendAndConfirmTransaction(connection, tx, [wallet, mintKeypair]);
+
+console.log(`Token created: ${mintKeypair.publicKey.toBase58()}`);
+```
+
+The token is created with:
+
+- **Mint authority**: Revoked immediately after minting 1B tokens
+- **Freeze authority**: Never set (null from creation)
+- **Total supply**: 1,000,000,000 tokens (6 decimals)
+- **Metadata**: Created via Metaplex (update_authority = creator)
+
+## Holder Rewards
+
+### Claim Rewards from Bonding Curve
+
+```typescript
+const instructions = await sdk.buildClaimRewardsCurveInstruction(tokenMint, wallet.publicKey);
+
+const tx = new Transaction().add(...instructions);
+const signature = await sendAndConfirmTransaction(connection, tx, [wallet]);
+```
+
+### Claim Rewards from AMM Pool (Post-Graduation)
+
+```typescript
+const instructions = await sdk.buildClaimRewardsPoolInstruction(tokenMint, wallet.publicKey);
+
+const tx = new Transaction().add(...instructions);
+const signature = await sendAndConfirmTransaction(connection, tx, [wallet]);
+```
+
 ## Market Info
 
 ### Get Token Market State
@@ -173,6 +222,36 @@ const raw = toRawAmount(100); // 100_000_000n
 const ui = toUiAmount(100_000_000n); // 100
 ```
 
+## Token Metadata
+
+Fetch token metadata from the Metaplex Token Metadata program:
+
+```typescript
+// Get on-chain metadata (fast - just name, symbol, uri)
+const metadata = await sdk.getTokenMetadata(tokenMint);
+if (metadata) {
+	console.log(metadata.name); // "My Token"
+	console.log(metadata.symbol); // "MTK"
+	console.log(metadata.uri); // "https://..."
+}
+
+// Get full metadata including off-chain JSON (image, socials)
+const fullMetadata = await sdk.getTokenMetadataJson(tokenMint);
+if (fullMetadata) {
+	console.log(fullMetadata.image); // "https://..." or "ipfs://..."
+	console.log(fullMetadata.description); // "A cool token"
+	console.log(fullMetadata.twitter); // "@mytoken"
+	console.log(fullMetadata.website); // "https://..."
+}
+
+// Batch fetch for multiple tokens (more efficient)
+const mints = [mint1, mint2, mint3];
+const metadataMap = await sdk.batchGetTokenMetadata(mints);
+for (const [mintStr, meta] of metadataMap) {
+	console.log(`${mintStr}: ${meta?.name}`);
+}
+```
+
 ## PDA Helpers
 
 ```typescript
@@ -180,6 +259,7 @@ const ui = toUiAmount(100_000_000n); // 100
 const bondingCurve = sdk.getBondingCurvePda(tokenMint);
 const pool = sdk.getPoolPda(tokenMint);
 const holderReward = sdk.getHolderRewardPda(tokenMint, wallet.publicKey);
+const metadataPda = sdk.getMetadataPda(tokenMint); // Metaplex metadata PDA
 ```
 
 ## Fee Structure
@@ -212,6 +292,11 @@ import type {
 	SellQuote,
 	SwapQuote,
 	Network,
+	TokenMetadata,
+	TokenMetadataJson,
+	CreateBarrelTokenParams,
+	ClaimHolderRewardsParams,
+	ClaimHolderRewardsCurveParams,
 } from '@coinbarrel/sdk';
 ```
 

package/dist/accounts.js

@@ -1,11 +1,19 @@
+"use strict";
 /**
  * Account Fetching and Parsing
  * Read on-chain account data for bonding curves and pools
  */
-import { PublicKey } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token';
-import { BONDING_CURVE_OFFSETS, POOL_OFFSETS, NATIVE_MINT, LAMPORTS_PER_SOL } from './constants.js';
-import { getBondingCurvePda, getPoolPda, getSolEscrowPda, } from './pda.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBondingCurveState = getBondingCurveState;
+exports.getCurveSolBalance = getCurveSolBalance;
+exports.getPoolState = getPoolState;
+exports.getPoolBalances = getPoolBalances;
+exports.getMarketInfo = getMarketInfo;
+exports.getUserTokenBalance = getUserTokenBalance;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_js_1 = require("./constants.js");
+const pda_js_1 = require("./pda.js");
 // ============= Buffer Helpers =============
 function readU16LE(data, offset) {
     return data.readUInt16LE(offset);
@@ -19,7 +27,7 @@ function readU128LE(data, offset) {
     return low + (high << 64n);
 }
 function readPubkey(data, offset) {
-    return new PublicKey(data.subarray(offset, offset + 32));
+    return new web3_js_1.PublicKey(data.subarray(offset, offset + 32));
 }
 function readBool(data, offset) {
     return data[offset] !== 0;
@@ -28,14 +36,14 @@ function readBool(data, offset) {
 /**
  * Fetch and parse bonding curve state
  */
-export async function getBondingCurveState(connection, tokenMint, programId) {
-    const bondingCurve = getBondingCurvePda(tokenMint, programId);
+async function getBondingCurveState(connection, tokenMint, programId) {
+    const bondingCurve = (0, pda_js_1.getBondingCurvePda)(tokenMint, programId);
     const accountInfo = await connection.getAccountInfo(bondingCurve);
     if (!accountInfo || accountInfo.data.length < 209) {
         return null;
     }
     const data = accountInfo.data;
-    const O = BONDING_CURVE_OFFSETS;
+    const O = constants_js_1.BONDING_CURVE_OFFSETS;
     return {
         tokenMint: readPubkey(data, O.TOKEN_MINT),
         tokenVault: readPubkey(data, O.TOKEN_VAULT),
@@ -57,9 +65,9 @@ export async function getBondingCurveState(connection, tokenMint, programId) {
 /**
  * Get SOL balance in bonding curve escrow
  */
-export async function getCurveSolBalance(connection, tokenMint, programId) {
-    const bondingCurve = getBondingCurvePda(tokenMint, programId);
-    const solEscrow = getSolEscrowPda(bondingCurve, programId);
+async function getCurveSolBalance(connection, tokenMint, programId) {
+    const bondingCurve = (0, pda_js_1.getBondingCurvePda)(tokenMint, programId);
+    const solEscrow = (0, pda_js_1.getSolEscrowPda)(bondingCurve, programId);
     const balance = await connection.getBalance(solEscrow);
     return BigInt(balance);
 }
@@ -67,14 +75,14 @@ export async function getCurveSolBalance(connection, tokenMint, programId) {
 /**
  * Fetch and parse pool state
  */
-export async function getPoolState(connection, tokenMint, programId) {
-    const pool = getPoolPda(tokenMint, programId);
+async function getPoolState(connection, tokenMint, programId) {
+    const pool = (0, pda_js_1.getPoolPda)(tokenMint, programId);
     const accountInfo = await connection.getAccountInfo(pool);
     if (!accountInfo || accountInfo.data.length < 269) {
         return null;
     }
     const data = accountInfo.data;
-    const O = POOL_OFFSETS;
+    const O = constants_js_1.POOL_OFFSETS;
     return {
         tokenAMint: readPubkey(data, O.TOKEN_A_MINT),
         tokenBMint: readPubkey(data, O.TOKEN_B_MINT),
@@ -95,20 +103,20 @@ export async function getPoolState(connection, tokenMint, programId) {
  * Get pool vault balances
  * Uses vault addresses stored in Pool state rather than deriving PDAs
  */
-export async function getPoolBalances(connection, tokenMint, programId) {
+async function getPoolBalances(connection, tokenMint, programId) {
     // First fetch pool state to get stored vault addresses
     const state = await getPoolState(connection, tokenMint, programId);
     if (!state) {
         return null;
     }
     // Determine which vault is WSOL and which is the token based on stored mints
-    const isTokenANative = state.tokenAMint.equals(NATIVE_MINT);
+    const isTokenANative = state.tokenAMint.equals(constants_js_1.NATIVE_MINT);
     const wsolVault = isTokenANative ? state.tokenAVault : state.tokenBVault;
     const tokenVault = isTokenANative ? state.tokenBVault : state.tokenAVault;
     try {
         const [wsolAccount, tokenAccount] = await Promise.all([
-            getAccount(connection, wsolVault),
-            getAccount(connection, tokenVault),
+            (0, spl_token_1.getAccount)(connection, wsolVault),
+            (0, spl_token_1.getAccount)(connection, tokenVault),
         ]);
         return {
             solBalance: wsolAccount.amount,
@@ -124,7 +132,7 @@ export async function getPoolBalances(connection, tokenMint, programId) {
  * Get comprehensive market info for a token
  * Automatically detects if on bonding curve or AMM pool
  */
-export async function getMarketInfo(connection, tokenMint, programId) {
+async function getMarketInfo(connection, tokenMint, programId) {
     // Try bonding curve first
     const curveState = await getBondingCurveState(connection, tokenMint, programId);
     if (curveState && !curveState.paused) {
@@ -133,9 +141,9 @@ export async function getMarketInfo(connection, tokenMint, programId) {
             // Still on bonding curve
             const solBalance = await getCurveSolBalance(connection, tokenMint, programId);
             // Calculate price from virtual reserves: price = vSol / vToken
-            const price = curveState.vToken > 0n ? (curveState.vSol * LAMPORTS_PER_SOL) / curveState.vToken : 0n;
+            const price = curveState.vToken > 0n ? (curveState.vSol * constants_js_1.LAMPORTS_PER_SOL) / curveState.vToken : 0n;
             // Market cap = circulating supply * price
-            const marketCapSol = curveState.totalSold > 0n ? (curveState.totalSold * price) / LAMPORTS_PER_SOL : 0n;
+            const marketCapSol = curveState.totalSold > 0n ? (curveState.totalSold * price) / constants_js_1.LAMPORTS_PER_SOL : 0n;
             return {
                 tokenMint,
                 phase: 'curve',
@@ -155,7 +163,7 @@ export async function getMarketInfo(connection, tokenMint, programId) {
     if (poolState && poolBalances) {
         // Calculate price from reserves: price = solReserve / tokenReserve
         const price = poolBalances.tokenBalance > 0n
-            ? (poolBalances.solBalance * LAMPORTS_PER_SOL) / poolBalances.tokenBalance
+            ? (poolBalances.solBalance * constants_js_1.LAMPORTS_PER_SOL) / poolBalances.tokenBalance
             : 0n;
         // For pool, circulating = total supply - vault balance
         // We'd need to fetch total supply, for now use a placeholder
@@ -179,14 +187,13 @@ export async function getMarketInfo(connection, tokenMint, programId) {
 /**
  * Get user's token balance
  */
-export async function getUserTokenBalance(connection, tokenMint, user) {
+async function getUserTokenBalance(connection, tokenMint, user) {
     try {
-        const ata = getAssociatedTokenAddressSync(tokenMint, user);
-        const account = await getAccount(connection, ata);
+        const ata = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+        const account = await (0, spl_token_1.getAccount)(connection, ata);
         return account.amount;
     }
     catch {
         return 0n;
     }
 }
-//# sourceMappingURL=accounts.js.map

package/dist/constants.js

@@ -1,21 +1,26 @@
+"use strict";
 /**
  * CoinBarrel SDK Constants
  * Network-specific program IDs and configuration
  */
-import { PublicKey } from '@solana/web3.js';
-export const PROGRAM_IDS = {
-    devnet: new PublicKey('AhfARnaxxX61YotZw3mZWLLUFpF8UV6pZmWJBEZCbVC4'),
-    mainnet: new PublicKey('7HxbxHnTUBaUfWjVPbPLs8gqqScmjmBWjRnETBjS9DMj'),
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_DECIMALS_MULTIPLIER = exports.LAMPORTS_PER_SOL = exports.DEFAULT_SLIPPAGE_BPS = exports.DEFAULT_DECIMALS = exports.POOL_OFFSETS = exports.BONDING_CURVE_OFFSETS = exports.DISCRIMINATORS = exports.SEEDS = exports.TOKEN_METADATA_PROGRAM_ID = exports.NATIVE_MINT = exports.ADMIN_FEE_RECIPIENTS = exports.PROGRAM_IDS = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.PROGRAM_IDS = {
+    devnet: new web3_js_1.PublicKey('AhfARnaxxX61YotZw3mZWLLUFpF8UV6pZmWJBEZCbVC4'),
+    mainnet: new web3_js_1.PublicKey('7HxbxHnTUBaUfWjVPbPLs8gqqScmjmBWjRnETBjS9DMj'),
 };
 // Admin fee recipient (CoinBarrel protocol fee wallet)
-export const ADMIN_FEE_RECIPIENTS = {
-    devnet: new PublicKey('4Uw8XhtqVBEXEkjZfWb7agyrhxbSmfDSGWEdxbWonhwu'),
-    mainnet: new PublicKey('4Uw8XhtqVBEXEkjZfWb7agyrhxbSmfDSGWEdxbWonhwu'),
+exports.ADMIN_FEE_RECIPIENTS = {
+    devnet: new web3_js_1.PublicKey('4Uw8XhtqVBEXEkjZfWb7agyrhxbSmfDSGWEdxbWonhwu'),
+    mainnet: new web3_js_1.PublicKey('4Uw8XhtqVBEXEkjZfWb7agyrhxbSmfDSGWEdxbWonhwu'),
 };
 // WSOL mint (same on all networks)
-export const NATIVE_MINT = new PublicKey('So11111111111111111111111111111111111111112');
+exports.NATIVE_MINT = new web3_js_1.PublicKey('So11111111111111111111111111111111111111112');
+// Metaplex Token Metadata Program ID (same on all networks)
+exports.TOKEN_METADATA_PROGRAM_ID = new web3_js_1.PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
 // ============= PDA Seeds =============
-export const SEEDS = {
+exports.SEEDS = {
     BONDING: Buffer.from('bonding'),
     BONDING_AUTHORITY: Buffer.from('bonding_authority'),
     BONDING_SOL: Buffer.from('bonding_sol'),
@@ -28,9 +33,10 @@ export const SEEDS = {
 };
 // ============= Instruction Discriminators =============
 // Pre-computed Anchor discriminators (first 8 bytes of sha256("global:<instruction_name>"))
-export const DISCRIMINATORS = {
+exports.DISCRIMINATORS = {
     // Bonding curve
     initialize_barrel_curve: Buffer.from([158, 16, 141, 14, 53, 250, 33, 42]),
+    create_barrel_token: Buffer.from([88, 190, 74, 163, 144, 5, 73, 246]),
     buy_on_curve: Buffer.from([6, 20, 84, 191, 116, 79, 21, 147]),
     sell_on_curve: Buffer.from([158, 242, 158, 47, 48, 215, 214, 209]),
     sell_max_on_curve: Buffer.from([42, 184, 90, 220, 13, 36, 18, 77]),
@@ -54,7 +60,7 @@ export const DISCRIMINATORS = {
 };
 // ============= Account Data Offsets =============
 // For parsing on-chain account data
-export const BONDING_CURVE_OFFSETS = {
+exports.BONDING_CURVE_OFFSETS = {
     DISCRIMINATOR: 0,
     TOKEN_MINT: 8,
     TOKEN_VAULT: 8 + 32,
@@ -72,7 +78,7 @@ export const BONDING_CURVE_OFFSETS = {
     TOTAL_SOLD: 8 + 192,
     PAUSED: 8 + 208,
 };
-export const POOL_OFFSETS = {
+exports.POOL_OFFSETS = {
     DISCRIMINATOR: 0,
     TOKEN_A_MINT: 8,
     TOKEN_B_MINT: 8 + 32,
@@ -89,8 +95,7 @@ export const POOL_OFFSETS = {
     CREATOR_FEE_RECIPIENT: 8 + 237,
 };
 // ============= Defaults =============
-export const DEFAULT_DECIMALS = 6;
-export const DEFAULT_SLIPPAGE_BPS = 100; // 1%
-export const LAMPORTS_PER_SOL = 1000000000n;
-export const TOKEN_DECIMALS_MULTIPLIER = 1000000n; // 10^6 for 6 decimals
-//# sourceMappingURL=constants.js.map
+exports.DEFAULT_DECIMALS = 6;
+exports.DEFAULT_SLIPPAGE_BPS = 100; // 1%
+exports.LAMPORTS_PER_SOL = 1000000000n;
+exports.TOKEN_DECIMALS_MULTIPLIER = 1000000n; // 10^6 for 6 decimals

package/dist/create.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Token Creation
+ * Create new barrel tokens with atomically revoked mint/freeze authority
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCreateBarrelTokenInstruction = buildCreateBarrelTokenInstruction;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_js_1 = require("./constants.js");
+const pda_js_1 = require("./pda.js");
+const metadata_js_1 = require("./metadata.js");
+// ============= Buffer Helpers =============
+function writeU8(n) {
+    const b = Buffer.alloc(1);
+    b.writeUInt8(n);
+    return b;
+}
+function writeU16LE(n) {
+    const b = Buffer.alloc(2);
+    b.writeUInt16LE(n);
+    return b;
+}
+function writePubkey(pk) {
+    return pk.toBuffer();
+}
+function writeString(s) {
+    const bytes = Buffer.from(s, 'utf-8');
+    const lenBuf = Buffer.alloc(4);
+    lenBuf.writeUInt32LE(bytes.length);
+    return Buffer.concat([lenBuf, bytes]);
+}
+// ============= Token Vault PDA =============
+function getTokenVaultPda(bondingCurve, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('token_vault'), bondingCurve.toBuffer()], programId);
+    return pda;
+}
+// ============= Instruction Builder =============
+/**
+ * Build create_barrel_token instruction
+ *
+ * Creates a new token with:
+ * - Mint authority: revoked immediately after minting 1B tokens
+ * - Freeze authority: null from creation
+ * - 1B total supply minted to bonding curve vault
+ * - Metadata created via Metaplex CPI
+ *
+ * @param params - Token creation parameters
+ * @param programId - CoinBarrel program ID
+ * @param network - Network for admin fee recipient
+ * @returns Object containing instruction and mint keypair (must sign transaction)
+ */
+function buildCreateBarrelTokenInstruction(params, programId, network) {
+    const { payer, name, symbol, uri, decimals = 6, variant = 0, creatorFeeRecipient, traderRewardsShareBps = 2500, // 25% of fees to holders
+     } = params;
+    // Generate new mint keypair
+    const mintKeypair = web3_js_1.Keypair.generate();
+    const tokenMint = mintKeypair.publicKey;
+    // Derive PDAs
+    const bondingCurve = (0, pda_js_1.getBondingCurvePda)(tokenMint, programId);
+    const bondingAuthority = (0, pda_js_1.getBondingAuthorityPda)(bondingCurve, programId);
+    const tokenVault = getTokenVaultPda(bondingCurve, programId);
+    const metadata = (0, metadata_js_1.getMetadataPda)(tokenMint);
+    // Admin fee recipient from network config
+    const adminFeeRecipient = constants_js_1.ADMIN_FEE_RECIPIENTS[network];
+    // Build instruction data
+    // Discriminator + decimals(u8) + variant(u8) + admin_fee_recipient(Pubkey) + creator_fee_recipient(Pubkey)
+    // + trader_rewards_share_bps(u16) + name(String) + symbol(String) + uri(String)
+    const data = Buffer.concat([
+        constants_js_1.DISCRIMINATORS.create_barrel_token,
+        writeU8(decimals),
+        writeU8(variant),
+        writePubkey(adminFeeRecipient),
+        writePubkey(creatorFeeRecipient),
+        writeU16LE(traderRewardsShareBps),
+        writeString(name),
+        writeString(symbol),
+        writeString(uri),
+    ]);
+    const createIx = new web3_js_1.TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: tokenMint, isWritable: true, isSigner: true },
+            { pubkey: bondingCurve, isWritable: true, isSigner: false },
+            { pubkey: tokenVault, isWritable: true, isSigner: false },
+            { pubkey: bondingAuthority, isWritable: false, isSigner: false },
+            { pubkey: metadata, isWritable: true, isSigner: false },
+            { pubkey: constants_js_1.TOKEN_METADATA_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: payer, isWritable: true, isSigner: true },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: web3_js_1.SYSVAR_RENT_PUBKEY, isWritable: false, isSigner: false },
+        ],
+        data,
+    });
+    return {
+        instructions: [createIx],
+        mintKeypair,
+    };
+}