@qubic.ts/contracts 0.1.0

package/src/generated/core-registry.types.ts

@@ -0,0 +1,100 @@
+/* eslint-disable */
+/* This file is generated. Do not edit manually. */
+
+export type ContractName = "CCF" | "GQMPROP" | "MLM" | "MSVAULT" | "NOST" | "QBAY" | "QBOND" | "QDRAW" | "QDUEL" | "QEARN" | "QIP" | "QRAFFLE" | "QRP" | "QRWA" | "QSWAP" | "QTF" | "QUOTTERY" | "QUTIL" | "QVAULT" | "QX" | "RANDOM" | "RL" | "SWATCH";
+
+export type FunctionName<C extends ContractName> = C extends "QX"
+  ? "AssetAskOrders" | "AssetBidOrders" | "EntityAskOrders" | "EntityBidOrders" | "Fees"
+  : C extends "QUOTTERY"
+    ? "basicInfo" | "getActiveBet" | "getBetByCreator" | "getBetInfo" | "getBetOptionDetail"
+    : C extends "RANDOM"
+      ? never
+      : C extends "QUTIL"
+        ? "GetCurrentPollId" | "GetCurrentResult" | "GetFees" | "GetPollInfo" | "GetPollsByCreator" | "GetSendToManyV1Fee" | "GetShareholderProposal" | "GetShareholderProposalFees" | "GetShareholderProposalIndices" | "GetShareholderVotes" | "GetShareholderVotingResults" | "GetTotalNumberOfAssetShares" | "QueryFeeReserve"
+        : C extends "MLM"
+          ? never
+          : C extends "GQMPROP"
+            ? "GetProposal" | "GetProposalIndices" | "GetRevenueDonation" | "GetVote" | "GetVotingResults"
+            : C extends "SWATCH"
+              ? never
+              : C extends "CCF"
+                ? "GetLatestTransfers" | "GetProposal" | "GetProposalFee" | "GetProposalIndices" | "GetRegularPayments" | "GetVote" | "GetVotingResults"
+                : C extends "QEARN"
+                  ? "getBurnedAndBoostedStats" | "getBurnedAndBoostedStatsPerEpoch" | "getEndedStatus" | "getLockInfoPerEpoch" | "getStateOfRound" | "getStatsPerEpoch" | "getUserLockedInfo" | "getUserLockStatus"
+                  : C extends "QVAULT"
+                    ? "getData"
+                    : C extends "MSVAULT"
+                      ? "getAssetReleaseStatus" | "getBalanceOf" | "getFees" | "getFeeVotes" | "getFeeVotesOwner" | "getFeeVotesScore" | "getManagedAssetBalance" | "getReleaseStatus" | "getRevenueInfo" | "getUniqueFeeVotes" | "getUniqueFeeVotesRanking" | "getVaultAssetBalances" | "getVaultName" | "getVaultOwners" | "getVaults" | "isShareHolder"
+                      : C extends "QBAY"
+                        ? "getIncomingAuctions" | "getInfoOfCollectionByCreator" | "getInfoOfCollectionById" | "getInfoOfMarketplace" | "getInfoOfNFTById" | "getInfoOfNFTUserPossessed" | "getNumberOfNFTForUser" | "getUserCreatedCollection" | "getUserCreatedNFT"
+                        : C extends "QSWAP"
+                          ? "Fees" | "GetLiquidityOf" | "GetPoolBasicState" | "InvestRewardsInfo" | "QuoteExactAssetInput" | "QuoteExactAssetOutput" | "QuoteExactQuInput" | "QuoteExactQuOutput"
+                          : C extends "NOST"
+                            ? "checkTokenCreatability" | "getFundarasingByIndex" | "getInfoUserInvested" | "getMaxClaimAmount" | "getNumberOfInvestedProjects" | "getProjectByIndex" | "getProjectIndexListByCreator" | "getStats" | "getTierLevelByUser" | "getUserVoteStatus"
+                            : C extends "QDRAW"
+                              ? "getInfo" | "getParticipants"
+                              : C extends "RL"
+                                ? "GetBalance" | "GetDrawHour" | "GetFees" | "GetMaxNumberOfPlayers" | "GetNextEpochData" | "GetPlayers" | "GetSchedule" | "GetState" | "GetTicketPrice" | "GetWinners"
+                                : C extends "QBOND"
+                                  ? "GetCFA" | "GetEarnedFees" | "GetFees" | "GetInfoPerEpoch" | "GetMBondsTable" | "GetOrders" | "GetUserMBonds" | "GetUserOrders"
+                                  : C extends "QIP"
+                                    ? "getICOInfo"
+                                    : C extends "QRAFFLE"
+                                      ? "getActiveProposal" | "getActiveTokenRaffle" | "getAnalytics" | "getEndedQuRaffle" | "getEndedTokenRaffle" | "getEpochRaffleIndexes" | "getQuRaffleEntryAmountPerUser" | "getQuRaffleEntryAverageAmount" | "getRegisters"
+                                      : C extends "QRWA"
+                                        ? "GetActiveAssetReleasePollIds" | "GetActiveGovPollIds" | "GetAssetReleasePoll" | "GetDividendBalances" | "GetGeneralAssetBalance" | "GetGeneralAssets" | "GetGovParams" | "GetGovPoll" | "GetTotalDistributed" | "GetTreasuryBalance"
+                                        : C extends "QRP"
+                                          ? "GetAllowedSC" | "GetAvailableReserve"
+                                          : C extends "QTF"
+                                            ? "EstimatePrizePayouts" | "GetDrawHour" | "GetFees" | "GetNextEpochData" | "GetPools" | "GetSchedule" | "GetState" | "GetTicketPrice" | "GetWinnerData"
+                                            : C extends "QDUEL"
+                                              ? "GetPercentFees" | "GetRooms" | "GetTTLHours" | "GetUserProfile"
+                                              : never;
+
+export type ProcedureName<C extends ContractName> = C extends "QX"
+  ? "AddToAskOrder" | "AddToBidOrder" | "IssueAsset" | "RemoveFromAskOrder" | "RemoveFromBidOrder" | "TransferShareManagementRights" | "TransferShareOwnershipAndPossession"
+  : C extends "QUOTTERY"
+    ? "cancelBet" | "issueBet" | "joinBet" | "publishResult"
+    : C extends "RANDOM"
+      ? "RevealAndCommit"
+      : C extends "QUTIL"
+        ? "BurnQubic" | "BurnQubicForContract" | "CancelPoll" | "CreatePoll" | "DistributeQuToShareholders" | "SendToManyBenchmark" | "SendToManyV1" | "SetShareholderProposal" | "SetShareholderVotes" | "Vote"
+        : C extends "MLM"
+          ? never
+          : C extends "GQMPROP"
+            ? "SetProposal" | "Vote"
+            : C extends "SWATCH"
+              ? never
+              : C extends "CCF"
+                ? "SetProposal" | "Vote"
+                : C extends "QEARN"
+                  ? "lock" | "unlock"
+                  : C extends "QVAULT"
+                    ? "changeAdminAddress" | "changeAuthAddress" | "changeDistributionPermille" | "changeReinvestingAddress" | "saveBannedAddress" | "submitAdminAddress" | "submitAuthAddress" | "submitBannedAddress" | "submitDistributionPermille" | "submitReinvestingAddress" | "submitUnbannedAddress" | "unblockBannedAddress"
+                    : C extends "MSVAULT"
+                      ? "deposit" | "depositAsset" | "registerVault" | "releaseAssetTo" | "releaseTo" | "resetAssetRelease" | "resetRelease" | "revokeAssetManagementRights" | "voteFeeChange"
+                      : C extends "QBAY"
+                        ? "acceptOffer" | "bidOnTraditionalAuction" | "buy" | "cancelExchange" | "cancelOffer" | "cancelSale" | "changeStatusOfMarketPlace" | "createCollection" | "createTraditionalAuction" | "listInExchange" | "listInMarket" | "makeOffer" | "mint" | "mintOfDrop" | "settingCFBAndQubicPrice" | "transfer" | "TransferShareManagementRights"
+                        : C extends "QSWAP"
+                          ? "AddLiquidity" | "CreatePool" | "IssueAsset" | "RemoveLiquidity" | "SetInvestRewardsInfo" | "SwapAssetForExactQu" | "SwapExactAssetForQu" | "SwapExactQuForAsset" | "SwapQuForExactAsset" | "TransferShareManagementRights" | "TransferShareOwnershipAndPossession"
+                          : C extends "NOST"
+                            ? "claimToken" | "createFundraising" | "createProject" | "investInProject" | "logoutFromTier" | "registerInTier" | "TransferShareManagementRights" | "upgradeTier" | "voteInProject"
+                            : C extends "QDRAW"
+                              ? "buyTicket"
+                              : C extends "RL"
+                                ? "BuyTicket" | "SetPrice" | "SetSchedule"
+                                : C extends "QBOND"
+                                  ? "AddAskOrder" | "AddBidOrder" | "BurnQU" | "RemoveAskOrder" | "RemoveBidOrder" | "Stake" | "TransferMBondOwnershipAndPossession" | "UpdateCFA"
+                                  : C extends "QIP"
+                                    ? "buyToken" | "createICO" | "TransferShareManagementRights"
+                                    : C extends "QRAFFLE"
+                                      ? "depositInQuRaffle" | "depositInTokenRaffle" | "logoutInSystem" | "registerInSystem" | "submitEntryAmount" | "submitProposal" | "TransferShareManagementRights" | "voteInProposal"
+                                      : C extends "QRWA"
+                                        ? "CreateAssetReleasePoll" | "DepositGeneralAsset" | "DonateToTreasury" | "RevokeAssetManagementRights" | "VoteAssetRelease" | "VoteGovParams"
+                                        : C extends "QRP"
+                                          ? "AddAllowedSC" | "RemoveAllowedSC" | "WithdrawReserve"
+                                          : C extends "QTF"
+                                            ? "BuyTicket" | "SetDrawHour" | "SetPrice" | "SetSchedule" | "SetTargetJackpot"
+                                            : C extends "QDUEL"
+                                              ? "ConnectToRoom" | "CreateRoom" | "Deposit" | "SetPercentFees" | "SetTTLHours" | "Withdraw"
+                                              : never;

package/src/generator/contract-codecs.fixture.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "bun:test";
+import { validateContractsRegistry } from "../registry/index.js";
+import { generateContractCodecs } from "./contract-codecs.js";
+
+describe("generateContractCodecs fixture", () => {
+  it("matches the expected generated file", async () => {
+    const fixturePath = new URL("../../test/fixtures/registry.sample.json", import.meta.url);
+    const expectedPath = new URL("../../test/fixtures/registry.sample.codecs.ts", import.meta.url);
+
+    const fixtureRaw = (await Bun.file(fixturePath).json()) as unknown;
+    const expected = await Bun.file(expectedPath).text();
+    const registry = validateContractsRegistry(fixtureRaw);
+    const generated = generateContractCodecs(registry);
+
+    expect(generated).toBe(expected);
+  });
+});

package/src/generator/contract-codecs.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "bun:test";
+import type { ContractsRegistry } from "../registry/types.js";
+import { generateContractCodecs } from "./contract-codecs.js";
+
+describe("generateContractCodecs", () => {
+  it("generates typed function/procedure wiring from io types", () => {
+    const output = generateContractCodecs(makeFixture(), {
+      banner: "// generated",
+    });
+
+    expect(output).toContain("export type QUTIL_GetFees_input = Record<string, never>;");
+    expect(output).toContain("export type QUTIL_GetFees_output = {");
+    expect(output).toContain("readonly fee: bigint;");
+    expect(output).toContain("readonly indices: ReadonlyArray<number>;");
+    expect(output).toContain("export interface ContractTypeMap {");
+    expect(output).toContain("readonly input: QUTIL_GetFees_input;");
+    expect(output).toContain("readonly output: QUTIL_GetFees_output;");
+    expect(output).toContain("readonly orders: ReadonlyArray<QUTIL_Order>;");
+    expect(output).toContain("readonly revealedBits: ReadonlyArray<boolean>;");
+    expect(output).toContain("export const contractCodecRegistry = {");
+    expect(output).toContain("GetFees: {");
+    expect(output).toContain("// generated");
+  });
+
+  it("is deterministic", () => {
+    const first = generateContractCodecs(makeFixture());
+    const second = generateContractCodecs(makeFixture());
+    expect(first).toBe(second);
+  });
+});
+
+function makeFixture(): ContractsRegistry {
+  return {
+    version: 1,
+    metadata: {
+      generatedAt: "2026-02-18T00:00:00.000Z",
+      sources: [{ name: "qubic/core" }],
+    },
+    contracts: [
+      {
+        name: "QUTIL",
+        contractIndex: 4,
+        address: "EAAAA",
+        ioTypes: [
+          { kind: "alias", name: "GetFees_input", target: "NoData" },
+          {
+            kind: "struct",
+            name: "GetFees_output",
+            fields: [
+              { name: "fee", type: "sint64" },
+              { name: "indices", type: "Array<uint16, 64>" },
+            ],
+          },
+          {
+            kind: "struct",
+            name: "GetOrders_input",
+            fields: [],
+          },
+          {
+            kind: "struct",
+            name: "GetOrders_output",
+            fields: [{ name: "orders", type: "Array<QUTIL::GetOrders_output::Order, 2>" }],
+          },
+          {
+            kind: "struct",
+            name: "Order",
+            fields: [{ name: "value", type: "uint16" }],
+          },
+          {
+            kind: "struct",
+            name: "RevealAndCommit_input",
+            fields: [{ name: "revealedBits", type: "BitArray<64>" }],
+          },
+          {
+            kind: "struct",
+            name: "RevealAndCommit_output",
+            fields: [],
+          },
+          { kind: "alias", name: "BurnQubic_input", target: "UnknownAliasType" },
+          { kind: "alias", name: "BurnQubic_output", target: "sint32" },
+        ],
+        entries: [
+          {
+            kind: "function",
+            name: "GetFees",
+            inputType: 7,
+            inputTypeName: "GetFees_input",
+            outputTypeName: "GetFees_output",
+          },
+          {
+            kind: "function",
+            name: "GetOrders",
+            inputType: 8,
+            inputTypeName: "GetOrders_input",
+            outputTypeName: "GetOrders_output",
+          },
+          {
+            kind: "procedure",
+            name: "RevealAndCommit",
+            inputType: 9,
+            inputTypeName: "RevealAndCommit_input",
+            outputTypeName: "RevealAndCommit_output",
+          },
+          {
+            kind: "procedure",
+            name: "BurnQubic",
+            inputType: 2,
+            inputTypeName: "BurnQubic_input",
+            outputTypeName: "BurnQubic_output",
+          },
+        ],
+      },
+    ],
+  };
+}

package/src/generator/contract-codecs.ts

@@ -0,0 +1,416 @@
+import { normalizeContractsRegistry } from "../registry/normalize.js";
+import type {
+  ContractDefinition,
+  ContractEntry,
+  ContractIoTypeDefinition,
+  ContractsRegistry,
+} from "../registry/types.js";
+
+export type GenerateContractCodecsOptions = Readonly<{
+  banner?: string;
+  runtimeExportName?: string;
+}>;
+
+export function generateContractCodecs(
+  registry: ContractsRegistry,
+  options: GenerateContractCodecsOptions = {},
+): string {
+  const normalized = normalizeContractsRegistry(registry);
+  const contracts = normalized.contracts;
+  const runtimeExportName = options.runtimeExportName ?? "contractCodecRegistry";
+  const contexts = contracts.map(createContractContext);
+
+  const banner =
+    options.banner ?? "/* eslint-disable */\n/* This file is generated. Do not edit manually. */";
+
+  const ioTypeBlocks = contexts.flatMap((context) => renderContractIoTypeAliases(context));
+
+  return [
+    banner,
+    "",
+    ...ioTypeBlocks,
+    ...(ioTypeBlocks.length > 0 ? [""] : []),
+    "export interface ContractTypeMap {",
+    ...contexts.map((context) => renderContractTypeMapEntry(context)),
+    "}",
+    "",
+    "export type ContractName = keyof ContractTypeMap & string;",
+    'export type FunctionName<C extends ContractName> = keyof ContractTypeMap[C]["functions"] & string;',
+    'export type ProcedureName<C extends ContractName> = keyof ContractTypeMap[C]["procedures"] & string;',
+    "",
+    "export type FunctionInput<",
+    "  C extends ContractName,",
+    "  F extends FunctionName<C>,",
+    '> = ContractTypeMap[C]["functions"][F]["input"];',
+    "export type FunctionOutput<",
+    "  C extends ContractName,",
+    "  F extends FunctionName<C>,",
+    '> = ContractTypeMap[C]["functions"][F]["output"];',
+    "",
+    "export type ProcedureInput<",
+    "  C extends ContractName,",
+    "  P extends ProcedureName<C>,",
+    '> = ContractTypeMap[C]["procedures"][P]["input"];',
+    "export type ProcedureOutput<",
+    "  C extends ContractName,",
+    "  P extends ProcedureName<C>,",
+    '> = ContractTypeMap[C]["procedures"][P]["output"];',
+    "",
+    `export const ${runtimeExportName} = {`,
+    ...contexts.map((context) => renderRuntimeContractEntry(context)),
+    `} as const satisfies Readonly<Record<ContractName, unknown>>;`,
+    "",
+    `export type RuntimeContractCodecRegistry = typeof ${runtimeExportName};`,
+    "",
+  ].join("\n");
+}
+
+type ContractRenderContext = Readonly<{
+  contract: ContractDefinition;
+  ioTypeByName: ReadonlyMap<string, ContractIoTypeDefinition>;
+  typeAliasByIoName: ReadonlyMap<string, string>;
+}>;
+
+function createContractContext(contract: ContractDefinition): ContractRenderContext {
+  const ioTypeByName = new Map((contract.ioTypes ?? []).map((typeDef) => [typeDef.name, typeDef]));
+  const typeAliasByIoName = new Map<string, string>();
+
+  for (const typeDef of contract.ioTypes ?? []) {
+    typeAliasByIoName.set(typeDef.name, makeIoAliasName(contract.name, typeDef.name));
+  }
+
+  return {
+    contract,
+    ioTypeByName,
+    typeAliasByIoName,
+  };
+}
+
+function renderContractIoTypeAliases(context: ContractRenderContext): readonly string[] {
+  const blocks: string[] = [];
+  const typeDefs = context.contract.ioTypes ?? [];
+
+  for (const typeDef of typeDefs) {
+    const aliasName = context.typeAliasByIoName.get(typeDef.name);
+    if (!aliasName) continue;
+    const rendered = renderIoTypeDefinition(typeDef, context);
+    blocks.push(`export type ${aliasName} = ${rendered};`);
+  }
+
+  return blocks;
+}
+
+function renderIoTypeDefinition(
+  typeDef: ContractIoTypeDefinition,
+  context: ContractRenderContext,
+): string {
+  if (typeDef.kind === "alias") {
+    return renderCoreTypeExpression(typeDef.target, context);
+  }
+
+  if (typeDef.fields.length === 0) {
+    return "Record<string, never>";
+  }
+
+  const lines = ["{"];
+  for (const field of typeDef.fields) {
+    lines.push(
+      `  readonly ${quoteProperty(field.name)}: ${renderCoreTypeExpression(field.type, context)};`,
+    );
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+function renderCoreTypeExpression(typeExpression: string, context: ContractRenderContext): string {
+  const normalized = typeExpression.trim();
+  if (!normalized) return "unknown";
+
+  const noQualifiers = normalizeTypeExpression(stripTypeQualifiers(normalized));
+
+  if (isArrayType(noQualifiers)) {
+    const args = splitTopLevelGenericArgs(extractGenericArgs(noQualifiers) ?? "");
+    const elementType = renderCoreTypeExpression(args[0] ?? "unknown", context);
+    return `ReadonlyArray<${elementType}>`;
+  }
+
+  if (isFixedArrayNotation(noQualifiers)) {
+    const base = noQualifiers.replace(/\[[^\]]*\]\s*$/, "").trim();
+    return `ReadonlyArray<${renderCoreTypeExpression(base, context)}>`;
+  }
+
+  const simple = collapseWhitespace(noQualifiers);
+  if (isBitArrayType(simple)) {
+    return "ReadonlyArray<boolean>";
+  }
+
+  const primitive = CORE_PRIMITIVE_TO_TS[simple];
+  if (primitive) return primitive;
+
+  const ioAlias = resolveIoAliasName(simple, context.typeAliasByIoName);
+  if (ioAlias) return ioAlias;
+
+  return "unknown";
+}
+
+const CORE_PRIMITIVE_TO_TS: Readonly<Record<string, string>> = {
+  NoData: "Record<string, never>",
+  bit: "boolean",
+  bool: "boolean",
+  sint8: "number",
+  uint8: "number",
+  int8_t: "number",
+  uint8_t: "number",
+  sint16: "number",
+  uint16: "number",
+  int16_t: "number",
+  uint16_t: "number",
+  sint32: "number",
+  uint32: "number",
+  int32_t: "number",
+  uint32_t: "number",
+  sint64: "bigint",
+  uint64: "bigint",
+  int64_t: "bigint",
+  uint64_t: "bigint",
+  uint128: "bigint",
+  id: "string",
+  m256i: "string",
+};
+
+function renderContractTypeMapEntry(context: ContractRenderContext): string {
+  const { contract } = context;
+  const functionEntries = contract.entries.filter((entry) => entry.kind === "function");
+  const procedureEntries = contract.entries.filter((entry) => entry.kind === "procedure");
+
+  return [
+    `  ${quoteProperty(contract.name)}: {`,
+    `    readonly contractIndex: ${contract.contractIndex};`,
+    ...renderEntryTypeContainer("functions", functionEntries, context),
+    ...renderEntryTypeContainer("procedures", procedureEntries, context),
+    "  };",
+  ].join("\n");
+}
+
+function renderEntryTypeContainer(
+  name: "functions" | "procedures",
+  entries: readonly ContractEntry[],
+  context: ContractRenderContext,
+): readonly string[] {
+  if (entries.length === 0) {
+    return [`    readonly ${name}: Record<never, never>;`];
+  }
+
+  return [`    readonly ${name}: {`, ...renderEntryTypeMap(entries, context), "    };"];
+}
+
+function renderEntryTypeMap(
+  entries: readonly ContractEntry[],
+  context: ContractRenderContext,
+): readonly string[] {
+  return entries.map((entry) =>
+    [
+      `      ${quoteProperty(entry.name)}: {`,
+      `        readonly kind: ${quote(entry.kind)};`,
+      `        readonly inputType: ${entry.inputType};`,
+      `        readonly inputTypeName: ${quote(entry.inputTypeName ?? `${entry.name}_input`)};`,
+      `        readonly outputTypeName: ${quote(entry.outputTypeName ?? `${entry.name}_output`)};`,
+      `        readonly input: ${resolveEntryInputType(entry, context)};`,
+      `        readonly output: ${resolveEntryOutputType(entry, context)};`,
+      "      };",
+    ].join("\n"),
+  );
+}
+
+function resolveEntryInputType(entry: ContractEntry, context: ContractRenderContext): string {
+  if (!entry.inputTypeName) return "unknown";
+  const aliased = context.typeAliasByIoName.get(entry.inputTypeName);
+  if (aliased) return aliased;
+
+  const ioType = context.ioTypeByName.get(entry.inputTypeName);
+  if (!ioType) return "unknown";
+  return renderIoTypeDefinition(ioType, context);
+}
+
+function resolveEntryOutputType(entry: ContractEntry, context: ContractRenderContext): string {
+  if (!entry.outputTypeName) return "unknown";
+  const aliased = context.typeAliasByIoName.get(entry.outputTypeName);
+  if (aliased) return aliased;
+
+  const ioType = context.ioTypeByName.get(entry.outputTypeName);
+  if (!ioType) return "unknown";
+  return renderIoTypeDefinition(ioType, context);
+}
+
+function renderRuntimeContractEntry(context: ContractRenderContext): string {
+  const { contract } = context;
+  const functionEntries = contract.entries.filter((entry) => entry.kind === "function");
+  const procedureEntries = contract.entries.filter((entry) => entry.kind === "procedure");
+
+  return [
+    `  ${quoteProperty(contract.name)}: {`,
+    `    contractIndex: ${contract.contractIndex},`,
+    ...renderRuntimeEntryContainer("functions", functionEntries),
+    ...renderRuntimeEntryContainer("procedures", procedureEntries),
+    "  },",
+  ].join("\n");
+}
+
+function renderRuntimeEntryContainer(
+  name: "functions" | "procedures",
+  entries: readonly ContractEntry[],
+): readonly string[] {
+  if (entries.length === 0) {
+    return [`    ${name}: {},`];
+  }
+
+  return [`    ${name}: {`, ...renderRuntimeEntries(entries), "    },"];
+}
+
+function renderRuntimeEntries(entries: readonly ContractEntry[]): readonly string[] {
+  return entries.map((entry) =>
+    [
+      `      ${quoteProperty(entry.name)}: {`,
+      `        kind: ${quote(entry.kind)},`,
+      `        inputType: ${entry.inputType},`,
+      `        inputTypeName: ${quote(entry.inputTypeName ?? `${entry.name}_input`)},`,
+      `        outputTypeName: ${quote(entry.outputTypeName ?? `${entry.name}_output`)},`,
+      "      },",
+    ].join("\n"),
+  );
+}
+
+function makeIoAliasName(contractName: string, ioTypeName: string): string {
+  return `${toTypeIdentifier(contractName)}_${toTypeIdentifier(ioTypeName)}`;
+}
+
+function toTypeIdentifier(value: string): string {
+  const sanitized = value.replace(/[^A-Za-z0-9_]/g, "_");
+  const startsWithDigit = /^[0-9]/.test(sanitized);
+  return startsWithDigit ? `T_${sanitized}` : sanitized;
+}
+
+function quote(value: string): string {
+  return JSON.stringify(value);
+}
+
+function quoteProperty(value: string): string {
+  return isValidIdentifier(value) ? value : JSON.stringify(value);
+}
+
+function isValidIdentifier(value: string): boolean {
+  return /^[$A-Z_a-z][$\w]*$/.test(value);
+}
+
+function stripTypeQualifiers(value: string): string {
+  return collapseWhitespace(
+    value
+      .replace(/\bQPI::/g, "")
+      .replace(/\bconst\b/g, "")
+      .replace(/\bvolatile\b/g, "")
+      .replace(/\bstruct\b/g, "")
+      .replace(/\bclass\b/g, "")
+      .replace(/\s*&+/g, "")
+      .replace(/\s*\*+/g, ""),
+  );
+}
+
+function collapseWhitespace(value: string): string {
+  return value.trim().replace(/\s+/g, " ");
+}
+
+function normalizeTypeExpression(value: string): string {
+  return collapseWhitespace(value)
+    .replace(/^::+/, "")
+    .replace(/\s*<\s*/g, "<")
+    .replace(/\s*>\s*/g, ">")
+    .replace(/\s*,\s*/g, ", ");
+}
+
+function resolveIoAliasName(
+  typeExpression: string,
+  aliasByIoName: ReadonlyMap<string, string>,
+): string | undefined {
+  for (const candidate of getTypeLookupCandidates(typeExpression)) {
+    const resolved = aliasByIoName.get(candidate);
+    if (resolved) return resolved;
+  }
+  return undefined;
+}
+
+function getTypeLookupCandidates(value: string): readonly string[] {
+  const candidates: string[] = [];
+  const seen = new Set<string>();
+
+  const push = (candidate: string | undefined): void => {
+    const normalized = normalizeTypeExpression(candidate ?? "");
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+
+  const normalized = normalizeTypeExpression(value);
+  push(normalized);
+  push(extractUnqualifiedTypeName(normalized));
+
+  const templateBase = extractTemplateBaseName(normalized);
+  if (templateBase) {
+    push(templateBase);
+    push(extractUnqualifiedTypeName(templateBase));
+  }
+
+  return candidates;
+}
+
+function extractTemplateBaseName(value: string): string | undefined {
+  const index = value.indexOf("<");
+  if (index <= 0) return undefined;
+  return value.slice(0, index).trim();
+}
+
+function extractUnqualifiedTypeName(value: string): string {
+  const trimmed = value.trim();
+  const segments = trimmed.split("::").filter((segment) => segment.length > 0);
+  return segments[segments.length - 1] ?? trimmed;
+}
+
+function isArrayType(value: string): boolean {
+  return /^Array\s*</.test(value);
+}
+
+function extractGenericArgs(value: string): string | null {
+  const start = value.indexOf("<");
+  const end = value.lastIndexOf(">");
+  if (start < 0 || end < 0 || end <= start) return null;
+  return value.slice(start + 1, end);
+}
+
+function splitTopLevelGenericArgs(value: string): readonly string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let current = "";
+
+  for (const char of value) {
+    if (char === "<") depth += 1;
+    if (char === ">") depth = Math.max(0, depth - 1);
+
+    if (char === "," && depth === 0) {
+      out.push(current.trim());
+      current = "";
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.trim().length > 0) out.push(current.trim());
+  return out;
+}
+
+function isFixedArrayNotation(value: string): boolean {
+  return /\[[^\]]*\]\s*$/.test(value);
+}
+
+function isBitArrayType(value: string): boolean {
+  return /^BitArray<\d+>$/.test(value);
+}

package/src/generator/index.ts

@@ -0,0 +1,14 @@
+export {
+  type GenerateContractCodecsOptions,
+  generateContractCodecs,
+} from "./contract-codecs.js";
+export {
+  type GeneratedPerContractFile,
+  type GeneratePerContractFilesOptions,
+  generatePerContractFiles,
+} from "./per-contract-files.js";
+export {
+  type GenerateRegistryRuntimeOptions,
+  generateRegistryRuntime,
+} from "./registry-runtime.js";
+export { type GenerateRegistryTypesOptions, generateRegistryTypes } from "./registry-types.js";