@tangle-network/starter-foundry 0.1.0

package/registry/layers/capability/solana-keeper/files/keeper-hooks.ts

@@ -0,0 +1,90 @@
+// Types
+
+export interface Position {
+  account: string
+  market: string
+  collateral: number
+  debt: number
+  liquidationThreshold: number
+}
+
+export interface PriceData {
+  asset: string
+  price: number
+  confidence: number
+  timestamp: number
+}
+
+export interface LiquidationParams {
+  account: string
+  market: string
+  debtToRepay: number
+  collateralToSeize: number
+  incentive: number
+  programId: string
+  keys: Array<{ pubkey: string; isSigner: boolean; isWritable: boolean }>
+}
+
+// Implementation
+
+export function checkLiquidatable(
+  position: Position,
+  priceData: PriceData,
+): { liquidatable: boolean; healthFactor: number; shortfall: number } {
+  const collateralValue = position.collateral * priceData.price
+  const healthFactor = position.debt > 0
+    ? collateralValue / (position.debt * position.liquidationThreshold)
+    : Infinity
+
+  const shortfall = healthFactor < 1
+    ? position.debt - collateralValue / position.liquidationThreshold
+    : 0
+
+  return {
+    liquidatable: healthFactor < 1,
+    healthFactor,
+    shortfall,
+  }
+}
+
+export function buildLiquidationTx(
+  position: Position,
+  market: string,
+  priceData: PriceData,
+): LiquidationParams {
+  const { shortfall } = checkLiquidatable(position, priceData)
+
+  // Liquidate up to 50% of the debt (close factor)
+  const closeFactor = 0.5
+  const debtToRepay = Math.min(position.debt * closeFactor, position.debt)
+
+  // Liquidation incentive: 5% bonus on collateral seized
+  const incentive = 0.05
+  const collateralToSeize = (debtToRepay / priceData.price) * (1 + incentive)
+
+  return {
+    account: position.account,
+    market,
+    debtToRepay,
+    collateralToSeize,
+    incentive,
+    programId: market,
+    keys: [
+      { pubkey: position.account, isSigner: false, isWritable: true },
+      { pubkey: market, isSigner: false, isWritable: true },
+      // Liquidator account would be added at signing time
+    ],
+  }
+}
+
+export function calculatePriority(healthFactor: number, positionSize: number): number {
+  // Lower health factor = higher priority (more urgent)
+  // Larger position = higher priority (more profitable)
+  if (healthFactor >= 1) return 0
+
+  const urgency = 1 / Math.max(healthFactor, 0.01)
+  const sizeScore = Math.log10(Math.max(positionSize, 1))
+
+  // Weighted combination: urgency matters more than size
+  return urgency * 0.7 + sizeScore * 0.3
+}

package/registry/layers/capability/solana-keeper/files/market-feed.json

@@ -0,0 +1,7 @@
+{
+  "ticks": [
+    { "symbol": "SOL-PERP", "price": 172.4 },
+    { "symbol": "BTC-PERP", "price": 68421.2 },
+    { "symbol": "JUP-SOL", "price": 0.0152 }
+  ]
+}

package/registry/layers/capability/solana-keeper/manifest.json

@@ -0,0 +1,18 @@
+{
+  "id": "solana-keeper",
+  "description": "Adds keeper-oriented feed and lifecycle hooks for Solana workers.",
+  "appliesTo": ["worker-job"],
+  "files": [
+    {
+      "source": "files/keeper-hooks.ts",
+      "target": "keeper-hooks.ts"
+    },
+    {
+      "source": "files/market-feed.json",
+      "target": "market-feed.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": ["keeper-hooks.ts", "market-feed.json"]
+  }
+}

package/registry/layers/capability/solana-launchpad/files/README.md

@@ -0,0 +1,5 @@
+# Solana Launchpad Notes
+
+- Keep launch creation, contribution, and claim flows isolated.
+- Bias the agent toward vesting and anti-bot configuration in a separate config layer.
+- Keep launch calendar and participant UI in the web lane.

package/registry/layers/capability/solana-launchpad/files/lib.rs

@@ -0,0 +1,52 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProgramError {
+    InvalidInstruction,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Instruction {
+    CreateLaunch,
+    Contribute,
+    ClaimTokens,
+}
+
+impl Instruction {
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        match input.first().copied() {
+            Some(0) => Ok(Self::CreateLaunch),
+            Some(1) => Ok(Self::Contribute),
+            Some(2) => Ok(Self::ClaimTokens),
+            _ => Err(ProgramError::InvalidInstruction),
+        }
+    }
+}
+
+pub fn process_instruction(input: &[u8]) -> Result<&'static str, ProgramError> {
+    match Instruction::unpack(input)? {
+        Instruction::CreateLaunch => Ok("create_launch"),
+        Instruction::Contribute => Ok("contribute"),
+        Instruction::ClaimTokens => Ok("claim_tokens"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{process_instruction, Instruction, ProgramError};
+
+    #[test]
+    fn unpacks_launchpad_instructions() {
+        assert_eq!(Instruction::unpack(&[0]), Ok(Instruction::CreateLaunch));
+        assert_eq!(Instruction::unpack(&[1]), Ok(Instruction::Contribute));
+        assert_eq!(Instruction::unpack(&[2]), Ok(Instruction::ClaimTokens));
+    }
+
+    #[test]
+    fn rejects_unknown_instruction() {
+        assert_eq!(Instruction::unpack(&[9]), Err(ProgramError::InvalidInstruction));
+    }
+
+    #[test]
+    fn processes_claims() {
+        assert_eq!(process_instruction(&[2]), Ok("claim_tokens"));
+    }
+}

package/registry/layers/capability/solana-launchpad/files/sale-config.json

@@ -0,0 +1,5 @@
+{
+  "product": "launchpad",
+  "saleModes": ["fixed-price", "dutch-auction", "bonding-curve"],
+  "postSale": ["lpProvision", "lpLock", "vesting"]
+}

package/registry/layers/capability/solana-launchpad/manifest.json

@@ -0,0 +1,35 @@
+{
+  "id": "solana-launchpad",
+  "description": "Specializes a Solana program lane for token sale and vesting flows.",
+  "appliesTo": [
+    "solana-program"
+  ],
+  "files": [
+    {
+      "source": "files/lib.rs",
+      "target": "src/lib.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "client/README.md"
+    },
+    {
+      "source": "files/sale-config.json",
+      "target": "sale-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "src/lib.rs",
+      "sale-config.json",
+      "client/README.md"
+    ]
+  },
+  "keywords": [
+    "launchpad",
+    "fair launch",
+    "token launchpad",
+    "bonding curve",
+    "claim portal"
+  ]
+}

package/registry/layers/capability/solana-nft/files/README.md

@@ -0,0 +1,5 @@
+# Solana NFT Notes
+
+- Keep listing, offer, auction, and royalty settlement instructions explicit.
+- Pair with an API lane for ranking, collection activity, and compressed NFT metadata.
+- Keep gallery and creator tooling in the web lane.

package/registry/layers/capability/solana-nft/files/lib.rs

@@ -0,0 +1,52 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProgramError {
+    InvalidInstruction,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Instruction {
+    CreateListing,
+    AcceptOffer,
+    SettleAuction,
+}
+
+impl Instruction {
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        match input.first().copied() {
+            Some(0) => Ok(Self::CreateListing),
+            Some(1) => Ok(Self::AcceptOffer),
+            Some(2) => Ok(Self::SettleAuction),
+            _ => Err(ProgramError::InvalidInstruction),
+        }
+    }
+}
+
+pub fn process_instruction(input: &[u8]) -> Result<&'static str, ProgramError> {
+    match Instruction::unpack(input)? {
+        Instruction::CreateListing => Ok("create_listing"),
+        Instruction::AcceptOffer => Ok("accept_offer"),
+        Instruction::SettleAuction => Ok("settle_auction"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{process_instruction, Instruction, ProgramError};
+
+    #[test]
+    fn unpacks_marketplace_instructions() {
+        assert_eq!(Instruction::unpack(&[0]), Ok(Instruction::CreateListing));
+        assert_eq!(Instruction::unpack(&[1]), Ok(Instruction::AcceptOffer));
+        assert_eq!(Instruction::unpack(&[2]), Ok(Instruction::SettleAuction));
+    }
+
+    #[test]
+    fn rejects_unknown_instruction() {
+        assert_eq!(Instruction::unpack(&[9]), Err(ProgramError::InvalidInstruction));
+    }
+
+    #[test]
+    fn processes_listing_creation() {
+        assert_eq!(process_instruction(&[0]), Ok("create_listing"));
+    }
+}

package/registry/layers/capability/solana-nft/files/marketplace-config.json

@@ -0,0 +1,4 @@
+{
+  "product": "nft-marketplace",
+  "features": ["auctions", "offers", "royalties", "compressedNFTs", "bundleSales"]
+}

package/registry/layers/capability/solana-nft/manifest.json

@@ -0,0 +1,34 @@
+{
+  "id": "solana-nft",
+  "description": "Specializes a Solana program lane for marketplace and collection flows.",
+  "appliesTo": [
+    "solana-program"
+  ],
+  "files": [
+    {
+      "source": "files/lib.rs",
+      "target": "src/lib.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "client/README.md"
+    },
+    {
+      "source": "files/marketplace-config.json",
+      "target": "marketplace-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "src/lib.rs",
+      "marketplace-config.json",
+      "client/README.md"
+    ]
+  },
+  "keywords": [
+    "nft marketplace",
+    "compressed nfts",
+    "royalty enforcement",
+    "bundle sales"
+  ]
+}

package/registry/layers/capability/solana-perps/files/README.md

@@ -0,0 +1,5 @@
+# Solana Perps Notes
+
+- Bias the agent toward PDA-backed margin accounts and explicit liquidation paths.
+- Pair the program lane with a worker or API lane for feeds, funding, and risk snapshots.
+- Keep TradingView and wallet adapter concerns in the web lane.

package/registry/layers/capability/solana-perps/files/lib.rs

@@ -0,0 +1,52 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProgramError {
+    InvalidInstruction,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Instruction {
+    InitializePerpMarket,
+    OpenPosition,
+    LiquidatePosition,
+}
+
+impl Instruction {
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        match input.first().copied() {
+            Some(0) => Ok(Self::InitializePerpMarket),
+            Some(1) => Ok(Self::OpenPosition),
+            Some(2) => Ok(Self::LiquidatePosition),
+            _ => Err(ProgramError::InvalidInstruction),
+        }
+    }
+}
+
+pub fn process_instruction(input: &[u8]) -> Result<&'static str, ProgramError> {
+    match Instruction::unpack(input)? {
+        Instruction::InitializePerpMarket => Ok("initialize_perp_market"),
+        Instruction::OpenPosition => Ok("open_position"),
+        Instruction::LiquidatePosition => Ok("liquidate_position"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{process_instruction, Instruction, ProgramError};
+
+    #[test]
+    fn unpacks_perps_instructions() {
+        assert_eq!(Instruction::unpack(&[0]), Ok(Instruction::InitializePerpMarket));
+        assert_eq!(Instruction::unpack(&[1]), Ok(Instruction::OpenPosition));
+        assert_eq!(Instruction::unpack(&[2]), Ok(Instruction::LiquidatePosition));
+    }
+
+    #[test]
+    fn rejects_unknown_instruction() {
+        assert_eq!(Instruction::unpack(&[9]), Err(ProgramError::InvalidInstruction));
+    }
+
+    #[test]
+    fn processes_open_position() {
+        assert_eq!(process_instruction(&[1]), Ok("open_position"));
+    }
+}

package/registry/layers/capability/solana-perps/files/market-config.json

@@ -0,0 +1,6 @@
+{
+  "product": "perpetuals",
+  "oracle": "pyth",
+  "riskEngine": ["twap", "maintenanceMargin", "autoDeleveraging"],
+  "collateral": "USDC"
+}

package/registry/layers/capability/solana-perps/manifest.json

@@ -0,0 +1,22 @@
+{
+  "id": "solana-perps",
+  "description": "Specializes a Solana program lane for perpetuals and liquidation flows.",
+  "appliesTo": ["solana-program"],
+  "files": [
+    {
+      "source": "files/lib.rs",
+      "target": "src/lib.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "client/README.md"
+    },
+    {
+      "source": "files/market-config.json",
+      "target": "market-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/lib.rs", "market-config.json", "client/README.md"]
+  }
+}

package/registry/layers/capability/solana-prediction/files/README.md

@@ -0,0 +1,5 @@
+# Solana Prediction Notes
+
+- Keep market creation, trading, resolution, and disputes explicit.
+- Pair with API and worker lanes for oracle ingestion and dispute timing.
+- Keep browser, leaderboard, and position management in the web lane.

package/registry/layers/capability/solana-prediction/files/lib.rs

@@ -0,0 +1,52 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProgramError {
+    InvalidInstruction,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Instruction {
+    CreateMarket,
+    PlaceOrder,
+    ResolveMarket,
+}
+
+impl Instruction {
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        match input.first().copied() {
+            Some(0) => Ok(Self::CreateMarket),
+            Some(1) => Ok(Self::PlaceOrder),
+            Some(2) => Ok(Self::ResolveMarket),
+            _ => Err(ProgramError::InvalidInstruction),
+        }
+    }
+}
+
+pub fn process_instruction(input: &[u8]) -> Result<&'static str, ProgramError> {
+    match Instruction::unpack(input)? {
+        Instruction::CreateMarket => Ok("create_market"),
+        Instruction::PlaceOrder => Ok("place_order"),
+        Instruction::ResolveMarket => Ok("resolve_market"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{process_instruction, Instruction, ProgramError};
+
+    #[test]
+    fn unpacks_prediction_instructions() {
+        assert_eq!(Instruction::unpack(&[0]), Ok(Instruction::CreateMarket));
+        assert_eq!(Instruction::unpack(&[1]), Ok(Instruction::PlaceOrder));
+        assert_eq!(Instruction::unpack(&[2]), Ok(Instruction::ResolveMarket));
+    }
+
+    #[test]
+    fn rejects_unknown_instruction() {
+        assert_eq!(Instruction::unpack(&[9]), Err(ProgramError::InvalidInstruction));
+    }
+
+    #[test]
+    fn processes_market_resolution() {
+        assert_eq!(process_instruction(&[2]), Ok("resolve_market"));
+    }
+}

package/registry/layers/capability/solana-prediction/files/prediction-config.json

@@ -0,0 +1,6 @@
+{
+  "product": "prediction-market",
+  "marketTypes": ["binary", "scalar", "categorical"],
+  "oracle": ["pyth", "switchboard"],
+  "resolution": ["optimistic", "disputeWindow"]
+}

package/registry/layers/capability/solana-prediction/manifest.json

@@ -0,0 +1,22 @@
+{
+  "id": "solana-prediction",
+  "description": "Specializes a Solana program lane for markets, resolution, and disputes.",
+  "appliesTo": ["solana-program"],
+  "files": [
+    {
+      "source": "files/lib.rs",
+      "target": "src/lib.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "client/README.md"
+    },
+    {
+      "source": "files/prediction-config.json",
+      "target": "prediction-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/lib.rs", "prediction-config.json", "client/README.md"]
+  }
+}

package/registry/layers/capability/solana-staking/files/README.md

@@ -0,0 +1,5 @@
+# Solana Staking Notes
+
+- Keep pool initialization, stake, and reward claim instructions explicit.
+- Pair with an API lane for APY, leaderboard, and rewards history surfaces.
+- Keep staking UX and calculators in the web lane.

package/registry/layers/capability/solana-staking/files/lib.rs

@@ -0,0 +1,52 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ProgramError {
+    InvalidInstruction,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Instruction {
+    InitializeStakePool,
+    StakeTokens,
+    ClaimRewards,
+}
+
+impl Instruction {
+    pub fn unpack(input: &[u8]) -> Result<Self, ProgramError> {
+        match input.first().copied() {
+            Some(0) => Ok(Self::InitializeStakePool),
+            Some(1) => Ok(Self::StakeTokens),
+            Some(2) => Ok(Self::ClaimRewards),
+            _ => Err(ProgramError::InvalidInstruction),
+        }
+    }
+}
+
+pub fn process_instruction(input: &[u8]) -> Result<&'static str, ProgramError> {
+    match Instruction::unpack(input)? {
+        Instruction::InitializeStakePool => Ok("initialize_stake_pool"),
+        Instruction::StakeTokens => Ok("stake_tokens"),
+        Instruction::ClaimRewards => Ok("claim_rewards"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{process_instruction, Instruction, ProgramError};
+
+    #[test]
+    fn unpacks_staking_instructions() {
+        assert_eq!(Instruction::unpack(&[0]), Ok(Instruction::InitializeStakePool));
+        assert_eq!(Instruction::unpack(&[1]), Ok(Instruction::StakeTokens));
+        assert_eq!(Instruction::unpack(&[2]), Ok(Instruction::ClaimRewards));
+    }
+
+    #[test]
+    fn rejects_unknown_instruction() {
+        assert_eq!(Instruction::unpack(&[9]), Err(ProgramError::InvalidInstruction));
+    }
+
+    #[test]
+    fn processes_rewards_claims() {
+        assert_eq!(process_instruction(&[2]), Ok("claim_rewards"));
+    }
+}

package/registry/layers/capability/solana-staking/files/staking-config.json

@@ -0,0 +1,5 @@
+{
+  "product": "staking",
+  "rewardModel": ["per-second", "boostMultiplier", "multiReward"],
+  "advanced": ["veToken", "autoCompound"]
+}

package/registry/layers/capability/solana-staking/manifest.json

@@ -0,0 +1,22 @@
+{
+  "id": "solana-staking",
+  "description": "Specializes a Solana program lane for staking and rewards distribution.",
+  "appliesTo": ["solana-program"],
+  "files": [
+    {
+      "source": "files/lib.rs",
+      "target": "src/lib.rs"
+    },
+    {
+      "source": "files/README.md",
+      "target": "client/README.md"
+    },
+    {
+      "source": "files/staking-config.json",
+      "target": "staking-config.json"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": ["src/lib.rs", "staking-config.json", "client/README.md"]
+  }
+}

package/registry/layers/capability/tailwind/files/design-tokens.json

@@ -0,0 +1,51 @@
+{
+  "light": {
+    "--background": "0 0% 100%",
+    "--foreground": "222.2 84% 4.9%",
+    "--card": "0 0% 100%",
+    "--card-foreground": "222.2 84% 4.9%",
+    "--popover": "0 0% 100%",
+    "--popover-foreground": "222.2 84% 4.9%",
+    "--primary": "222.2 47.4% 11.2%",
+    "--primary-foreground": "210 40% 98%",
+    "--secondary": "210 40% 96.1%",
+    "--secondary-foreground": "222.2 47.4% 11.2%",
+    "--muted": "210 40% 96.1%",
+    "--muted-foreground": "215.4 16.3% 46.9%",
+    "--accent": "210 40% 96.1%",
+    "--accent-foreground": "222.2 47.4% 11.2%",
+    "--destructive": "0 84.2% 60.2%",
+    "--border": "214.3 31.8% 91.4%",
+    "--input": "214.3 31.8% 91.4%",
+    "--ring": "222.2 84% 4.9%",
+    "--radius": "0.5rem"
+  },
+  "dark": {
+    "--background": "222.2 84% 4.9%",
+    "--foreground": "210 40% 98%",
+    "--card": "222.2 84% 4.9%",
+    "--card-foreground": "210 40% 98%",
+    "--popover": "222.2 84% 4.9%",
+    "--popover-foreground": "210 40% 98%",
+    "--primary": "210 40% 98%",
+    "--primary-foreground": "222.2 47.4% 11.2%",
+    "--secondary": "217.2 32.6% 17.5%",
+    "--secondary-foreground": "210 40% 98%",
+    "--muted": "217.2 32.6% 17.5%",
+    "--muted-foreground": "215 20.2% 65.1%",
+    "--accent": "217.2 32.6% 17.5%",
+    "--accent-foreground": "210 40% 98%",
+    "--destructive": "0 62.8% 30.6%",
+    "--border": "217.2 32.6% 17.5%",
+    "--input": "217.2 32.6% 17.5%",
+    "--ring": "212.7 26.8% 83.9%",
+    "--radius": "0.5rem"
+  },
+  "notes": [
+    "These are the default shadcn/ui design tokens in HSL format.",
+    "Apply light tokens to :root and dark tokens to .dark class.",
+    "Override individual tokens to match brand colors.",
+    "All components reference these tokens via Tailwind utility classes.",
+    "Include a prefers-reduced-motion media query in globals.css to disable animations and transitions for accessibility."
+  ]
+}