pyre-world-kit 1.0.0

package/dist/intel.js

@@ -0,0 +1,342 @@
+"use strict";
+/**
+ * Pyre Kit Intel
+ *
+ * Game-specific utility functions that compose torchsdk reads into
+ * strategic intelligence. Agents use these to reason about the world.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFactionPower = getFactionPower;
+exports.getFactionLeaderboard = getFactionLeaderboard;
+exports.detectAlliances = detectAlliances;
+exports.getFactionRivals = getFactionRivals;
+exports.getAgentProfile = getAgentProfile;
+exports.getAgentFactions = getAgentFactions;
+exports.getWorldFeed = getWorldFeed;
+exports.getWorldStats = getWorldStats;
+const torchsdk_1 = require("torchsdk");
+const mappers_1 = require("./mappers");
+// ─── Faction Power & Rankings ──────────────────────────────────────
+/**
+ * Calculate a faction's power score.
+ *
+ * Score = (market_cap_sol * 0.4) + (members * 0.2) + (war_chest_sol * 0.2)
+ *       + (rallies * 0.1) + (progress * 0.1)
+ *
+ * Normalized to make comparison easy. Higher = stronger.
+ */
+async function getFactionPower(connection, mint) {
+    const t = await (0, torchsdk_1.getToken)(connection, mint);
+    const score = computePowerScore(t);
+    return {
+        mint: t.mint,
+        name: t.name,
+        symbol: t.symbol,
+        score,
+        market_cap_sol: t.market_cap_sol,
+        members: t.holders ?? 0,
+        war_chest_sol: t.treasury_sol_balance,
+        rallies: t.stars,
+        progress_percent: t.progress_percent,
+        status: (0, mappers_1.mapFactionStatus)(t.status),
+    };
+}
+/**
+ * Ranked leaderboard of all factions by power score.
+ */
+async function getFactionLeaderboard(connection, opts) {
+    // Fetch all tokens (up to 1000)
+    const statusMap = {
+        rising: 'bonding',
+        ready: 'complete',
+        ascended: 'migrated',
+        razed: 'reclaimed',
+    };
+    const sdkStatus = opts?.status ? statusMap[opts.status] : 'all';
+    const result = await (0, torchsdk_1.getTokens)(connection, { limit: opts?.limit ?? 100, status: sdkStatus });
+    const powers = result.tokens.map((t) => ({
+        mint: t.mint,
+        name: t.name,
+        symbol: t.symbol,
+        score: computePowerScoreFromSummary(t),
+        market_cap_sol: t.market_cap_sol,
+        members: t.holders ?? 0,
+        war_chest_sol: 0, // Not available in summary
+        rallies: 0, // Not available in summary
+        progress_percent: t.progress_percent,
+        status: (0, mappers_1.mapFactionStatus)(t.status),
+    }));
+    powers.sort((a, b) => b.score - a.score);
+    return powers;
+}
+// ─── Alliance & Rivalry Detection ──────────────────────────────────
+/**
+ * Detect alliances: factions with shared members.
+ *
+ * Given a set of faction mints, finds wallets holding multiple faction tokens.
+ * Returns alliance clusters showing which factions share members.
+ */
+async function detectAlliances(connection, mints, holderLimit = 50) {
+    // Fetch holders for each faction in parallel
+    const holdersPerFaction = await Promise.all(mints.map(async (mint) => {
+        const result = await (0, torchsdk_1.getHolders)(connection, mint, holderLimit);
+        return { mint, holders: new Set(result.holders.map(h => h.address)) };
+    }));
+    // Find overlapping holders between faction pairs
+    const clusters = [];
+    for (let i = 0; i < holdersPerFaction.length; i++) {
+        for (let j = i + 1; j < holdersPerFaction.length; j++) {
+            const a = holdersPerFaction[i];
+            const b = holdersPerFaction[j];
+            const shared = [...a.holders].filter(h => b.holders.has(h));
+            if (shared.length > 0) {
+                const minSize = Math.min(a.holders.size, b.holders.size);
+                clusters.push({
+                    factions: [a.mint, b.mint],
+                    shared_members: shared.length,
+                    overlap_percent: minSize > 0 ? (shared.length / minSize) * 100 : 0,
+                });
+            }
+        }
+    }
+    clusters.sort((a, b) => b.shared_members - a.shared_members);
+    return clusters;
+}
+/**
+ * Find rival factions based on recent defection activity.
+ *
+ * Looks at recent sell messages to detect agents who have defected
+ * from or to this faction.
+ */
+async function getFactionRivals(connection, mint, limit = 50) {
+    // Get recent messages (sells include defection messages)
+    const msgs = await (0, torchsdk_1.getMessages)(connection, mint, limit);
+    const defectors = new Set(msgs.messages.map(m => m.sender));
+    // For each defector, check what other factions they hold
+    // This is a heuristic — we look at the messages to find patterns
+    // In practice, agents would track this over time
+    const rivalCounts = new Map();
+    // Get all factions to cross-reference
+    const allFactions = await (0, torchsdk_1.getTokens)(connection, { limit: 20, sort: 'volume' });
+    for (const faction of allFactions.tokens) {
+        if (faction.mint === mint)
+            continue;
+        const holders = await (0, torchsdk_1.getHolders)(connection, faction.mint, 50);
+        const holderAddrs = new Set(holders.holders.map(h => h.address));
+        const overlap = [...defectors].filter(d => holderAddrs.has(d)).length;
+        if (overlap > 0) {
+            rivalCounts.set(faction.mint, {
+                in: overlap, // Agents from this faction who also hold rival
+                out: overlap,
+                ...(rivalCounts.get(faction.mint) ?? {}),
+            });
+        }
+    }
+    const rivals = [];
+    for (const [rivalMint, counts] of rivalCounts) {
+        const faction = allFactions.tokens.find(t => t.mint === rivalMint);
+        if (faction) {
+            rivals.push({
+                mint: rivalMint,
+                name: faction.name,
+                symbol: faction.symbol,
+                defections_in: counts.in,
+                defections_out: counts.out,
+            });
+        }
+    }
+    rivals.sort((a, b) => (b.defections_in + b.defections_out) - (a.defections_in + a.defections_out));
+    return rivals;
+}
+// ─── Agent Intelligence ────────────────────────────────────────────
+/**
+ * Build an aggregate profile for an agent wallet.
+ */
+async function getAgentProfile(connection, wallet) {
+    // Fetch stronghold and SAID verification in parallel
+    const [vault, said] = await Promise.all([
+        (0, torchsdk_1.getVaultForWallet)(connection, wallet).catch(() => null),
+        (0, torchsdk_1.verifySaid)(wallet).catch(() => null),
+    ]);
+    // Get factions this agent holds — requires scanning
+    // For now, check top factions for this holder
+    const factions = await getAgentFactions(connection, wallet);
+    // Find factions this wallet created
+    const allFactions = await (0, torchsdk_1.getTokens)(connection, { limit: 100 });
+    const founded = allFactions.tokens
+        .filter(t => t.mint) // TokenSummary doesn't have creator, so we skip for now
+        .map(t => t.mint);
+    const totalValue = factions.reduce((sum, f) => sum + f.value_sol, 0);
+    return {
+        wallet,
+        stronghold: vault ? {
+            address: vault.address,
+            creator: vault.creator,
+            authority: vault.authority,
+            sol_balance: vault.sol_balance,
+            total_deposited: vault.total_deposited,
+            total_withdrawn: vault.total_withdrawn,
+            total_spent: vault.total_spent,
+            total_received: vault.total_received,
+            linked_agents: vault.linked_wallets,
+            created_at: vault.created_at,
+        } : null,
+        factions_joined: factions,
+        factions_founded: [], // Would need per-token creator lookup
+        said_verification: said,
+        total_value_sol: totalValue + (vault?.sol_balance ?? 0),
+    };
+}
+/**
+ * List all factions an agent holds tokens in.
+ *
+ * Checks top factions for this wallet's holdings.
+ */
+async function getAgentFactions(connection, wallet, factionLimit = 50) {
+    const allFactions = await (0, torchsdk_1.getTokens)(connection, { limit: factionLimit });
+    const positions = [];
+    // Check each faction for this holder
+    await Promise.all(allFactions.tokens.map(async (faction) => {
+        try {
+            const holders = await (0, torchsdk_1.getHolders)(connection, faction.mint, 100);
+            const holding = holders.holders.find(h => h.address === wallet);
+            if (holding && holding.balance > 0) {
+                positions.push({
+                    mint: faction.mint,
+                    name: faction.name,
+                    symbol: faction.symbol,
+                    balance: holding.balance,
+                    percentage: holding.percentage,
+                    value_sol: holding.balance * faction.price_sol,
+                });
+            }
+        }
+        catch {
+            // Skip factions we can't read
+        }
+    }));
+    positions.sort((a, b) => b.value_sol - a.value_sol);
+    return positions;
+}
+// ─── World State ───────────────────────────────────────────────────
+/**
+ * Aggregated recent activity across ALL factions.
+ *
+ * The "Bloomberg terminal" feed — launches, joins, defections, rallies.
+ */
+async function getWorldFeed(connection, opts) {
+    const factionLimit = opts?.factionLimit ?? 20;
+    const msgLimit = opts?.limit ?? 5;
+    const allFactions = await (0, torchsdk_1.getTokens)(connection, { limit: factionLimit, sort: 'newest' });
+    const events = [];
+    // Add launch events for each faction
+    for (const faction of allFactions.tokens) {
+        events.push({
+            type: 'launch',
+            faction_mint: faction.mint,
+            faction_name: faction.name,
+            timestamp: faction.created_at,
+        });
+        // Map status to events
+        if (faction.status === 'migrated') {
+            events.push({
+                type: 'ascend',
+                faction_mint: faction.mint,
+                faction_name: faction.name,
+                timestamp: faction.last_activity_at,
+            });
+        }
+        else if (faction.status === 'reclaimed') {
+            events.push({
+                type: 'raze',
+                faction_mint: faction.mint,
+                faction_name: faction.name,
+                timestamp: faction.last_activity_at,
+            });
+        }
+    }
+    // Get recent messages from top factions (messages = trade activity)
+    const topFactions = allFactions.tokens.slice(0, 10);
+    await Promise.all(topFactions.map(async (faction) => {
+        try {
+            const msgs = await (0, torchsdk_1.getMessages)(connection, faction.mint, msgLimit);
+            for (const msg of msgs.messages) {
+                events.push({
+                    type: 'join', // Messages are trade-bundled, most are buys
+                    faction_mint: faction.mint,
+                    faction_name: faction.name,
+                    agent: msg.sender,
+                    timestamp: msg.timestamp,
+                    signature: msg.signature,
+                    message: msg.memo,
+                });
+            }
+        }
+        catch {
+            // Skip factions with no messages
+        }
+    }));
+    events.sort((a, b) => b.timestamp - a.timestamp);
+    return events.slice(0, opts?.limit ?? 100);
+}
+/**
+ * Global stats: total factions, total agents, total SOL locked.
+ */
+async function getWorldStats(connection) {
+    const [all, rising, ascended] = await Promise.all([
+        (0, torchsdk_1.getTokens)(connection, { limit: 1, status: 'all' }),
+        (0, torchsdk_1.getTokens)(connection, { limit: 100, status: 'bonding' }),
+        (0, torchsdk_1.getTokens)(connection, { limit: 100, status: 'migrated' }),
+    ]);
+    const allFactions = [...rising.tokens, ...ascended.tokens];
+    const totalSolLocked = allFactions.reduce((sum, t) => sum + t.market_cap_sol, 0);
+    // Find most powerful
+    let mostPowerful = null;
+    let maxScore = 0;
+    for (const t of allFactions) {
+        const score = computePowerScoreFromSummary(t);
+        if (score > maxScore) {
+            maxScore = score;
+            mostPowerful = {
+                mint: t.mint,
+                name: t.name,
+                symbol: t.symbol,
+                score,
+                market_cap_sol: t.market_cap_sol,
+                members: t.holders ?? 0,
+                war_chest_sol: 0,
+                rallies: 0,
+                progress_percent: t.progress_percent,
+                status: (0, mappers_1.mapFactionStatus)(t.status),
+            };
+        }
+    }
+    return {
+        total_factions: all.total,
+        rising_factions: rising.total,
+        ascended_factions: ascended.total,
+        total_sol_locked: totalSolLocked,
+        most_powerful: mostPowerful,
+    };
+}
+// ─── Internal Helpers ──────────────────────────────────────────────
+function computePowerScore(t) {
+    const mcWeight = 0.4;
+    const memberWeight = 0.2;
+    const chestWeight = 0.2;
+    const rallyWeight = 0.1;
+    const progressWeight = 0.1;
+    return ((t.market_cap_sol * mcWeight) +
+        ((t.holders ?? 0) * memberWeight) +
+        (t.treasury_sol_balance * chestWeight) +
+        (t.stars * rallyWeight) +
+        (t.progress_percent * progressWeight));
+}
+function computePowerScoreFromSummary(t) {
+    const mcWeight = 0.4;
+    const memberWeight = 0.2;
+    const progressWeight = 0.1;
+    return ((t.market_cap_sol * mcWeight) +
+        ((t.holders ?? 0) * memberWeight) +
+        (t.progress_percent * progressWeight));
+}

package/dist/mappers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pyre Kit Mappers
+ *
+ * Internal mapping functions between Torch SDK types and Pyre game types.
+ */
+import type { TokenStatus, TokenSummary, TokenDetail, TokenStatusFilter, VaultInfo, VaultWalletLinkInfo, TokenMessage, LendingInfo, LoanPositionInfo, LoanPositionWithKey, Holder, HoldersResult, MessagesResult, TokenListResult, AllLoanPositionsResult, BuyTransactionResult, CreateTokenResult } from 'torchsdk';
+import type { FactionStatus, FactionTier, FactionStatusFilter, Strategy, FactionSummary, FactionDetail, Stronghold, AgentLink, Comms, WarChest, WarLoan, WarLoanWithAgent, Member, FactionListResult, MembersResult, CommsResult, AllWarLoansResult, JoinFactionResult, LaunchFactionResult } from './types';
+export declare function mapFactionStatus(status: TokenStatus): FactionStatus;
+export declare function mapTokenStatus(status: FactionStatus): TokenStatus;
+export declare function mapTokenStatusFilter(status: FactionStatusFilter): TokenStatusFilter;
+/** Map SOL target to faction tier */
+export declare function mapFactionTier(sol_target: number): FactionTier;
+/** Infer tier from sol_target in SOL (not lamports) */
+export declare function mapFactionTierFromSol(sol_target: number): FactionTier;
+export declare function mapStrategy(vote: 'burn' | 'return'): Strategy;
+export declare function mapVote(strategy: Strategy): 'burn' | 'return';
+export declare function mapTokenSummaryToFaction(t: TokenSummary): FactionSummary;
+export declare function mapTokenDetailToFaction(t: TokenDetail): FactionDetail;
+export declare function mapVaultToStronghold(v: VaultInfo): Stronghold;
+export declare function mapWalletLinkToAgentLink(l: VaultWalletLinkInfo): AgentLink;
+export declare function mapTokenMessageToComms(m: TokenMessage): Comms;
+export declare function mapLendingToWarChest(l: LendingInfo): WarChest;
+export declare function mapLoanToWarLoan(l: LoanPositionInfo): WarLoan;
+export declare function mapLoanWithKeyToWarLoan(l: LoanPositionWithKey): WarLoanWithAgent;
+export declare function mapHolderToMember(h: Holder): Member;
+export declare function mapTokenListResult(r: TokenListResult): FactionListResult;
+export declare function mapHoldersResult(r: HoldersResult): MembersResult;
+export declare function mapMessagesResult(r: MessagesResult): CommsResult;
+export declare function mapAllLoansResult(r: AllLoanPositionsResult): AllWarLoansResult;
+export declare function mapBuyResult(r: BuyTransactionResult): JoinFactionResult;
+export declare function mapCreateResult(r: CreateTokenResult): LaunchFactionResult;

package/dist/mappers.js

@@ -0,0 +1,258 @@
+"use strict";
+/**
+ * Pyre Kit Mappers
+ *
+ * Internal mapping functions between Torch SDK types and Pyre game types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapFactionStatus = mapFactionStatus;
+exports.mapTokenStatus = mapTokenStatus;
+exports.mapTokenStatusFilter = mapTokenStatusFilter;
+exports.mapFactionTier = mapFactionTier;
+exports.mapFactionTierFromSol = mapFactionTierFromSol;
+exports.mapStrategy = mapStrategy;
+exports.mapVote = mapVote;
+exports.mapTokenSummaryToFaction = mapTokenSummaryToFaction;
+exports.mapTokenDetailToFaction = mapTokenDetailToFaction;
+exports.mapVaultToStronghold = mapVaultToStronghold;
+exports.mapWalletLinkToAgentLink = mapWalletLinkToAgentLink;
+exports.mapTokenMessageToComms = mapTokenMessageToComms;
+exports.mapLendingToWarChest = mapLendingToWarChest;
+exports.mapLoanToWarLoan = mapLoanToWarLoan;
+exports.mapLoanWithKeyToWarLoan = mapLoanWithKeyToWarLoan;
+exports.mapHolderToMember = mapHolderToMember;
+exports.mapTokenListResult = mapTokenListResult;
+exports.mapHoldersResult = mapHoldersResult;
+exports.mapMessagesResult = mapMessagesResult;
+exports.mapAllLoansResult = mapAllLoansResult;
+exports.mapBuyResult = mapBuyResult;
+exports.mapCreateResult = mapCreateResult;
+// ─── Status Mapping ────────────────────────────────────────────────
+const STATUS_MAP = {
+    bonding: 'rising',
+    complete: 'ready',
+    migrated: 'ascended',
+    reclaimed: 'razed',
+};
+const STATUS_REVERSE = {
+    rising: 'bonding',
+    ready: 'complete',
+    ascended: 'migrated',
+    razed: 'reclaimed',
+};
+const STATUS_FILTER_REVERSE = {
+    rising: 'bonding',
+    ready: 'complete',
+    ascended: 'migrated',
+    razed: 'reclaimed',
+    all: 'all',
+};
+function mapFactionStatus(status) {
+    return STATUS_MAP[status];
+}
+function mapTokenStatus(status) {
+    return STATUS_REVERSE[status];
+}
+function mapTokenStatusFilter(status) {
+    return STATUS_FILTER_REVERSE[status];
+}
+// ─── Tier Mapping ──────────────────────────────────────────────────
+/** Map SOL target to faction tier */
+function mapFactionTier(sol_target) {
+    // Torch tiers: spark (≤50 SOL), flame (≤100 SOL), torch (200 SOL default)
+    if (sol_target <= 50_000_000_000)
+        return 'ember'; // ≤50 SOL in lamports
+    if (sol_target <= 100_000_000_000)
+        return 'blaze'; // ≤100 SOL
+    return 'inferno'; // 200 SOL (default)
+}
+/** Infer tier from sol_target in SOL (not lamports) */
+function mapFactionTierFromSol(sol_target) {
+    if (sol_target <= 50)
+        return 'ember';
+    if (sol_target <= 100)
+        return 'blaze';
+    return 'inferno';
+}
+// ─── Strategy Mapping ──────────────────────────────────────────────
+function mapStrategy(vote) {
+    return vote === 'burn' ? 'scorched_earth' : 'fortify';
+}
+function mapVote(strategy) {
+    return strategy === 'scorched_earth' ? 'burn' : 'return';
+}
+// ─── Core Type Mappers ─────────────────────────────────────────────
+function mapTokenSummaryToFaction(t) {
+    return {
+        mint: t.mint,
+        name: t.name,
+        symbol: t.symbol,
+        status: mapFactionStatus(t.status),
+        tier: mapFactionTierFromSol(t.market_cap_sol > 0 ? 200 : 200), // default tier from target
+        price_sol: t.price_sol,
+        market_cap_sol: t.market_cap_sol,
+        progress_percent: t.progress_percent,
+        members: t.holders,
+        created_at: t.created_at,
+        last_activity_at: t.last_activity_at,
+    };
+}
+function mapTokenDetailToFaction(t) {
+    return {
+        mint: t.mint,
+        name: t.name,
+        symbol: t.symbol,
+        description: t.description,
+        image: t.image,
+        status: mapFactionStatus(t.status),
+        tier: mapFactionTierFromSol(t.sol_target),
+        price_sol: t.price_sol,
+        price_usd: t.price_usd,
+        market_cap_sol: t.market_cap_sol,
+        market_cap_usd: t.market_cap_usd,
+        progress_percent: t.progress_percent,
+        sol_raised: t.sol_raised,
+        sol_target: t.sol_target,
+        total_supply: t.total_supply,
+        circulating_supply: t.circulating_supply,
+        tokens_in_curve: t.tokens_in_curve,
+        tokens_in_vote_vault: t.tokens_in_vote_vault,
+        tokens_burned: t.tokens_burned,
+        war_chest_sol: t.treasury_sol_balance,
+        war_chest_tokens: t.treasury_token_balance,
+        total_bought_back: t.total_bought_back,
+        buyback_count: t.buyback_count,
+        votes_scorched_earth: t.votes_burn,
+        votes_fortify: t.votes_return,
+        founder: t.creator,
+        members: t.holders,
+        rallies: t.stars,
+        created_at: t.created_at,
+        last_activity_at: t.last_activity_at,
+        twitter: t.twitter,
+        telegram: t.telegram,
+        website: t.website,
+        founder_verified: t.creator_verified,
+        founder_trust_tier: t.creator_trust_tier,
+        founder_said_name: t.creator_said_name,
+        founder_badge_url: t.creator_badge_url,
+        warnings: t.warnings,
+    };
+}
+function mapVaultToStronghold(v) {
+    return {
+        address: v.address,
+        creator: v.creator,
+        authority: v.authority,
+        sol_balance: v.sol_balance,
+        total_deposited: v.total_deposited,
+        total_withdrawn: v.total_withdrawn,
+        total_spent: v.total_spent,
+        total_received: v.total_received,
+        linked_agents: v.linked_wallets,
+        created_at: v.created_at,
+    };
+}
+function mapWalletLinkToAgentLink(l) {
+    return {
+        address: l.address,
+        stronghold: l.vault,
+        wallet: l.wallet,
+        linked_at: l.linked_at,
+    };
+}
+function mapTokenMessageToComms(m) {
+    return {
+        signature: m.signature,
+        memo: m.memo,
+        sender: m.sender,
+        timestamp: m.timestamp,
+        sender_verified: m.sender_verified,
+        sender_trust_tier: m.sender_trust_tier,
+        sender_said_name: m.sender_said_name,
+        sender_badge_url: m.sender_badge_url,
+    };
+}
+function mapLendingToWarChest(l) {
+    return {
+        interest_rate_bps: l.interest_rate_bps,
+        max_ltv_bps: l.max_ltv_bps,
+        liquidation_threshold_bps: l.liquidation_threshold_bps,
+        liquidation_bonus_bps: l.liquidation_bonus_bps,
+        utilization_cap_bps: l.utilization_cap_bps,
+        borrow_share_multiplier: l.borrow_share_multiplier,
+        total_sol_lent: l.total_sol_lent,
+        active_loans: l.active_loans,
+        war_chest_sol_available: l.treasury_sol_available,
+        warnings: l.warnings,
+    };
+}
+function mapLoanToWarLoan(l) {
+    return {
+        collateral_amount: l.collateral_amount,
+        borrowed_amount: l.borrowed_amount,
+        accrued_interest: l.accrued_interest,
+        total_owed: l.total_owed,
+        collateral_value_sol: l.collateral_value_sol,
+        current_ltv_bps: l.current_ltv_bps,
+        health: l.health,
+        warnings: l.warnings,
+    };
+}
+function mapLoanWithKeyToWarLoan(l) {
+    return {
+        ...mapLoanToWarLoan(l),
+        borrower: l.borrower,
+    };
+}
+function mapHolderToMember(h) {
+    return {
+        address: h.address,
+        balance: h.balance,
+        percentage: h.percentage,
+    };
+}
+// ─── Result Mappers ────────────────────────────────────────────────
+function mapTokenListResult(r) {
+    return {
+        factions: r.tokens.map(mapTokenSummaryToFaction),
+        total: r.total,
+        limit: r.limit,
+        offset: r.offset,
+    };
+}
+function mapHoldersResult(r) {
+    return {
+        members: r.holders.map(mapHolderToMember),
+        total_members: r.total_holders,
+    };
+}
+function mapMessagesResult(r) {
+    return {
+        comms: r.messages.map(mapTokenMessageToComms),
+        total: r.total,
+    };
+}
+function mapAllLoansResult(r) {
+    return {
+        positions: r.positions.map(mapLoanWithKeyToWarLoan),
+        pool_price_sol: r.pool_price_sol,
+    };
+}
+function mapBuyResult(r) {
+    return {
+        transaction: r.transaction,
+        additionalTransactions: r.additionalTransactions,
+        message: r.message,
+        migrationTransaction: r.migrationTransaction,
+    };
+}
+function mapCreateResult(r) {
+    return {
+        transaction: r.transaction,
+        additionalTransactions: r.additionalTransactions,
+        message: r.message,
+        mint: r.mint,
+        mintKeypair: r.mintKeypair,
+    };
+}