Build a Mining Royalty Investment and Lending Platform

import { TokenFactory, CollateralVault } from "@ankarachain/sdk";

export const factory = new TokenFactory({
  network:          "stellar-testnet",
  stellarSecretKey: process.env.STELLAR_SECRET_KEY!,
  factoryAddress:   "CBMBI63UU6KJIZ5KUVP6A3FGMBMS4R3OXSY27NQNK5PPLCWJW7DPSEEF",
});

// Shared Ankara Chain Stellar Testnet CollateralVault
export const vault = new CollateralVault(
  factory.adapter,
  "CDIUS3CGVFJONWUK3SCK4RFFONENSJ6QRZLNOHHO7EMVPZCCQ3IUSVNB"
);

import express from "express";
import { AssetRegistry } from "@ankarachain/sdk";
import { factory } from "./config";

export const router = express.Router();

router.post("/api/concessions", async (req, res) => {
  const { licenseNumber, mineralType, concessionArea, areaHectares, licenseDurationDays, issuingAuthority, royaltyRateBps } = req.body;

  const now = BigInt(Math.floor(Date.now() / 1000));

  const result = await factory.deployMiningRights({
    name:        `${concessionArea} ${mineralType} Rights`,
    symbol:      "MINE",
    assetId:     licenseNumber,
    countryCode: req.body.countryCode,
    metadata: {
      licenseNumber,
      mineralType,
      concessionArea,
      areaHectares:        BigInt(areaHectares),
      licenseExpiry:       now + BigInt(licenseDurationDays * 24 * 60 * 60),
      issuingAuthority,
      licenseDocumentHash: "0x" + "00".repeat(32),
      royaltyRateBps:      BigInt(royaltyRateBps),   // e.g. 300n = 3%
      lastUpdated:         now,
    },
  });

  res.json({ tokenAddress: result.tokenAddress, txHash: result.txHash });
});

router.post("/api/concessions/:tokenAddress/royalty", async (req, res) => {
  const registry = new AssetRegistry(factory.adapter, req.params.tokenAddress, "mining-rights");
  // Off-chain: pay each holder their share of the royalty first (see the Real Estate tutorial's pattern).
  const txHash = await registry.declareRoyalty(BigInt(req.body.extractionValueUSD) * 10n ** 18n);
  res.json({ txHash });
});

import cron from "node-cron";
import { AssetRegistry } from "@ankarachain/sdk";
import { factory } from "../config";

cron.schedule("0 3 * * *", async () => {
  for (const tokenAddress of await listActiveConcessionAddresses()) { // your DB query
    const registry = new AssetRegistry(factory.adapter, tokenAddress, "mining-rights");

    if (await registry.isLicenseExpired()) {
      const txHash = await registry.markLicenseExpired();
      console.log(`Licence expired for ${tokenAddress}: ${txHash}`);
    }
  }
});

router.post("/api/loans/open", async (req, res) => {
  const { holderSigner, collateralTokenAddress, collateralAmount, borrowAmount } = req.body;

  // In a non-custodial product this call is signed by the holder's own wallet
  // (a TokenFactory/CollateralVault built with the holder's stellarSigner), not the platform's.
  const holderVault = req.holderVault; // constructed per-request from holderSigner — see the note below

  const { loanId, txHash } = await holderVault.openLoan(
    collateralTokenAddress,
    BigInt(collateralAmount) * 10_000_000n,  // Stellar tokens use 7 decimals
    BigInt(borrowAmount) * 10_000_000n
  );

  res.json({ loanId, txHash });
});

router.get("/api/loans/:loanId", async (req, res) => {
  const { vault } = await import("./config");
  const loanId = Number(req.params.loanId);

  const loan       = await vault.getLoan(loanId);
  const currentLtv = await vault.currentLtvBps(loanId);
  const liquidatable = await vault.isLiquidatable(loanId);

  res.json({ loan, currentLtvBps: currentLtv, liquidatable });
});

router.post("/api/loans/:loanId/repay", async (req, res) => {
  const { vault } = await import("./config");
  const txHash = await vault.repayLoan(Number(req.params.loanId));
  res.json({ txHash });
});

"use client";

import { useAsset, useTokenBalance } from "@ankarachain/sdk/react";

export function RoyaltyPosition({ tokenAddress, walletAddress }: { tokenAddress: string; walletAddress: string }) {
  const asset   = useAsset({ tokenAddress, template: "mining-rights", network: "stellar-testnet" });
  const balance = useTokenBalance({ tokenAddress, walletAddress, network: "stellar-testnet" });

  if (asset.isLoading) return <p>Loading…</p>;

  const meta = asset.metadata as { mineralType?: string; royaltyRateBps?: bigint; licenseExpiry?: bigint } | null;

  return (
    <div className="royalty-card">
      <h3>{asset.name}</h3>
      <p>Mineral: {meta?.mineralType ?? "—"}</p>
      <p>Royalty rate: {meta?.royaltyRateBps != null ? Number(meta.royaltyRateBps) / 100 : "—"}%</p>
      <p>Your shares: {balance.formatted ?? "0"}</p>
    </div>
  );
}