@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/common/src/services/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseAccountClient"), exports);
+__exportStar(require("./baseIxBuilderService"), exports);
+__exportStar(require("./dataCache"), exports);
+__exportStar(require("./lutManager"), exports);
+__exportStar(require("./mints"), exports);
+__exportStar(require("./swap"), exports);
+__exportStar(require("./token"), exports);
+__exportStar(require("./transactionSender"), exports);

package/dist/shared/common/src/services/lutManager.d.ts

@@ -0,0 +1,31 @@
+import type { Address, Rpc, SolanaRpcApi, TransactionSigner } from "@solana/kit";
+import { type CacheTtlConfig } from "./dataCache";
+export type LookupTableInput = {
+    address: Address;
+    addresses: Address[];
+};
+export declare class LutManager {
+    private cache;
+    constructor(cacheTtlConfig?: CacheTtlConfig);
+    /**
+     * Fetch a single lookup table's data, with caching.
+     */
+    private fetchLookupTable;
+    /**
+     * Fetch address lookup table data for the given addresses, with caching.
+     */
+    getLookupTableInputs(rpc: Rpc<SolanaRpcApi>, lookupTableAddresses: Address[]): Promise<LookupTableInput[]>;
+    private addAddressesIfNeeded;
+    private deriveLookupTableAddress;
+    updateLookupTable(signer: TransactionSigner, rpc: Rpc<SolanaRpcApi>, accounts: Address[], existingLookupTableAddress?: Address): Promise<Address>;
+    /**
+     * Clear all cached lookup table data.
+     */
+    clearCache(): void;
+    /**
+     * Clear cached data for a specific lookup table.
+     */
+    clearLookupTableCache(address: Address): void;
+}
+/** Global LutManager instance for shared use across the application. */
+export declare const lutManager: LutManager;

package/dist/shared/common/src/services/lutManager.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lutManager = exports.LutManager = void 0;
+const kit_1 = require("@solana/kit");
+const address_lookup_table_1 = require("@solana-program/address-lookup-table");
+const utils_1 = require("../utils");
+const dataCache_1 = require("./dataCache");
+const constants_1 = require("../constants");
+const LUT_CACHE_CATEGORY = "lookupTable";
+class LutManager {
+    constructor(cacheTtlConfig) {
+        this.cache = new dataCache_1.DataCache({
+            defaultTtlMs: cacheTtlConfig?.defaultTtlMs ?? 60000 * 15,
+            categoryTtlMs: cacheTtlConfig?.categoryTtlMs,
+        });
+    }
+    /**
+     * Fetch a single lookup table's data, with caching.
+     */
+    async fetchLookupTable(rpc, address) {
+        const { data } = await this.cache.getDataOrThrow(async () => {
+            const table = await (0, address_lookup_table_1.fetchAddressLookupTable)(rpc, address);
+            return {
+                address,
+                addresses: table.data.addresses,
+            };
+        }, LUT_CACHE_CATEGORY, address);
+        return data;
+    }
+    /**
+     * Fetch address lookup table data for the given addresses, with caching.
+     */
+    async getLookupTableInputs(rpc, lookupTableAddresses) {
+        return Promise.all(lookupTableAddresses.map((address) => this.fetchLookupTable(rpc, address)));
+    }
+    async addAddressesIfNeeded(signer, rpc, lookupTableAddress, existingAddresses, addressesToAdd) {
+        const existingSet = new Set(existingAddresses);
+        const addresses = addressesToAdd.filter((x) => !existingSet.has(x));
+        if (addresses.length > 0) {
+            const batches = (0, utils_1.getBatches)(addresses, 20);
+            for (const addressBatch of batches) {
+                const extendIx = (0, address_lookup_table_1.getExtendLookupTableInstruction)({
+                    address: lookupTableAddress,
+                    authority: signer,
+                    payer: signer,
+                    addresses: addressBatch,
+                });
+                await (0, utils_1.signSendAndConfirmTransaction)(rpc, signer, [extendIx]);
+            }
+        }
+    }
+    async deriveLookupTableAddress(signerAddress, recentSlot) {
+        const addressEncoder = (0, kit_1.getAddressEncoder)();
+        const u64Encoder = (0, kit_1.getU64Encoder)();
+        return await (0, kit_1.getProgramDerivedAddress)({
+            programAddress: address_lookup_table_1.ADDRESS_LOOKUP_TABLE_PROGRAM_ADDRESS,
+            seeds: [addressEncoder.encode(signerAddress), u64Encoder.encode(recentSlot)],
+        });
+    }
+    async updateLookupTable(signer, rpc, accounts, existingLookupTableAddress) {
+        if (existingLookupTableAddress === constants_1.DEFAULT_PUBLIC_KEY) {
+            existingLookupTableAddress = undefined;
+        }
+        let lookupTableAddress;
+        let existingAccounts;
+        if (existingLookupTableAddress) {
+            lookupTableAddress = existingLookupTableAddress;
+            const lutInput = await this.fetchLookupTable(rpc, lookupTableAddress);
+            existingAccounts = lutInput.addresses;
+        }
+        else {
+            const maxAttempts = 3;
+            let lastError;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                const slot = await (0, utils_1.getSlot)(rpc);
+                const lutPda = await this.deriveLookupTableAddress(signer.address, slot);
+                const createLutIx = (0, address_lookup_table_1.getCreateLookupTableInstruction)({
+                    address: lutPda,
+                    authority: signer,
+                    recentSlot: slot,
+                });
+                try {
+                    await (0, utils_1.signSendAndConfirmTransaction)(rpc, signer, [createLutIx], {
+                        hideFailureInfo: attempt < maxAttempts,
+                    });
+                    lookupTableAddress = lutPda[0];
+                    console.log(`Created new lookup table: ${lookupTableAddress}`);
+                    this.cache.setCache(LUT_CACHE_CATEGORY, lookupTableAddress, {
+                        address: lookupTableAddress,
+                        addresses: [],
+                    });
+                    lastError = undefined;
+                    break;
+                }
+                catch (e) {
+                    lastError = e;
+                    const errorStr = String(e);
+                    const logsStr = e instanceof utils_1.TransactionError ? e.programLogs.join("\n") : "";
+                    const isStaleSlot = errorStr.includes("is not a recent slot") || logsStr.includes("is not a recent slot");
+                    if (isStaleSlot && attempt < maxAttempts) {
+                        console.warn(`LUT creation failed (stale slot ${slot}), retrying (${attempt}/${maxAttempts})...`);
+                        await new Promise((r) => setTimeout(r, 2000));
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            if (lastError)
+                throw lastError;
+            lookupTableAddress = lookupTableAddress;
+            existingAccounts = [];
+        }
+        await this.addAddressesIfNeeded(signer, rpc, lookupTableAddress, existingAccounts, (0, utils_1.deduplicateAccounts)(accounts).filter((x) => x !== constants_1.DEFAULT_PUBLIC_KEY));
+        // Invalidate cache for this LUT since we just modified it
+        this.clearLookupTableCache(lookupTableAddress);
+        return lookupTableAddress;
+    }
+    /**
+     * Clear all cached lookup table data.
+     */
+    clearCache() {
+        this.cache.clearAllCache();
+    }
+    /**
+     * Clear cached data for a specific lookup table.
+     */
+    clearLookupTableCache(address) {
+        this.cache.clearCacheEntry(LUT_CACHE_CATEGORY, address);
+    }
+}
+exports.LutManager = LutManager;
+/** Global LutManager instance for shared use across the application. */
+exports.lutManager = new LutManager();

package/dist/shared/common/src/services/mints/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { MintConfig } from "./types";
+export declare const DEFAULT_MINTS: MintConfig[];

package/dist/shared/common/src/services/mints/defaults.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MINTS = void 0;
+const kit_1 = require("@solana/kit");
+exports.DEFAULT_MINTS = [
+    // Risk assets
+    {
+        address: (0, kit_1.address)("So11111111111111111111111111111111111111112"),
+        symbol: "SOL",
+        name: "Solana",
+        decimals: 9,
+        assetType: "Standard",
+    },
+    {
+        address: (0, kit_1.address)("3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh"),
+        symbol: "wBTC",
+        name: "Wrapped Bitcoin",
+        decimals: 8,
+        assetType: "Standard",
+    },
+    {
+        address: (0, kit_1.address)("cbbtcf3aa214zXHbiAZQwf4122FBYbraNdFqgw4iMij"),
+        symbol: "cbBTC",
+        name: "Coinbase Wrapped Bitcoin",
+        decimals: 8,
+        assetType: "Standard",
+    },
+    {
+        address: (0, kit_1.address)("7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"),
+        symbol: "wETH",
+        name: "Wrapped Ethereum",
+        decimals: 8,
+        assetType: "Standard",
+    },
+    {
+        address: (0, kit_1.address)("27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4"),
+        symbol: "JLP",
+        name: "Jupiter Perps LP",
+        decimals: 6,
+        assetType: "Standard",
+    },
+    {
+        address: (0, kit_1.address)("XsoCS1TfEyfFhfvj8EtZ528L3CaKBDBRqRapnBbDF2W"),
+        symbol: "SPYx",
+        name: "SP500 xStock",
+        decimals: 8,
+        assetType: "Standard",
+        isToken2022: true,
+    },
+    {
+        address: (0, kit_1.address)("Xs8S1uUs1zvS2p7iwtsG3b6fkhpvmwz4GYU3gWAmWHZ"),
+        symbol: "QQQx",
+        name: "Nasdaq xStock",
+        decimals: 8,
+        assetType: "Standard",
+        isToken2022: true,
+    },
+    // Stablecoins
+    {
+        address: (0, kit_1.address)("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+        symbol: "USDC",
+        name: "USD Coin",
+        decimals: 6,
+        assetType: "Stablecoin",
+    },
+    {
+        address: (0, kit_1.address)("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"),
+        symbol: "USDT",
+        name: "Tether USD",
+        decimals: 6,
+        assetType: "Stablecoin",
+    },
+    {
+        address: (0, kit_1.address)("USDSwr9ApdHk5bvJKMjzff41FfuX8bSxdKcR81vTwcA"),
+        symbol: "USDS",
+        decimals: 6,
+        assetType: "Stablecoin",
+    },
+    {
+        address: (0, kit_1.address)("2u1tszSeqZ3qBWF3uNGPFc8TzMk2tdiwknnRMWGWjGWH"),
+        symbol: "USDG",
+        name: "Global Dollar",
+        decimals: 6,
+        assetType: "Stablecoin",
+        isToken2022: true,
+    },
+    {
+        address: (0, kit_1.address)("2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo"),
+        symbol: "PYUSD",
+        name: "PayPal USD",
+        decimals: 6,
+        assetType: "Stablecoin",
+        isToken2022: true,
+    },
+    {
+        address: (0, kit_1.address)("CASHx9KJUStyftLFWGvEVf59SGeG9sh5FfcnZMVPCASH"),
+        symbol: "CASH",
+        decimals: 6,
+        assetType: "Stablecoin",
+        isToken2022: true,
+    },
+    {
+        address: (0, kit_1.address)("USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB"),
+        symbol: "USD1",
+        decimals: 6,
+        assetType: "Stablecoin",
+    },
+    // LSTs
+    {
+        address: (0, kit_1.address)("J1toso1uCk3RLmjorhTtrVwY9HJ7X8V9yYac6Y7kGCPn"),
+        symbol: "JitoSOL",
+        name: "Jito SOL",
+        decimals: 9,
+        assetType: "LST",
+    },
+    {
+        address: (0, kit_1.address)("jupSoLaHXQiZZTSfEWMTRRgpnyFm8f6sZdosWBjx93v"),
+        symbol: "JupSOL",
+        name: "Jupiter Staked SOL",
+        decimals: 9,
+        assetType: "LST",
+    },
+    {
+        address: (0, kit_1.address)("sctmB7GPi5L2Q5G9tUSzXvhZ4YiDMEGcRov9KfArQpx"),
+        symbol: "dfdvSOL",
+        name: "DeFi Development Corp SOL",
+        decimals: 9,
+        assetType: "LST",
+    },
+    // Yield bearing assets
+    {
+        address: (0, kit_1.address)("star9agSpjiFe3M49B3RniVU4CMBBEK3Qnaqn3RGiFM"),
+        symbol: "USD*",
+        name: "USD Star",
+        decimals: 6,
+        assetType: "YBA",
+    },
+    {
+        address: (0, kit_1.address)("3AJYCjrhKitmBd8tRUurPA5dGHCAQh6A8L9DkuSC37Rm"),
+        symbol: "USD*-J",
+        name: "USD Star Junior",
+        decimals: 6,
+        assetType: "YBA",
+    },
+    {
+        address: (0, kit_1.address)("59obFNBzyTBGowrkif5uK7ojS58vsuWz3ZCvg6tfZAGw"),
+        symbol: "PST",
+        name: "PayFi Strategy Token",
+        decimals: 6,
+        assetType: "YBA",
+    },
+];

package/dist/shared/common/src/services/mints/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./registry";
+export * from "./defaults";
+export * from "./symbols";

package/dist/shared/common/src/services/mints/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./registry"), exports);
+__exportStar(require("./defaults"), exports);
+__exportStar(require("./symbols"), exports);

package/dist/shared/common/src/services/mints/registry.d.ts

@@ -0,0 +1,70 @@
+import type { Address } from "@solana/kit";
+import type { AssetType, MintConfig, MintInfo, MintRegistryOptions } from "./types";
+import { MintIdentifier } from "../../types";
+/**
+ * Registry for token mint information.
+ *
+ * Provides a unified interface to query token metadata by address or symbol.
+ * Supports both well-known tokens and custom configurations.
+ *
+ * @example
+ * ```typescript
+ * // Create registry with defaults
+ * const mints = new MintRegistry();
+ *
+ * // Query by symbol
+ * const usdc = mints.get("USDC");
+ * console.log(usdc?.decimals); // 6
+ *
+ * // Query by address
+ * const token = mints.get(someAddress);
+ * console.log(token?.symbol); // "USDC"
+ *
+ * // Add custom tokens
+ * const mints = new MintRegistry({
+ *   custom: [{ address: "...", symbol: "MY_TOKEN", decimals: 9 }]
+ * });
+ * ```
+ */
+export declare class MintRegistry {
+    private byAddress;
+    private bySymbol;
+    constructor(options?: MintRegistryOptions);
+    /**
+     * Register a new mint configuration.
+     * Overwrites existing entries with the same address or symbol.
+     */
+    register(config: MintConfig): void;
+    /**
+     * Get mint information by address or symbol.
+     *
+     * @param mint - Mint address or token symbol (case-insensitive)
+     * @returns MintInfo if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * mints.get("USDC")?.decimals  // 6
+     * mints.get(usdcAddress)?.symbol  // "USDC"
+     * ```
+     */
+    get(mint: MintIdentifier): MintInfo | undefined;
+    all(): MintInfo[];
+    standardAssets(): MintInfo[];
+    stablecoins(): MintInfo[];
+    lsts(): MintInfo[];
+    yieldBearingAssets(): MintInfo[];
+    filterAssetsByType(assetType: AssetType): MintInfo[];
+    symbols(): string[];
+    addresses(): Address[];
+}
+/**
+ * Default MintRegistry instance with well-known tokens.
+ * Use this for quick access without creating a new instance.
+ *
+ * @example
+ * ```typescript
+ * import { mints } from "./services/mints";
+ * const usdc = mints.get("USDC");
+ * ```
+ */
+export declare const mints: MintRegistry;

package/dist/shared/common/src/services/mints/registry.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mints = exports.MintRegistry = void 0;
+const token_1 = require("@solana-program/token");
+const token_2022_1 = require("@solana-program/token-2022");
+const defaults_1 = require("./defaults");
+const numbers_1 = require("../../utils/numbers");
+/**
+ * Registry for token mint information.
+ *
+ * Provides a unified interface to query token metadata by address or symbol.
+ * Supports both well-known tokens and custom configurations.
+ *
+ * @example
+ * ```typescript
+ * // Create registry with defaults
+ * const mints = new MintRegistry();
+ *
+ * // Query by symbol
+ * const usdc = mints.get("USDC");
+ * console.log(usdc?.decimals); // 6
+ *
+ * // Query by address
+ * const token = mints.get(someAddress);
+ * console.log(token?.symbol); // "USDC"
+ *
+ * // Add custom tokens
+ * const mints = new MintRegistry({
+ *   custom: [{ address: "...", symbol: "MY_TOKEN", decimals: 9 }]
+ * });
+ * ```
+ */
+class MintRegistry {
+    constructor(options = {}) {
+        this.byAddress = new Map();
+        this.bySymbol = new Map();
+        const { includeDefaults = true, custom = [] } = options;
+        if (includeDefaults) {
+            for (const config of defaults_1.DEFAULT_MINTS) {
+                this.register(config);
+            }
+        }
+        for (const config of custom) {
+            this.register(config);
+        }
+    }
+    /**
+     * Register a new mint configuration.
+     * Overwrites existing entries with the same address or symbol.
+     */
+    register(config) {
+        const mintInfo = {
+            ...config,
+            tokenProgram: config.isToken2022 ? token_2022_1.TOKEN_2022_PROGRAM_ADDRESS : token_1.TOKEN_PROGRAM_ADDRESS,
+            toUiAmount: (amount) => (0, numbers_1.toUiAmount)(amount, config.decimals),
+            fromUiAmount: (amount) => (0, numbers_1.fromUiAmount)(amount, config.decimals),
+        };
+        this.byAddress.set(config.address, mintInfo);
+        this.bySymbol.set(config.symbol.toUpperCase(), mintInfo);
+    }
+    /**
+     * Get mint information by address or symbol.
+     *
+     * @param mint - Mint address or token symbol (case-insensitive)
+     * @returns MintInfo if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * mints.get("USDC")?.decimals  // 6
+     * mints.get(usdcAddress)?.symbol  // "USDC"
+     * ```
+     */
+    get(mint) {
+        const upperKey = mint.toUpperCase();
+        const bySymbol = this.bySymbol.get(upperKey);
+        if (bySymbol) {
+            return bySymbol;
+        }
+        return this.byAddress.get(mint);
+    }
+    all() {
+        return Array.from(this.byAddress.values());
+    }
+    standardAssets() {
+        return this.filterAssetsByType("Standard");
+    }
+    stablecoins() {
+        return this.filterAssetsByType("Stablecoin");
+    }
+    lsts() {
+        return this.filterAssetsByType("LST");
+    }
+    yieldBearingAssets() {
+        return this.filterAssetsByType("YBA");
+    }
+    filterAssetsByType(assetType) {
+        return Array.from(this.byAddress.values()).filter((x) => x.assetType === assetType);
+    }
+    symbols() {
+        return Array.from(this.bySymbol.keys());
+    }
+    addresses() {
+        return Array.from(this.byAddress.keys());
+    }
+}
+exports.MintRegistry = MintRegistry;
+/**
+ * Default MintRegistry instance with well-known tokens.
+ * Use this for quick access without creating a new instance.
+ *
+ * @example
+ * ```typescript
+ * import { mints } from "./services/mints";
+ * const usdc = mints.get("USDC");
+ * ```
+ */
+exports.mints = new MintRegistry();

package/dist/shared/common/src/services/mints/symbols.d.ts

@@ -0,0 +1,6 @@
+import type { MintIdentifier } from "../../types";
+import type { MintRegistry } from "./registry";
+/** Human-readable token symbol from the registry, or a short address prefix when unknown. */
+export declare function mintSymbol(mint: MintIdentifier, registry?: MintRegistry): string;
+/** Pair label for two mints, e.g. `cbBTC/PYUSD`. */
+export declare function formatMintPair(leftMint: MintIdentifier, rightMint: MintIdentifier, registry?: MintRegistry): string;

package/dist/shared/common/src/services/mints/symbols.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintSymbol = mintSymbol;
+exports.formatMintPair = formatMintPair;
+const registry_1 = require("./registry");
+/** Human-readable token symbol from the registry, or a short address prefix when unknown. */
+function mintSymbol(mint, registry = registry_1.mints) {
+    return registry.get(mint)?.symbol ?? String(mint).slice(0, 6);
+}
+/** Pair label for two mints, e.g. `cbBTC/PYUSD`. */
+function formatMintPair(leftMint, rightMint, registry = registry_1.mints) {
+    return `${mintSymbol(leftMint, registry)}/${mintSymbol(rightMint, registry)}`;
+}

package/dist/shared/common/src/services/mints/types.d.ts

@@ -0,0 +1,30 @@
+import type { Address } from "@solana/kit";
+import { BN } from "@anchor-lang/core";
+export type AssetType = "LST" | "YBA" | "Stablecoin" | "Standard";
+export interface MintConfig {
+    address: Address;
+    symbol: string;
+    decimals: number;
+    name?: string;
+    assetType: AssetType;
+    isToken2022?: boolean;
+}
+/**
+ * Runtime information for a token mint.
+ * Extends MintConfig with methods for dynamic data.
+ */
+export interface MintInfo extends MintConfig {
+    tokenProgram: Address;
+    /**
+     * Get the current APY for this token (LSTs & YBAs only).
+     * Returns undefined for non-LST tokens.
+     */
+    getApy?: () => Promise<number | undefined>;
+    toUiAmount: (amount: bigint | BN) => number;
+    fromUiAmount: (amount: number) => BN;
+}
+export interface MintRegistryOptions {
+    /** Default: true */
+    includeDefaults?: boolean;
+    custom?: MintConfig[];
+}

package/dist/shared/common/src/services/mints/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/common/src/services/swap/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./swapClientBase";
+export * from "./routableSwapClient";
+export * from "./swapRouting";

package/dist/shared/common/src/services/swap/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./swapClientBase"), exports);
+__exportStar(require("./routableSwapClient"), exports);
+__exportStar(require("./swapRouting"), exports);