Turn intellectual property into a programmable asset class.

01// 01 — SME Onboarding & IP Underwriting02import { IFScore } from "@if-score/sdk";03 04const IP_UNDERWRITING_CRITERIA = {05  // Intellectual Property Quality06  ipQuality: [07    "Software",08    "Brands",09    "Patents",10    "Algorithms",11    "Designs",12    "Content libraries",13    "Proprietary technologies",14    "Licensing rights",15    "Other intangible assets",16  ],17 18  // Business Performance19  performance: [20    "Historical revenue",21    "Revenue growth",22    "Recurring revenue",23    "Customer retention",24    "Profitability",25    "Cash-flow generation",26  ],27 28  // Commercial Strength29  commercial: [30    "Market position",31    "Customer base",32    "Competitive advantage",33    "Distribution",34    "Partnerships",35    "Contract quality",36  ],37 38  // Future IP Revenue Potential39  projections: [40    "Expected IP-generated revenue",41    "Monetisation potential",42    "Revenue durability",43    "Growth scenarios",44    "Risk-adjusted valuation",45  ],46};47 48async function underwrite(sme: SME) {49  const data = await sme.connect([50    "ip.registry",51    "financials",52    "contracts",53    "customers",54  ]);55 56  const score = await IFScore.evaluate({57    ipQuality: data.ip,58    performance: data.revenue,59    commercial: data.market,60    projections: data.futureIP,61    criteria: IP_UNDERWRITING_CRITERIA,62  });63 64  return {65    score: score.value,             // 0 – 100066    projectedRoyalties: score.cf,   // 5-yr NPV67    riskBand: score.risk,           // AAA … C68  };69}

01// 02 — Usufruct Transfer & Instant Lease-Back02contract IPUsufruct {03  address public sme;              // retains ownership04  address public passTheJam;       // holds economics05 06  // Pass The Jam receives07  struct AcquiredRights {08    string[] economicUsageRights;09    string[] exploitIPEconomically;10    string[] receiveRoyaltyPayments;11  }12 13  // The SME retains14  struct RetainedRights {15    string[] legalOwnershipOfIP;16    string[] ownershipOfCompany;17    string[] strategicControlOverIP;18  }19 20  // Lease-back — SME continues21  struct ContinuedOperations {22    string[] sellingProducts;23    string[] providingServices;24    string[] runningSoftware;25    string[] commercialisingBrand;26    string[] licensingTechnology;27  }28 29  function transferUsufruct() external onlySME {30    // Economics move; legal title stays put31    AcquiredRights memory toJam = AcquiredRights({32      economicUsageRights:    ["Economic usage rights"],33      exploitIPEconomically:  ["Rights to exploit the IP economically"],34      receiveRoyaltyPayments: ["Rights to receive royalty payments"]35    });36 37    RetainedRights memory toSME = RetainedRights({38      legalOwnershipOfIP:   ["Legal ownership of the IP"],39      ownershipOfCompany: ["Ownership of the company"],40      strategicControlOverIP: ["Strategic control over the IP"]41    });42 43    ContinuedOperations memory ops = ContinuedOperations({44      sellingProducts:    ["Selling products"],45      providingServices:  ["Providing services"],46      runningSoftware:    ["Running software"],47      commercialisingBrand: ["Commercialising the brand"],48      licensingTechnology:  ["Licensing technology"]49    });50 51    economicRights[passTheJam] = toJam;52    legalOwnership[sme]        = toSME;   // untouched53    emit UsufructTransferred(sme, passTheJam);54 55    // T+0 lease-back — no operational gap56    leaseBack({57      licensee: sme,58      operations: ops,59      royaltyBps: 850,60      term: FOREVER_UNTIL_TERMINATED,61    });62  }63}

01// 03 — TOAST Creation02mint TOAST from usufruct {03  supply       : usufruct.valuation / 1 GBP,   // £10M → 10_000_00004  cashflow     : usufruct.royaltyStream,05  onDefault    : trigger(CDS_LAYER),06  onMajorEvent : flipToEquity(sme, 0.30),07  distribute   : (holder, amount) => vault.push(holder, amount),08}09 10// deploy → attach lifecycle hooks → freeze bytecode11deploy(TOAST).immutable();

01// 04 — Pass The Jam Acquires TOASTs02async function acquire(toast: TOAST) {03  const price = toast.valuation;                 // £10M04 05  // Only the protocol touches raw TOASTs06  await ptj.pay(sme, TBD.mint(price * 0.80));    // £8M → SME07  await reserve.lock(     TBD.mint(price * 0.20)); // £2M → Reserve08 09  toast.transferTo(ptj.vault);10  invariant(!investorsCanBuy(toast), "TOASTs never sold direct");11}

01// 05 — Royalty Default Protection Reserve02//03// Royalty Default Protection Example04//   TOAST acquisition value : £10M05//   £8M TBD  → SME06//   £2M TBD  → Royalty Protection Reserve07//   Custodied · segregated · linked to the TOAST08struct Reserve {09  uint256 tbdLocked;       // £2M from £10M TOAST10  bytes32 toastId;         // linked 1:111  bool    isInvestorCapital;   // false — never12  bool    isYieldSource;       // false — never13}14 15// Protects against16//   • Temporary royalty interruptions17//   • SME payment defaults18//   • Revenue volatility19function coverShortfall(bytes32 id, uint256 miss) internal {20  Reserve storage r = reserves[id];21  require(r.tbdLocked >= miss, "reserve exhausted");22  r.tbdLocked -= miss;23  vault.credit(id, miss);   // firewall absorbs the hit24}

01// 06 — Pass The Jam IP Vault02const vault: IPVault = {03  strategy: "diversify across sector · geo · IP-type",04  holdings: [05    { id: "TOAST #001", type: "Software IP",  weight: 0.22 },06    { id: "TOAST #002", type: "Gaming IP",    weight: 0.18 },07    { id: "TOAST #003", type: "Patent IP",    weight: 0.20 },08    { id: "TOAST #004", type: "Brand IP",     weight: 0.24 },09    { id: "TOAST #005", type: "Content IP",   weight: 0.16 },10  ],11  aggregateValue() {12    return this.holdings.reduce((s, t) => s + t.mark(), 0);13  },14};

01// 07 — JAM Issuance Against TOAST Reserve02function mintJAM() external onlyProtocol returns (uint256) {03  uint256 reserveValue = vault.markToMarket();    // £100M TOASTs04  uint256 supply       = jam.totalSupply();05 06  require(reserveValue >= supply, "under-collateralised");07 08  uint256 mintable = reserveValue - supply;       // 1:1 with vault09  jam.mint(treasury, mintable);10  emit Backing(reserveValue, supply + mintable);11  return mintable;12}

01// 08 — Investor Access Through JAM02const exposure = await investor.buy(JAM, { amount: 10_000 });03 04// JAM holders inherit the vault's productive IP exposure05exposure.reveal() === {06  streams : ["SaaS royalties", "brand licences", "patents"],07  regions : ["EU", "US", "APAC"],08  assets  : vault.holdings.length,   // diversified09  claim   : "pro-rata on TOAST cash-flows",10};

01// 09 — Royalty Cash Flow Mechanism02setInterval(async () => {03  for (const sme of activeSMEs) {04    const revenue  = await sme.getRevenue();05    const royalty  = revenue * sme.royaltyRate;    // e.g. 8.5%06 07    await sme.pay(ptj.vault, royalty);08    vault.creditTOAST(sme.toastId, royalty);09    jam.rebase(vault.markToMarket());              // reserve ↑10  }11}, ONE_MONTH);

01// 10 — TOAST Protection Mechanisms02on SMEBankruptcy(bytes32 toastId, address sme) {03  // Layer 1 — CDS Protection04  // Covers SME bankruptcy or insolvency events05  cds.payOut({06    toastId: toastId,07    event:   BANKRUPTCY_OR_INSOLVENCY,08    to:      ptj.vault,09    amount:  toastId.coverageLimit,10  });11  emit CDSPayoutTriggered(toastId, sme);12}13 14on SevereRoyaltyDefault(bytes32 toastId, uint256 miss) {15  // Layer 2 — Equity Flip16  // Converts into equity of the severe royalty defaulting SME17  const sme = registry.owner(toastId);18  equity.convert({19    from:   sme,20    to:     ptj.vault,21    basis:  toastId.impairedValue,22    into:   sme.equityToken,     // equity of defaulting SME23    lock:   RECOVERY_TERM,24  });25  emit EquityFlipActivated(toastId, sme);26}