@mysten-incubation/devstack 0.0.0

package/dist/plugins/coin/discovery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.mjs","names":[],"sources":["../../../src/plugins/coin/discovery.ts"],"sourcesContent":["// Coin auto-discovery — pure projection over a `LocalPackagePublishOutput`.\n//\n// Distilled-doc 13-coin.md §\"Capabilities PRODUCED\" §\"Registry\n// entries\" + Invariant 6 + Invariant 7:\n//\n//   - Iterate `output.objectChanges`,\n//   - Find paired Sui-framework `coin::TreasuryCap<T>` +\n//     `coin::CoinMetadata<T>`,\n//   - Reject nested generics (`TreasuryCap<A<B>>` returns no record),\n//   - Sort ascending by fullCoinType for deterministic order.\n//\n// This file is PURE — no Effect, no RPC. Metadata enrichment (the\n// `getCoinMetadata` RPC fold) lives in `metadata.ts`; we just emit\n// the raw discovered shape here. The input is structural so Coin does\n// not import Package internals.\n\nimport {\n\tpickSuiFrameworkInnerGeneric,\n\tpickSuiFrameworkInnerGenericFromModule,\n} from './type-strings.ts';\n\nexport interface CoinDiscoveryObjectChange {\n\treadonly type: 'created' | 'published' | 'mutated' | 'wrapped' | 'transferred';\n\treadonly objectId?: string;\n\treadonly objectType?: string;\n\treadonly owner?: unknown;\n\treadonly json?: unknown;\n}\n\nexport interface CoinDiscoveryPublishOutput {\n\treadonly publisher: string;\n\treadonly objectChanges: ReadonlyArray<CoinDiscoveryObjectChange>;\n}\n\n/** A discovered coin pulled out of a publish output. The downstream\n *  metadata enricher in `metadata.ts` turns this into a full\n *  `CoinRecord`. */\nexport interface DiscoveredCoin {\n\t/** `0xPKG::module::Witness`. */\n\treadonly fullCoinType: string;\n\t/** Lower-cased witness name. */\n\treadonly witness: string;\n\t/** Lower-cased module name. */\n\treadonly moduleName: string;\n\treadonly treasuryCapId?: string;\n\treadonly treasuryCapOwner?: string;\n\treadonly metadataId?: string;\n\treadonly decimals?: number;\n\treadonly symbol?: string;\n\treadonly displayName?: string;\n\treadonly iconUrl?: string;\n\t/** True when the cap is address-owned by the publisher at the\n\t *  end of the publish tx. Distilled-doc invariant: the faucet's\n\t *  treasury-cap-mint auto-registration is gated off this flag. */\n\treadonly publisherOwnsCap: boolean;\n}\n\ninterface DiscoveredMetadata {\n\treadonly id: string;\n\treadonly decimals?: number;\n\treadonly symbol?: string;\n\treadonly displayName?: string;\n\treadonly iconUrl?: string;\n}\n\n/** Extract module + witness from `0xPKG::module::Witness`. */\nconst splitCoinType = (\n\tfullCoinType: string,\n): { readonly moduleName: string; readonly witness: string } | null => {\n\tconst parts = fullCoinType.split('::');\n\tif (parts.length !== 3) return null;\n\tconst [, moduleName, witness] = parts;\n\tif (moduleName === undefined || witness === undefined) return null;\n\treturn { moduleName, witness };\n};\n\n/** Read the address owner from a package-publish-output change. Handles\n *  the SDK's discriminated owner-shape; non-address owners surface as\n *  `undefined`. The owner shape varies across SDK versions; this\n *  helper covers the common surface and degrades gracefully. */\nconst pickAddressOwner = (change: CoinDiscoveryObjectChange): string | undefined => {\n\tconst owner = change.owner as\n\t\t| { readonly AddressOwner?: string; readonly $kind?: string }\n\t\t| string\n\t\t| undefined;\n\tif (owner === undefined || owner === null) return undefined;\n\tif (typeof owner === 'string') return owner; // some SDK projections flatten\n\tif (typeof owner === 'object' && 'AddressOwner' in owner) {\n\t\treturn owner.AddressOwner;\n\t}\n\treturn undefined;\n};\n\nconst pickString = (json: Record<string, unknown>, key: string): string | undefined => {\n\tconst value = json[key];\n\treturn typeof value === 'string' && value.length > 0 ? value : undefined;\n};\n\nconst pickNumber = (json: Record<string, unknown>, key: string): number | undefined => {\n\tconst value = json[key];\n\treturn typeof value === 'number' && Number.isFinite(value) ? value : undefined;\n};\n\nconst pickMetadata = (change: CoinDiscoveryObjectChange): Omit<DiscoveredMetadata, 'id'> | null => {\n\tconst json = change.json;\n\tif (json === null || typeof json !== 'object' || Array.isArray(json)) return null;\n\tconst record = json as Record<string, unknown>;\n\tconst decimals = pickNumber(record, 'decimals');\n\tconst symbol = pickString(record, 'symbol');\n\tconst displayName = pickString(record, 'name');\n\tconst iconUrl = pickString(record, 'iconUrl') ?? pickString(record, 'icon_url');\n\tif (\n\t\tdecimals === undefined &&\n\t\tsymbol === undefined &&\n\t\tdisplayName === undefined &&\n\t\ticonUrl === undefined\n\t) {\n\t\treturn null;\n\t}\n\treturn {\n\t\t...(decimals === undefined ? {} : { decimals }),\n\t\t...(symbol === undefined ? {} : { symbol }),\n\t\t...(displayName === undefined ? {} : { displayName }),\n\t\t...(iconUrl === undefined ? {} : { iconUrl }),\n\t};\n};\n\n/** Walk a publish output for coin pairs.\n *\n *  Sort ascending by fullCoinType — distilled-doc invariant 6 — so\n *  the registry sees a stable order across re-runs of the same\n *  publish.\n *\n *  Pure. No Effect / RPC. */\nexport const discoverCoinsFromPublish = (\n\toutput: CoinDiscoveryPublishOutput,\n): ReadonlyArray<DiscoveredCoin> => {\n\tconst publisher = output.publisher;\n\t// Two passes over the changes: collect caps, collect metadata,\n\t// then JOIN on fullCoinType. The straightforward \"iterate once and\n\t// build per-coin records\" is harder to read when the two object\n\t// types interleave in the output.\n\tconst caps = new Map<string, { readonly id: string; readonly owner: string | undefined }>();\n\tconst metadata = new Map<string, DiscoveredMetadata>();\n\n\tfor (const change of output.objectChanges) {\n\t\tif (change.type !== 'created') continue;\n\t\tif (!change.objectType) continue;\n\t\tconst capInner = pickSuiFrameworkInnerGeneric(change.objectType, 'TreasuryCap');\n\t\tif (capInner !== null && change.objectId !== undefined) {\n\t\t\tcaps.set(capInner, {\n\t\t\t\tid: change.objectId,\n\t\t\t\towner: pickAddressOwner(change),\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst metaInner = pickSuiFrameworkInnerGeneric(change.objectType, 'CoinMetadata');\n\t\tif (metaInner !== null && change.objectId !== undefined) {\n\t\t\tmetadata.set(metaInner, {\n\t\t\t\tid: change.objectId,\n\t\t\t\t...(pickMetadata(change) ?? {}),\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst currencyInner = pickSuiFrameworkInnerGenericFromModule(\n\t\t\tchange.objectType,\n\t\t\t'coin_registry',\n\t\t\t'Currency',\n\t\t);\n\t\tif (currencyInner !== null && change.objectId !== undefined) {\n\t\t\tmetadata.set(currencyInner, {\n\t\t\t\tid: change.objectId,\n\t\t\t\t...(pickMetadata(change) ?? {}),\n\t\t\t});\n\t\t}\n\t}\n\n\t// Union the two sets of coin types — a coin with only a cap or\n\t// only metadata is still a coin (distilled-doc invariant: we\n\t// surface degraded records rather than drop them).\n\tconst allTypes = new Set<string>([...caps.keys(), ...metadata.keys()]);\n\tconst records: Array<DiscoveredCoin> = [];\n\tfor (const fullCoinType of allTypes) {\n\t\tconst parts = splitCoinType(fullCoinType);\n\t\tif (!parts) continue;\n\t\tconst cap = caps.get(fullCoinType);\n\t\tconst meta = metadata.get(fullCoinType);\n\t\tconst publisherOwnsCap = cap !== undefined && cap.owner === publisher;\n\t\trecords.push({\n\t\t\tfullCoinType,\n\t\t\twitness: parts.witness.toLowerCase(),\n\t\t\tmoduleName: parts.moduleName.toLowerCase(),\n\t\t\ttreasuryCapId: cap?.id,\n\t\t\ttreasuryCapOwner: cap?.owner,\n\t\t\tmetadataId: meta?.id,\n\t\t\t...(meta?.decimals === undefined ? {} : { decimals: meta.decimals }),\n\t\t\t...(meta?.symbol === undefined ? {} : { symbol: meta.symbol }),\n\t\t\t...(meta?.displayName === undefined ? {} : { displayName: meta.displayName }),\n\t\t\t...(meta?.iconUrl === undefined ? {} : { iconUrl: meta.iconUrl }),\n\t\t\tpublisherOwnsCap,\n\t\t});\n\t}\n\t// Distilled-doc invariant 6: ascending sort by fullCoinType. Stable\n\t// across re-runs so the \"first wins on collision\" tie-break is\n\t// deterministic.\n\trecords.sort((a, b) =>\n\t\ta.fullCoinType < b.fullCoinType ? -1 : a.fullCoinType > b.fullCoinType ? 1 : 0,\n\t);\n\treturn records;\n};\n"],"mappings":"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"}

package/dist/plugins/coin/errors.d.mts

@@ -0,0 +1,48 @@
+//#region src/plugins/coin/errors.d.ts
+/** Phases for `CoinError`. Closed sum — adding a phase requires
+ *  editing this list AND the cause walker's display table.
+ *
+ *  Phase semantics:
+ *   - `not-found`           — symbol/witness/bare-type didn't resolve
+ *                             against the registry / on-chain metadata.
+ *   - `ambiguous`           — two distinct coin types matched a single
+ *                             registry-key lookup. Caller should
+ *                             disambiguate via the witness form.
+ *   - `nested-generic`      — bare-coin-type rejected because it
+ *                             carried a nested generic (`<T<U>>`).
+ *                             Distilled-doc invariant 7: refuse to
+ *                             guess. Surfaces during the discovery
+ *                             walker AND during the address-resolution
+ *                             bare-string branch.
+ *   - `cap-missing`         — the package didn't capture a
+ *                             `TreasuryCap` under the requested field
+ *                             (either no cap at all, or the captured
+ *                             record key is wrong).
+ *   - `metadata-fetch`      — `getCoinMetadata` failed after retries.
+ *                             Soft-degradation path: the discovery
+ *                             walker swallows this to keep partial
+ *                             coverage; the bare-coin-type branch of
+ *                             the user-facing factory surfaces it.
+ *   - `mint-tx`             — sign-and-execute of the mint tx failed.
+ *   - `mint-parse`          — the minted `Coin<T>` was not present in
+ *                             the resulting `objectChanges`. */
+type CoinPhase = 'not-found' | 'ambiguous' | 'nested-generic' | 'cap-missing' | 'metadata-fetch' | 'mint-tx' | 'mint-parse';
+/** Single tagged coin error. */
+interface CoinError {
+  readonly _tag: 'CoinError';
+  readonly phase: CoinPhase;
+  /** User-facing identifier — the symbol / witness / bare-type the
+   *  caller passed. Populated even when the cause was a mint
+   *  (in which case it carries the resolved fullCoinType so the
+   *  pretty-cause walker can render context). */
+  readonly identifier: string;
+  readonly message: string;
+  /** Optional list of registered candidates — populated by
+   *  `not-found` / `ambiguous` so the renderer can show what WAS
+   *  available. */
+  readonly candidates?: ReadonlyArray<string>;
+  readonly cause?: unknown;
+}
+//#endregion
+export { CoinError, CoinPhase };
+//# sourceMappingURL=errors.d.mts.map

package/dist/plugins/coin/errors.mjs

@@ -0,0 +1,13 @@
+//#region src/plugins/coin/errors.ts
+const coinError = (phase, parts) => ({
+	_tag: "CoinError",
+	phase,
+	...parts
+});
+/** Error tags this plugin contributes — surfaced to the cause walker
+*  via `PluginErrorContribution`. */
+const COIN_ERROR_TAGS = ["CoinError"];
+//#endregion
+export { COIN_ERROR_TAGS, coinError };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/plugins/coin/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../src/plugins/coin/errors.ts"],"sourcesContent":["// Coin plugin — typed errors.\n//\n// Distilled-doc finding (13-coin.md Pain point #8 \"No CoinError tag at\n// all\"): the v3 coin module reused `PublishError` for mint failures\n// and surfaced `CoinNotFoundError` / `CoinAmbiguousError` only on the\n// factory path. The redesign unifies coin-side failures into a SINGLE\n// tagged error with a CLOSED phase set so downstream `catchTag`\n// callers can distinguish \"not in registry\" from \"mint failed\" from\n// \"cap missing\".\n//\n// Effect v4: plain interface + `_tag` literal discriminator (no\n// subclassing). Mirrors the Account plugin's split shape and the\n// substrate's per-plugin tagged-error convention.\n\n/** Phases for `CoinError`. Closed sum — adding a phase requires\n *  editing this list AND the cause walker's display table.\n *\n *  Phase semantics:\n *   - `not-found`           — symbol/witness/bare-type didn't resolve\n *                             against the registry / on-chain metadata.\n *   - `ambiguous`           — two distinct coin types matched a single\n *                             registry-key lookup. Caller should\n *                             disambiguate via the witness form.\n *   - `nested-generic`      — bare-coin-type rejected because it\n *                             carried a nested generic (`<T<U>>`).\n *                             Distilled-doc invariant 7: refuse to\n *                             guess. Surfaces during the discovery\n *                             walker AND during the address-resolution\n *                             bare-string branch.\n *   - `cap-missing`         — the package didn't capture a\n *                             `TreasuryCap` under the requested field\n *                             (either no cap at all, or the captured\n *                             record key is wrong).\n *   - `metadata-fetch`      — `getCoinMetadata` failed after retries.\n *                             Soft-degradation path: the discovery\n *                             walker swallows this to keep partial\n *                             coverage; the bare-coin-type branch of\n *                             the user-facing factory surfaces it.\n *   - `mint-tx`             — sign-and-execute of the mint tx failed.\n *   - `mint-parse`          — the minted `Coin<T>` was not present in\n *                             the resulting `objectChanges`. */\nexport type CoinPhase =\n\t| 'not-found'\n\t| 'ambiguous'\n\t| 'nested-generic'\n\t| 'cap-missing'\n\t| 'metadata-fetch'\n\t| 'mint-tx'\n\t| 'mint-parse';\n\n/** Single tagged coin error. */\nexport interface CoinError {\n\treadonly _tag: 'CoinError';\n\treadonly phase: CoinPhase;\n\t/** User-facing identifier — the symbol / witness / bare-type the\n\t *  caller passed. Populated even when the cause was a mint\n\t *  (in which case it carries the resolved fullCoinType so the\n\t *  pretty-cause walker can render context). */\n\treadonly identifier: string;\n\treadonly message: string;\n\t/** Optional list of registered candidates — populated by\n\t *  `not-found` / `ambiguous` so the renderer can show what WAS\n\t *  available. */\n\treadonly candidates?: ReadonlyArray<string>;\n\treadonly cause?: unknown;\n}\n\nexport const coinError = (\n\tphase: CoinPhase,\n\tparts: Omit<CoinError, '_tag' | 'phase'>,\n): CoinError => ({ _tag: 'CoinError', phase, ...parts });\n\n/** Error tags this plugin contributes — surfaced to the cause walker\n *  via `PluginErrorContribution`. */\nexport const COIN_ERROR_TAGS = ['CoinError'] as const;\n"],"mappings":";AAmEA,MAAa,aACZ,OACA,WACgB;CAAE,MAAM;CAAa;CAAO,GAAG;CAAO;;;AAIvD,MAAa,kBAAkB,CAAC,YAAY"}

package/dist/plugins/coin/index.d.mts

@@ -0,0 +1,95 @@
+import { CodegenableDecl } from "../../contracts/codegenable.mjs";
+import { SnapshotableDecl } from "../../contracts/snapshotable.mjs";
+import { StrategyContributorDecl } from "../../contracts/strategy-contributor.mjs";
+import { AnyResourceRef, Plugin, ResourceRef } from "../../substrate/plugin.mjs";
+import { SeedObjectsAccumulator } from "../sui/seed-objects.mjs";
+import { SuiClient } from "../sui/mode/shared.mjs";
+import { SuiOptions } from "../sui/mode/spec.mjs";
+import { ArtifactPublishError } from "../../primitives/artifact-publisher.mjs";
+import { CoinError, CoinPhase } from "./errors.mjs";
+import { MintResult, MintSigner } from "./mint.mjs";
+import { isBareCoinType, validateBareCoinType } from "./metadata.mjs";
+import { BUILTIN_COINS, BuiltinCoinName, ResolvedCoin } from "./address-resolution.mjs";
+import { CoinAddressForm, CoinValue } from "./service.mjs";
+import { CoinBindings } from "./codegen.mjs";
+import { DiscoveredCoin } from "./discovery.mjs";
+import { Effect } from "effect";
+
+//#region src/plugins/coin/index.d.ts
+type CoinResourceId<Sym extends string> = `coin:${Sym}`;
+type PackageNameOf<Pkg extends PackageMember> = Pkg extends ResourceRef<`package:${infer Name}`, PackageMemberValue> ? Name : string;
+/** A user-supplied package ref. The user passes the result of
+ *  `localPackage('foo', …)` / `knownPackage('foo', …)` — NOT a bare string
+ *  value. Generic over the literal package name so the witness-form
+ *  coin's dependency preserves the per-package resource id. */
+interface PackageMemberValue {
+  readonly name: string;
+  readonly packageId: string;
+  readonly publisher?: MintSigner;
+}
+type PackageMember<Name extends string = string> = ResourceRef<`package:${Name}`, PackageMemberValue>;
+/** User-facing factory namespace. Three variants — see file header for
+ *  the rationale on not exposing a `coin(identifier)` form-guessing
+ *  entry. */
+declare const coin: {
+  readonly fromPackage: <const Pkg extends PackageMember, Wit extends string>(pkg: Pkg, witnessName: Wit) => Plugin<`coin:${PackageNameOf<Pkg>}/${Lowercase<Wit>}`, CoinValue, {
+    readonly pkg: Pkg;
+    readonly sui: ResourceRef<"sui", SuiClient & {
+      readonly mode: SuiOptions["mode"];
+      readonly seedObjects: SeedObjectsAccumulator;
+    }>;
+  } extends infer T ? T extends {
+    readonly pkg: Pkg;
+    readonly sui: ResourceRef<"sui", SuiClient & {
+      readonly mode: SuiOptions["mode"];
+      readonly seedObjects: SeedObjectsAccumulator;
+    }>;
+  } ? T extends Readonly<Record<string, AnyResourceRef>> ? readonly T[keyof T][] : readonly [] : never : never, readonly [SnapshotableDecl, CodegenableDecl<`coin/${string}`>, StrategyContributorDecl<"coin-registry", {
+    readonly symbol: string;
+  }>, ...{
+    kind: "strategy-contributor";
+    capabilityKey: `coinType:${string}`;
+    strategy: {
+      readonly request: (req: {
+        readonly address: string;
+        readonly amount: bigint;
+      }) => Effect.Effect<void, CoinError | ArtifactPublishError>;
+    };
+    autoMounted: true;
+  }[]]>;
+  readonly known: <FullType extends string>(fullCoinType: FullType) => Plugin<`coin:${string}`, CoinValue, readonly ResourceRef<"sui", SuiClient & {
+    readonly mode: SuiOptions["mode"];
+    readonly seedObjects: SeedObjectsAccumulator;
+  }>[], readonly [SnapshotableDecl, CodegenableDecl<`coin/${string}`>, StrategyContributorDecl<"coin-registry", {
+    readonly symbol: string;
+  }>, ...{
+    kind: "strategy-contributor";
+    capabilityKey: `coinType:${string}`;
+    strategy: {
+      readonly request: (req: {
+        readonly address: string;
+        readonly amount: bigint;
+      }) => Effect.Effect<void, CoinError | ArtifactPublishError>;
+    };
+    autoMounted: true;
+  }[]]>;
+  readonly builtin: <Name extends keyof typeof BUILTIN_COINS>(name: Name) => Plugin<`coin:${Name}`, CoinValue, readonly ResourceRef<"sui", SuiClient & {
+    readonly mode: SuiOptions["mode"];
+    readonly seedObjects: SeedObjectsAccumulator;
+  }>[], readonly [SnapshotableDecl, CodegenableDecl<`coin/${string}`>, StrategyContributorDecl<"coin-registry", {
+    readonly symbol: string;
+  }>, ...{
+    kind: "strategy-contributor";
+    capabilityKey: `coinType:${string}`;
+    strategy: {
+      readonly request: (req: {
+        readonly address: string;
+        readonly amount: bigint;
+      }) => Effect.Effect<void, CoinError | ArtifactPublishError>;
+    };
+    autoMounted: true;
+  }[]]>;
+};
+//#endregion
+export { CoinResourceId, PackageMember, coin };
+//# sourceMappingURL=index.d.mts.map

package/dist/plugins/coin/index.mjs

@@ -0,0 +1,172 @@
+import { definePlugin, resource } from "../../substrate/plugin.mjs";
+import { pluginErrorContributions } from "../../api/plugin-errors.mjs";
+import { suiResource } from "../sui/index.mjs";
+import { ArtifactPublisherService } from "../../substrate/runtime/artifact-publisher/index.mjs";
+import "./discovery.mjs";
+import { COIN_REGISTRY_CAPABILITY_KEY, CoinRegistryService } from "./registry.mjs";
+import { makeCoinCodegen } from "./codegen.mjs";
+import { makeCoinSnapshotable } from "./snapshot.mjs";
+import { COIN_ERROR_TAGS } from "./errors.mjs";
+import "./metadata.mjs";
+import "./address-resolution.mjs";
+import "./mint.mjs";
+import { acquireCoin } from "./service.mjs";
+import { Effect } from "effect";
+//#region src/plugins/coin/index.ts
+const coinErrorContributions = pluginErrorContributions(COIN_ERROR_TAGS);
+const coinFundingCapabilityKey = (fullCoinType) => `coinType:${fullCoinType}`;
+/** Resource id constructor. The symbolic name is part of the resource identity
+*  so the substrate's compose-time dedup catches collisions. */
+const coinResourceId = (symbol) => `coin:${symbol}`;
+const packageNameFromMember = (pkg) => pkg.id.slice(8);
+const projectCoinSdk = (sui) => {
+	const grpcClient = sui.sdk.client;
+	return {
+		core: {
+			getObject: sui.sdk.core.getObject,
+			getCoinMetadata: (args) => grpcClient.core.getCoinMetadata(args)
+		},
+		client: sui.sdk.client
+	};
+};
+const buildCapabilities = (symbol, resolved) => {
+	const bindings = {
+		symbol: resolved.symbol ?? symbol,
+		fullCoinType: resolved.fullCoinType,
+		decimals: resolved.decimals,
+		source: resolved.source,
+		...resolved.displayName !== void 0 ? { displayName: resolved.displayName } : {},
+		...resolved.iconUrl !== void 0 ? { iconUrl: resolved.iconUrl } : {},
+		...resolved.treasuryCapId !== void 0 ? { treasuryCapId: resolved.treasuryCapId } : {},
+		...resolved.metadataId !== void 0 ? { metadataId: resolved.metadataId } : {},
+		...resolved.packageId !== void 0 ? { packageId: resolved.packageId } : {}
+	};
+	return [
+		makeCoinSnapshotable({ symbol }),
+		makeCoinCodegen({
+			symbol,
+			resolved: bindings
+		}),
+		{
+			kind: "strategy-contributor",
+			capabilityKey: COIN_REGISTRY_CAPABILITY_KEY,
+			strategy: { symbol },
+			autoMounted: true
+		},
+		...resolved.fundingStrategy === void 0 ? [] : [{
+			kind: "strategy-contributor",
+			capabilityKey: coinFundingCapabilityKey(resolved.fullCoinType),
+			strategy: resolved.fundingStrategy,
+			autoMounted: true
+		}]
+	];
+};
+/** Resolve a coin by `(publishing package member, witness)`. Forces
+*  a dep edge on the publishing package's resource — the substrate ensures
+*  the publish has completed before this resolves.
+*
+*  Resource identity includes both the package's symbolic name and the
+*  witness name, so two packages can expose the same witness without
+*  colliding in the substrate graph.
+*
+*  Pass the package MEMBER (the value returned by `localPackage(...)`
+*  / `knownPackage(...)`). The factory
+*  projects it to a dependency resource and receives the package value
+*  in `start`. */
+const fromPackage = (pkg, witnessName) => {
+	const packageName = packageNameFromMember(pkg);
+	const symbol = witnessName.toLowerCase();
+	return definePlugin({
+		id: resource(coinResourceId(`${packageName}/${symbol}`)).id,
+		dependsOn: {
+			pkg,
+			sui: suiResource
+		},
+		role: "task",
+		start: ({ pkg: resolved, sui }) => Effect.gen(function* () {
+			const artifactPublisher = yield* ArtifactPublisherService;
+			const registry = yield* CoinRegistryService;
+			return yield* acquireCoin({
+				kind: "witness",
+				publishingPackageName: resolved.name,
+				witness: witnessName,
+				...resolved.publisher === void 0 ? {} : { fundingSigner: resolved.publisher }
+			}, {
+				registry,
+				sdk: projectCoinSdk(sui),
+				chain: sui.chain,
+				publisher: artifactPublisher
+			});
+		}),
+		errorContributions: coinErrorContributions,
+		capabilities: ({ value }) => buildCapabilities(symbol, value)
+	});
+};
+/** Resolve a coin by bare on-chain type via `getCoinMetadata`.
+*  Used for live-net coins (mainnet DEEP, USDC etc.) that no local
+*  `Package(...)` publishes.
+*
+*  Soft-degrades to `decimals: 0` on RPC failure — distilled-doc
+*  invariant. Resource id uses a deterministic-but-readable derivation of
+*  the coin type so collisions surface at compose time. */
+const known = (fullCoinType) => {
+	const id = fullCoinType.replace(/^0x/, "").replace(/::/g, "_").slice(0, 60);
+	return definePlugin({
+		id: resource(coinResourceId(id)).id,
+		dependsOn: { sui: suiResource },
+		role: "task",
+		start: ({ sui }) => Effect.gen(function* () {
+			const publisher = yield* ArtifactPublisherService;
+			const registry = yield* CoinRegistryService;
+			return yield* acquireCoin({
+				kind: "known",
+				fullCoinType
+			}, {
+				registry,
+				sdk: projectCoinSdk(sui),
+				chain: sui.chain,
+				publisher
+			});
+		}),
+		errorContributions: coinErrorContributions,
+		capabilities: ({ value }) => buildCapabilities(id, value)
+	});
+};
+/** Resolve a protocol-defined builtin coin. Currently `'sui'` only —
+*  distilled-doc 13-coin.md Invariant 4: SUI is `0x2::sui::SUI`,
+*  decimals=9. No RPC, no registry. */
+const builtin = (name) => {
+	const symbol = name;
+	return definePlugin({
+		id: resource(coinResourceId(name)).id,
+		dependsOn: { sui: suiResource },
+		role: "task",
+		start: ({ sui }) => Effect.gen(function* () {
+			const publisher = yield* ArtifactPublisherService;
+			const registry = yield* CoinRegistryService;
+			return yield* acquireCoin({
+				kind: "builtin",
+				name
+			}, {
+				registry,
+				sdk: projectCoinSdk(sui),
+				chain: sui.chain,
+				publisher
+			});
+		}),
+		errorContributions: coinErrorContributions,
+		capabilities: ({ value }) => buildCapabilities(symbol, value)
+	});
+};
+/** User-facing factory namespace. Three variants — see file header for
+*  the rationale on not exposing a `coin(identifier)` form-guessing
+*  entry. */
+const coin = {
+	fromPackage,
+	known,
+	builtin
+};
+//#endregion
+export { coin, coinResourceId };
+
+//# sourceMappingURL=index.mjs.map

package/dist/plugins/coin/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../src/plugins/coin/index.ts"],"sourcesContent":["// Coin plugin — barrel + `coin(...)` factory family.\n//\n// Architecture (13-coin.md): Coin is the user-facing primitive family\n// for *addressing* custom Move coin types. It does NOT publish Move\n// modules itself — the Package plugin publishes; coin auto-discovery\n// (in `discovery.ts`) folds the publish output into the per-stack\n// `CoinRegistry`; this factory resolves user-supplied addresses\n// (witness / bare-type / builtin) against that registry plus the live RPC.\n//\n// User-facing factory shape — three variants mirroring the address\n// forms:\n//\n//   coin.fromPackage(pkg, 'MOCK_USDC')       // package member → registry\n//   coin.known('0x...::deep::DEEP')          // bare → live RPC\n//   coin.builtin('sui')                      // protocol-defined constant\n//\n// (A `coin(identifier)` convenience entry is intentionally NOT\n// exposed — distilled-doc 13-coin.md Pain point #6 documents how the\n// \"guess the form from the string\" path is a footgun. The three-form\n// surface forces the user to make the disambiguation explicit at the\n// call site.)\n//\n// Resource id: `'coin:<package>/<witness>'` for package-scoped coins and\n// `'coin:<identifier>'` for known/builtin coins — one tag per declared\n// coin instance, so the substrate's compose-time dedup detects collisions\n// cleanly. Mirrors the Package plugin's per-instance resource identity.\n\nimport { Effect } from 'effect';\n\nimport { definePlugin, resource, type ResourceRef } from '../../api/define-plugin.ts';\nimport { pluginErrorContributions } from '../../api/plugin-errors.ts';\nimport type { CodegenableDecl } from '../../contracts/codegenable.ts';\nimport type { SnapshotableDecl } from '../../contracts/snapshotable.ts';\nimport type { StrategyContributorDecl } from '../../contracts/strategy-contributor.ts';\nimport { ArtifactPublisherService } from '../../substrate/runtime/artifact-publisher/index.ts';\nimport { suiResource } from '../sui/index.ts';\nimport type { SuiClient } from '../sui/index.ts';\nimport type { AccountFundingStrategy } from '../account/funding.ts';\n\nimport { makeCoinCodegen, type CoinBindings } from './codegen.ts';\nimport { makeCoinSnapshotable } from './snapshot.ts';\nimport { COIN_REGISTRY_CAPABILITY_KEY, CoinRegistryService } from './registry.ts';\nimport { COIN_ERROR_TAGS } from './errors.ts';\nimport { acquireCoin, type CoinAddressForm, type CoinValue } from './service.ts';\nimport { BUILTIN_COINS } from './address-resolution.ts';\nimport type { MetadataSdkShim } from './metadata.ts';\nimport type { MintSdkShim } from './mint.ts';\n\nconst coinErrorContributions = pluginErrorContributions(COIN_ERROR_TAGS);\n\nexport const coinFundingCapabilityKey = <FullType extends string>(\n\tfullCoinType: FullType,\n): `coinType:${FullType}` => `coinType:${fullCoinType}` as const;\n\n// ---------------------------------------------------------------------------\n// Resource — one per declared coin instance, keyed by explicit address form.\n// ---------------------------------------------------------------------------\n\n/** Resource id constructor. The symbolic name is part of the resource identity\n *  so the substrate's compose-time dedup catches collisions. */\nexport const coinResourceId = <Sym extends string>(symbol: Sym): `coin:${Sym}` => `coin:${symbol}`;\n\nexport type CoinResourceId<Sym extends string> = `coin:${Sym}`;\n\ntype PackageNameOf<Pkg extends PackageMember> =\n\tPkg extends ResourceRef<`package:${infer Name}`, PackageMemberValue> ? Name : string;\n\ntype PackageCoinResourceKey<\n\tPkg extends PackageMember,\n\tWit extends string,\n> = `${PackageNameOf<Pkg>}/${Lowercase<Wit>}`;\n\nconst packageNameFromMember = <Pkg extends PackageMember>(pkg: Pkg): PackageNameOf<Pkg> =>\n\tpkg.id.slice('package:'.length) as PackageNameOf<Pkg>;\n\n// ---------------------------------------------------------------------------\n// SDK shim projection\n// ---------------------------------------------------------------------------\n//\n// The coin plugin's resolvers need three Sui surfaces: `core.getObject`\n// (mint verify probe), `core.getCoinMetadata` (bare-type address form),\n// and the opaque `client` (`Transaction.build({client})` in the mint\n// produce body).\n//\n// `sui.sdk.core.getObject` is on the typed `SuiSdkShim`; `getCoinMetadata`\n// lives on the underlying `SuiGrpcClient` reached via the opaque\n// `sui.sdk.client`. We project both onto a single `MetadataSdkShim &\n// MintSdkShim` here at the boundary — the cast mirrors STYLE_GUIDE §14\n// (localized cast through an opaque SDK surface), kept narrow to one\n// method projection.\n\nconst projectCoinSdk = (sui: SuiClient): MetadataSdkShim & MintSdkShim => {\n\tconst grpcClient = sui.sdk.client as {\n\t\treadonly core: {\n\t\t\treadonly getCoinMetadata: (args: { readonly coinType: string }) => Promise<unknown>;\n\t\t};\n\t};\n\treturn {\n\t\tcore: {\n\t\t\tgetObject: sui.sdk.core.getObject,\n\t\t\tgetCoinMetadata: (args) => grpcClient.core.getCoinMetadata(args),\n\t\t},\n\t\tclient: sui.sdk.client,\n\t};\n};\n\n// ---------------------------------------------------------------------------\n// Per-form capability builders — dynamic (POST-acquire). Receive the\n// resolved `CoinValue` so codegen bindings stamp the REAL fullCoinType\n// + decimals instead of placeholder values.\n// ---------------------------------------------------------------------------\n\nconst buildCapabilities = (symbol: string, resolved: CoinValue) => {\n\tconst bindings: CoinBindings = {\n\t\tsymbol: resolved.symbol ?? symbol,\n\t\tfullCoinType: resolved.fullCoinType,\n\t\tdecimals: resolved.decimals,\n\t\tsource: resolved.source,\n\t\t...(resolved.displayName !== undefined ? { displayName: resolved.displayName } : {}),\n\t\t...(resolved.iconUrl !== undefined ? { iconUrl: resolved.iconUrl } : {}),\n\t\t...(resolved.treasuryCapId !== undefined ? { treasuryCapId: resolved.treasuryCapId } : {}),\n\t\t...(resolved.metadataId !== undefined ? { metadataId: resolved.metadataId } : {}),\n\t\t...(resolved.packageId !== undefined ? { packageId: resolved.packageId } : {}),\n\t};\n\tconst snap: SnapshotableDecl = makeCoinSnapshotable({ symbol });\n\tconst codegen: CodegenableDecl<`coin/${string}`> = makeCoinCodegen({\n\t\tsymbol,\n\t\tresolved: bindings,\n\t});\n\t// Auto-mounted strategy contribution — siblings (Wallet, Faucet's\n\t// treasury-cap mint, Deepbook market-maker) read the per-stack\n\t// registry via this seam. The actual `CoinRegistry` instance is\n\t// wired at compose time (one registry per stack); each coin\n\t// contributes its `register(record)` call as a side effect at\n\t// acquire.\n\tconst registryContribution: StrategyContributorDecl<\n\t\ttypeof COIN_REGISTRY_CAPABILITY_KEY,\n\t\t{ readonly symbol: string }\n\t> = {\n\t\tkind: 'strategy-contributor',\n\t\tcapabilityKey: COIN_REGISTRY_CAPABILITY_KEY,\n\t\tstrategy: { symbol },\n\t\tautoMounted: true,\n\t};\n\tconst fundingContribution =\n\t\tresolved.fundingStrategy === undefined\n\t\t\t? []\n\t\t\t: [\n\t\t\t\t\t{\n\t\t\t\t\t\tkind: 'strategy-contributor',\n\t\t\t\t\t\tcapabilityKey: coinFundingCapabilityKey(resolved.fullCoinType),\n\t\t\t\t\t\tstrategy: resolved.fundingStrategy,\n\t\t\t\t\t\tautoMounted: true,\n\t\t\t\t\t} satisfies StrategyContributorDecl<`coinType:${string}`, AccountFundingStrategy>,\n\t\t\t\t];\n\treturn [snap, codegen, registryContribution, ...fundingContribution] as const;\n};\n\n// ---------------------------------------------------------------------------\n// Form 1: coin.fromPackage(pkg, witness) — package-scoped registry lookup\n// ---------------------------------------------------------------------------\n\n/** A user-supplied package ref. The user passes the result of\n *  `localPackage('foo', …)` / `knownPackage('foo', …)` — NOT a bare string\n *  value. Generic over the literal package name so the witness-form\n *  coin's dependency preserves the per-package resource id. */\nexport interface PackageMemberValue {\n\treadonly name: string;\n\treadonly packageId: string;\n\treadonly publisher?: import('./mint.ts').MintSigner;\n}\n\nexport type PackageMember<Name extends string = string> = ResourceRef<\n\t`package:${Name}`,\n\tPackageMemberValue\n>;\n\n/** Resolve a coin by `(publishing package member, witness)`. Forces\n *  a dep edge on the publishing package's resource — the substrate ensures\n *  the publish has completed before this resolves.\n *\n *  Resource identity includes both the package's symbolic name and the\n *  witness name, so two packages can expose the same witness without\n *  colliding in the substrate graph.\n *\n *  Pass the package MEMBER (the value returned by `localPackage(...)`\n *  / `knownPackage(...)`). The factory\n *  projects it to a dependency resource and receives the package value\n *  in `start`. */\nexport const fromPackage = <const Pkg extends PackageMember, Wit extends string>(\n\tpkg: Pkg,\n\twitnessName: Wit,\n) => {\n\tconst packageName = packageNameFromMember(pkg);\n\tconst symbol = witnessName.toLowerCase() as Lowercase<Wit>;\n\tconst resourceKey = `${packageName}/${symbol}` as PackageCoinResourceKey<Pkg, Wit>;\n\tconst coinRef = resource<CoinResourceId<typeof resourceKey>, CoinValue>(\n\t\tcoinResourceId(resourceKey),\n\t);\n\treturn definePlugin({\n\t\tid: coinRef.id,\n\t\tdependsOn: { pkg, sui: suiResource },\n\t\trole: 'task',\n\t\tstart: ({ pkg: resolved, sui }) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst artifactPublisher = yield* ArtifactPublisherService;\n\t\t\t\tconst registry = yield* CoinRegistryService;\n\t\t\t\tconst form: CoinAddressForm = {\n\t\t\t\t\tkind: 'witness',\n\t\t\t\t\tpublishingPackageName: resolved.name,\n\t\t\t\t\twitness: witnessName,\n\t\t\t\t\t...(resolved.publisher === undefined ? {} : { fundingSigner: resolved.publisher }),\n\t\t\t\t};\n\t\t\t\treturn yield* acquireCoin(form, {\n\t\t\t\t\tregistry,\n\t\t\t\t\tsdk: projectCoinSdk(sui),\n\t\t\t\t\tchain: sui.chain,\n\t\t\t\t\tpublisher: artifactPublisher,\n\t\t\t\t});\n\t\t\t}),\n\t\terrorContributions: coinErrorContributions,\n\t\tcapabilities: ({ value }) => buildCapabilities(symbol, value),\n\t});\n};\n\n// ---------------------------------------------------------------------------\n// Form 2: coin.known(fullCoinType) — bare on-chain type\n// ---------------------------------------------------------------------------\n\n/** Resolve a coin by bare on-chain type via `getCoinMetadata`.\n *  Used for live-net coins (mainnet DEEP, USDC etc.) that no local\n *  `Package(...)` publishes.\n *\n *  Soft-degrades to `decimals: 0` on RPC failure — distilled-doc\n *  invariant. Resource id uses a deterministic-but-readable derivation of\n *  the coin type so collisions surface at compose time. */\nexport const known = <FullType extends string>(fullCoinType: FullType) => {\n\t// Derive a resource id from the type: keep it readable but unique. The\n\t// substrate's compose-time dedup uses string equality on the id.\n\tconst id = fullCoinType.replace(/^0x/, '').replace(/::/g, '_').slice(0, 60);\n\tconst coinRef = resource<CoinResourceId<typeof id>, CoinValue>(\n\t\tcoinResourceId(id) as CoinResourceId<typeof id>,\n\t);\n\treturn definePlugin({\n\t\tid: coinRef.id,\n\t\tdependsOn: { sui: suiResource },\n\t\trole: 'task',\n\t\tstart: ({ sui }) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst publisher = yield* ArtifactPublisherService;\n\t\t\t\tconst registry = yield* CoinRegistryService;\n\t\t\t\tconst form: CoinAddressForm = { kind: 'known', fullCoinType };\n\t\t\t\treturn yield* acquireCoin(form, {\n\t\t\t\t\tregistry,\n\t\t\t\t\tsdk: projectCoinSdk(sui),\n\t\t\t\t\tchain: sui.chain,\n\t\t\t\t\tpublisher,\n\t\t\t\t});\n\t\t\t}),\n\t\terrorContributions: coinErrorContributions,\n\t\tcapabilities: ({ value }) => buildCapabilities(id, value),\n\t});\n};\n\n// ---------------------------------------------------------------------------\n// Form 3: coin.builtin('sui') — protocol-defined constant\n// ---------------------------------------------------------------------------\n\n/** Resolve a protocol-defined builtin coin. Currently `'sui'` only —\n *  distilled-doc 13-coin.md Invariant 4: SUI is `0x2::sui::SUI`,\n *  decimals=9. No RPC, no registry. */\nexport const builtin = <Name extends keyof typeof BUILTIN_COINS>(name: Name) => {\n\tconst symbol = name; // 'sui' today\n\tconst coinRef = resource<CoinResourceId<Name>, CoinValue>(coinResourceId(name));\n\treturn definePlugin({\n\t\tid: coinRef.id,\n\t\tdependsOn: { sui: suiResource },\n\t\trole: 'task',\n\t\tstart: ({ sui }) =>\n\t\t\tEffect.gen(function* () {\n\t\t\t\tconst publisher = yield* ArtifactPublisherService;\n\t\t\t\tconst registry = yield* CoinRegistryService;\n\t\t\t\tconst form: CoinAddressForm = { kind: 'builtin', name };\n\t\t\t\treturn yield* acquireCoin(form, {\n\t\t\t\t\tregistry,\n\t\t\t\t\tsdk: projectCoinSdk(sui),\n\t\t\t\t\tchain: sui.chain,\n\t\t\t\t\tpublisher,\n\t\t\t\t});\n\t\t\t}),\n\t\terrorContributions: coinErrorContributions,\n\t\tcapabilities: ({ value }) => buildCapabilities(symbol, value),\n\t});\n};\n\n// ---------------------------------------------------------------------------\n// Public `coin` namespace\n// ---------------------------------------------------------------------------\n\n/** User-facing factory namespace. Three variants — see file header for\n *  the rationale on not exposing a `coin(identifier)` form-guessing\n *  entry. */\nexport const coin = {\n\tfromPackage,\n\tknown,\n\tbuiltin,\n} as const;\n\n// ---------------------------------------------------------------------------\n// Re-exports — advanced callers (Wallet, Faucet, Deepbook, examples)\n// ---------------------------------------------------------------------------\n\nexport type { CoinValue, CoinAddressForm } from './service.ts';\nexport type { ResolvedCoin, BuiltinCoinName } from './address-resolution.ts';\nexport { BUILTIN_COINS } from './address-resolution.ts';\n\nexport type { CoinRecord, CoinRegistry, CoinKey } from './registry.ts';\nexport {\n\tCOIN_REGISTRY_CAPABILITY_KEY,\n\tCoinRegistryService,\n\tcoinRegistryLayer,\n} from './registry.ts';\n\nexport type { CoinBindings } from './codegen.ts';\n\nexport type { DiscoveredCoin } from './discovery.ts';\nexport { discoverCoinsFromPublish } from './discovery.ts';\n\nexport type { MetadataSdkShim, OnchainCoinMetadata, CoinMetadataCache } from './metadata.ts';\nexport {\n\tOnchainCoinMetadataShape,\n\tMETADATA_FETCH_TIMEOUT_MS,\n\tMETADATA_RETRY_SCHEDULE,\n\tfetchCoinMetadataOnce,\n\tfetchCoinMetadataMany,\n\tmakeCoinMetadataCache,\n\tisBareCoinType,\n\tvalidateBareCoinType,\n} from './metadata.ts';\n\nexport type { MintInputs, MintResult, MintSigner, MintSdkShim, CachedMint } from './mint.ts';\nexport { performMint, MintedCoinVerifyShape, mintTxError, mintParseError } from './mint.ts';\n\nexport type { CoinError, CoinPhase } from './errors.ts';\nexport { coinError, COIN_ERROR_TAGS } from './errors.ts';\n"],"mappings":"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"}

package/dist/plugins/coin/metadata.d.mts

@@ -0,0 +1,15 @@
+import { CoinError } from "./errors.mjs";
+import { Effect, Schema } from "effect";
+//#region src/plugins/coin/metadata.d.ts
+/** Bare-coin-type heuristic — distilled-doc 13-coin.md Invariant 3.
+ *
+ *  MUST agree with what `getCoinMetadata` accepts as a coin-type
+ *  argument: `0xHEX::module::Witness`. Anything else (symbol, witness
+ *  alone) falls through to the registry path. */
+declare const isBareCoinType: (s: string) => boolean;
+/** Project a coin-type validation failure to `CoinError`. Surfaces
+ *  the nested-generic case at the user-facing factory boundary. */
+declare const validateBareCoinType: (identifier: string) => CoinError | null;
+//#endregion
+export { isBareCoinType, validateBareCoinType };
+//# sourceMappingURL=metadata.d.mts.map

package/dist/plugins/coin/metadata.mjs

@@ -0,0 +1,99 @@
+import { decodeUnknown } from "../../substrate/runtime/runtime-decode.mjs";
+import { SpanAttr } from "../../substrate/runtime/observability/spans.mjs";
+import { makeSpacedRetrySchedule } from "../../substrate/runtime/retry-policy.mjs";
+import { coinError } from "./errors.mjs";
+import { Effect, Schema } from "effect";
+//#region src/plugins/coin/metadata.ts
+/** Per-attempt timeout (5 seconds) — distilled-doc invariant. */
+const METADATA_FETCH_TIMEOUT_MS = 5e3;
+/** Retry schedule — ONE retry at 250ms backoff. Matches the v3
+*  `RETRY_SCHEDULE` (250ms spaced, bounded to one retry). */
+const METADATA_RETRY_SCHEDULE = makeSpacedRetrySchedule(250, 1);
+/** On-chain CoinMetadata projection — narrowed to the columns the
+*  registry needs. The SDK's full shape carries more (description,
+*  raw bytes); we don't.
+*
+*  IMPORTANT (chain-probe schema constraint from the last sweep):
+*  this Schema MUST NOT depend on any services. `Schema.Schema<T>` is
+*  parameterized `<Type, Encoded, R, RD>`; we constrain `R` and `RD`
+*  to `never` via `Schema.Codec<T, unknown, never, never>` at the
+*  consumer boundary, but the schema literal itself uses ONLY
+*  service-free combinators (`Schema.String`, `Schema.Number`,
+*  `Schema.optional`). */
+const OnchainCoinMetadataShape = Schema.Struct({
+	id: Schema.String,
+	decimals: Schema.Number,
+	name: Schema.String,
+	symbol: Schema.String,
+	description: Schema.optional(Schema.String),
+	iconUrl: Schema.optional(Schema.String)
+});
+/** Fetch CoinMetadata for one coin type. Soft-degrades on RPC
+*  failure / timeout: returns `null` after the retry budget is
+*  exhausted, AND logs a warning.
+*
+*  Distilled-doc 13-coin.md Invariant 8: this is intentional. The
+*  publish-discovery pass must not fail the whole supervisor cycle on
+*  a flaky RPC blip. */
+const fetchCoinMetadataOnce = (sdk, fullCoinType) => Effect.gen(function* () {
+	const raw = yield* Effect.tryPromise({
+		try: () => sdk.core.getCoinMetadata({ coinType: fullCoinType }),
+		catch: (cause) => ({
+			_tag: "rpc",
+			cause
+		})
+	}).pipe(Effect.timeoutOrElse({
+		duration: `${METADATA_FETCH_TIMEOUT_MS} millis`,
+		orElse: () => Effect.fail({
+			_tag: "rpc",
+			cause: "timeout"
+		})
+	}), Effect.retry(METADATA_RETRY_SCHEDULE), Effect.catch((err) => {
+		return Effect.logWarning("coin metadata fetch failed; soft-degrading to null").pipe(Effect.annotateLogs({
+			[SpanAttr.coinType]: fullCoinType,
+			[SpanAttr.errorCause]: stringifyCause(err.cause)
+		}), Effect.as(null));
+	}));
+	if (raw === null || raw === void 0) return null;
+	return yield* decodeUnknown(OnchainCoinMetadataShape, raw, {
+		source: "coin metadata RPC response",
+		mkError: (issue) => issue
+	}).pipe(Effect.catch((issue) => Effect.logWarning("coin metadata response had non-conforming shape; degrading to null").pipe(Effect.annotateLogs({
+		[SpanAttr.coinType]: fullCoinType,
+		[SpanAttr.errorCause]: stringifyCause(issue.cause ?? issue)
+	}), Effect.as(null))));
+}).pipe(Effect.withSpan("coin.metadata.fetch", { attributes: { fullCoinType } }));
+/** Bare-coin-type heuristic — distilled-doc 13-coin.md Invariant 3.
+*
+*  MUST agree with what `getCoinMetadata` accepts as a coin-type
+*  argument: `0xHEX::module::Witness`. Anything else (symbol, witness
+*  alone) falls through to the registry path. */
+const isBareCoinType = (s) => {
+	if (!s.startsWith("0x")) return false;
+	if (!s.includes("::")) return false;
+	if (s.split("::").length !== 3) return false;
+	if (s.includes("<") || s.includes(">")) return false;
+	return true;
+};
+/** Project a coin-type validation failure to `CoinError`. Surfaces
+*  the nested-generic case at the user-facing factory boundary. */
+const validateBareCoinType = (identifier) => {
+	if (identifier.includes("<") || identifier.includes(">")) return coinError("nested-generic", {
+		identifier,
+		message: `coin('${identifier}'): nested generics not supported.`
+	});
+	return null;
+};
+const stringifyCause = (cause) => {
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "string") return cause;
+	try {
+		return JSON.stringify(cause);
+	} catch {
+		return String(cause);
+	}
+};
+//#endregion
+export { METADATA_FETCH_TIMEOUT_MS, METADATA_RETRY_SCHEDULE, OnchainCoinMetadataShape, fetchCoinMetadataOnce, isBareCoinType, validateBareCoinType };
+
+//# sourceMappingURL=metadata.mjs.map

package/dist/plugins/coin/metadata.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.mjs","names":[],"sources":["../../../src/plugins/coin/metadata.ts"],"sourcesContent":["// CoinMetadata fetch + soft-degradation.\n//\n// Distilled-doc 13-coin.md Invariant 8: `getCoinMetadata` failures\n// degrade, do not throw. A timeout or RPC error after one retry\n// returns `null` (logged as a warning); the discovery pipeline keeps\n// going. The next supervisor cycle picks the missing record up.\n//\n// Per-attempt timeout 5s, ONE retry at 250ms backoff (matches the v3\n// `RETRY_SCHEDULE` exactly — distilled-doc 13-coin.md §Configuration).\n//\n// In-process per-Layer-invocation cache keyed by fullCoinType. The\n// fullCoinType folds the packageId, so a fresh chain (new genesis)\n// means new packageIds, which means the cache misses naturally —\n// persistence across restart is unnecessary.\n\nimport { Effect, Ref, Schema } from 'effect';\n\nimport { decodeUnknown } from '../../substrate/runtime/runtime-decode.ts';\nimport { SpanAttr } from '../../substrate/runtime/observability/spans.ts';\nimport { makeSpacedRetrySchedule } from '../../substrate/runtime/retry-policy.ts';\nimport { coinError, type CoinError } from './errors.ts';\n\n/** Per-attempt timeout (5 seconds) — distilled-doc invariant. */\nexport const METADATA_FETCH_TIMEOUT_MS = 5_000;\n\n/** Retry schedule — ONE retry at 250ms backoff. Matches the v3\n *  `RETRY_SCHEDULE` (250ms spaced, bounded to one retry). */\nexport const METADATA_RETRY_SCHEDULE = makeSpacedRetrySchedule(250, 1);\n\n/** On-chain CoinMetadata projection — narrowed to the columns the\n *  registry needs. The SDK's full shape carries more (description,\n *  raw bytes); we don't.\n *\n *  IMPORTANT (chain-probe schema constraint from the last sweep):\n *  this Schema MUST NOT depend on any services. `Schema.Schema<T>` is\n *  parameterized `<Type, Encoded, R, RD>`; we constrain `R` and `RD`\n *  to `never` via `Schema.Codec<T, unknown, never, never>` at the\n *  consumer boundary, but the schema literal itself uses ONLY\n *  service-free combinators (`Schema.String`, `Schema.Number`,\n *  `Schema.optional`). */\nexport const OnchainCoinMetadataShape = Schema.Struct({\n\tid: Schema.String,\n\tdecimals: Schema.Number,\n\tname: Schema.String,\n\tsymbol: Schema.String,\n\tdescription: Schema.optional(Schema.String),\n\ticonUrl: Schema.optional(Schema.String),\n});\n\nexport type OnchainCoinMetadata = typeof OnchainCoinMetadataShape.Type;\n\n/** SDK shim — the surface the discovery pass calls. The Sui plugin's\n *  resolved client exposes this via `sdk.core.getCoinMetadata`. Kept\n *  narrow (no `@mysten/sui` type import) so this module stays\n *  layering-neutral; the consumer hands in the resolved client. */\nexport interface MetadataSdkShim {\n\treadonly core: {\n\t\treadonly getCoinMetadata: (args: { readonly coinType: string }) => Promise<unknown>;\n\t};\n}\n\n/** Per-Layer-invocation cache. `null` means \"we tried and the RPC\n *  said the coin had no CoinMetadata\"; `undefined` means \"we haven't\n *  asked yet\". */\nexport interface CoinMetadataCache {\n\treadonly get: (fullCoinType: string) => Effect.Effect<OnchainCoinMetadata | null | undefined>;\n\treadonly put: (fullCoinType: string, value: OnchainCoinMetadata | null) => Effect.Effect<void>;\n}\n\n/** Build an empty cache. */\nexport const makeCoinMetadataCache = (): Effect.Effect<CoinMetadataCache> =>\n\tEffect.gen(function* () {\n\t\tconst ref = yield* Ref.make<Record<string, OnchainCoinMetadata | null>>({});\n\t\treturn {\n\t\t\tget: (fullCoinType) =>\n\t\t\t\tRef.get(ref).pipe(Effect.map((m) => (fullCoinType in m ? m[fullCoinType] : undefined))),\n\t\t\tput: (fullCoinType, value) => Ref.update(ref, (m) => ({ ...m, [fullCoinType]: value })),\n\t\t};\n\t});\n\n/** Fetch CoinMetadata for one coin type. Soft-degrades on RPC\n *  failure / timeout: returns `null` after the retry budget is\n *  exhausted, AND logs a warning.\n *\n *  Distilled-doc 13-coin.md Invariant 8: this is intentional. The\n *  publish-discovery pass must not fail the whole supervisor cycle on\n *  a flaky RPC blip. */\nexport const fetchCoinMetadataOnce = (\n\tsdk: MetadataSdkShim,\n\tfullCoinType: string,\n): Effect.Effect<OnchainCoinMetadata | null> =>\n\tEffect.gen(function* () {\n\t\tconst raw: unknown = yield* Effect.tryPromise({\n\t\t\ttry: () => sdk.core.getCoinMetadata({ coinType: fullCoinType }),\n\t\t\tcatch: (cause): { readonly _tag: 'rpc'; readonly cause: unknown } => ({\n\t\t\t\t_tag: 'rpc',\n\t\t\t\tcause,\n\t\t\t}),\n\t\t}).pipe(\n\t\t\t// Effect v4: `timeoutOrElse` (not `timeoutFail`). The\n\t\t\t// `orElse` branch is the new value (Effect), not just an\n\t\t\t// error constructor — we surface a tagged failure that the\n\t\t\t// downstream `Effect.catch` swallows into `null`.\n\t\t\tEffect.timeoutOrElse({\n\t\t\t\tduration: `${METADATA_FETCH_TIMEOUT_MS} millis`,\n\t\t\t\torElse: () => Effect.fail({ _tag: 'rpc' as const, cause: 'timeout' }),\n\t\t\t}),\n\t\t\tEffect.retry(METADATA_RETRY_SCHEDULE),\n\t\t\tEffect.catch((err): Effect.Effect<unknown> => {\n\t\t\t\treturn Effect.logWarning('coin metadata fetch failed; soft-degrading to null').pipe(\n\t\t\t\t\tEffect.annotateLogs({\n\t\t\t\t\t\t[SpanAttr.coinType]: fullCoinType,\n\t\t\t\t\t\t[SpanAttr.errorCause]: stringifyCause(err.cause),\n\t\t\t\t\t}),\n\t\t\t\t\tEffect.as(null),\n\t\t\t\t);\n\t\t\t}),\n\t\t);\n\t\tif (raw === null || raw === undefined) return null;\n\t\treturn yield* decodeUnknown(OnchainCoinMetadataShape, raw, {\n\t\t\tsource: 'coin metadata RPC response',\n\t\t\tmkError: (issue) => issue,\n\t\t}).pipe(\n\t\t\tEffect.catch((issue) =>\n\t\t\t\tEffect.logWarning(\n\t\t\t\t\t'coin metadata response had non-conforming shape; degrading to null',\n\t\t\t\t).pipe(\n\t\t\t\t\tEffect.annotateLogs({\n\t\t\t\t\t\t[SpanAttr.coinType]: fullCoinType,\n\t\t\t\t\t\t[SpanAttr.errorCause]: stringifyCause(issue.cause ?? issue),\n\t\t\t\t\t}),\n\t\t\t\t\tEffect.as(null as OnchainCoinMetadata | null),\n\t\t\t\t),\n\t\t\t),\n\t\t);\n\t}).pipe(Effect.withSpan('coin.metadata.fetch', { attributes: { fullCoinType } }));\n\n/** Batch-fetch with cache. Each fullCoinType is asked at most once\n *  per Layer-invocation. The fetches run concurrently — distilled-doc\n *  opportunity (\"Coin discovery is naturally batchable\"). */\nexport const fetchCoinMetadataMany = (\n\tsdk: MetadataSdkShim,\n\tfullCoinTypes: ReadonlyArray<string>,\n\tcache: CoinMetadataCache,\n): Effect.Effect<ReadonlyMap<string, OnchainCoinMetadata | null>> =>\n\tEffect.gen(function* () {\n\t\tconst result = new Map<string, OnchainCoinMetadata | null>();\n\t\tyield* Effect.forEach(\n\t\t\tfullCoinTypes,\n\t\t\t(fullCoinType) =>\n\t\t\t\tEffect.gen(function* () {\n\t\t\t\t\tconst cached = yield* cache.get(fullCoinType);\n\t\t\t\t\tif (cached !== undefined) {\n\t\t\t\t\t\tresult.set(fullCoinType, cached);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tconst fetched = yield* fetchCoinMetadataOnce(sdk, fullCoinType);\n\t\t\t\t\tyield* cache.put(fullCoinType, fetched);\n\t\t\t\t\tresult.set(fullCoinType, fetched);\n\t\t\t\t}),\n\t\t\t{ concurrency: 'unbounded' },\n\t\t);\n\t\treturn result;\n\t});\n\n/** Bare-coin-type heuristic — distilled-doc 13-coin.md Invariant 3.\n *\n *  MUST agree with what `getCoinMetadata` accepts as a coin-type\n *  argument: `0xHEX::module::Witness`. Anything else (symbol, witness\n *  alone) falls through to the registry path. */\nexport const isBareCoinType = (s: string): boolean => {\n\tif (!s.startsWith('0x')) return false;\n\tif (!s.includes('::')) return false;\n\tif (s.split('::').length !== 3) return false;\n\t// Distilled-doc invariant 7: nested generics rejected at the\n\t// bare-string boundary too. The check fires before the RPC so\n\t// callers see a typed error rather than a downstream decode\n\t// failure.\n\tif (s.includes('<') || s.includes('>')) return false;\n\treturn true;\n};\n\n/** Project a coin-type validation failure to `CoinError`. Surfaces\n *  the nested-generic case at the user-facing factory boundary. */\nexport const validateBareCoinType = (identifier: string): CoinError | null => {\n\tif (identifier.includes('<') || identifier.includes('>')) {\n\t\treturn coinError('nested-generic', {\n\t\t\tidentifier,\n\t\t\tmessage: `coin('${identifier}'): nested generics not supported.`,\n\t\t});\n\t}\n\treturn null;\n};\n\nconst stringifyCause = (cause: unknown): string => {\n\tif (cause instanceof Error) return cause.message;\n\tif (typeof cause === 'string') return cause;\n\ttry {\n\t\treturn JSON.stringify(cause);\n\t} catch {\n\t\treturn String(cause);\n\t}\n};\n"],"mappings":";;;;;;;AAuBA,MAAa,4BAA4B;;;AAIzC,MAAa,0BAA0B,wBAAwB,KAAK,EAAE;;;;;;;;;;;;AAatE,MAAa,2BAA2B,OAAO,OAAO;CACrD,IAAI,OAAO;CACX,UAAU,OAAO;CACjB,MAAM,OAAO;CACb,QAAQ,OAAO;CACf,aAAa,OAAO,SAAS,OAAO,OAAO;CAC3C,SAAS,OAAO,SAAS,OAAO,OAAO;CACvC,CAAC;;;;;;;;AAwCF,MAAa,yBACZ,KACA,iBAEA,OAAO,IAAI,aAAa;CACvB,MAAM,MAAe,OAAO,OAAO,WAAW;EAC7C,WAAW,IAAI,KAAK,gBAAgB,EAAE,UAAU,cAAc,CAAC;EAC/D,QAAQ,WAA8D;GACrE,MAAM;GACN;GACA;EACD,CAAC,CAAC,KAKF,OAAO,cAAc;EACpB,UAAU,GAAG,0BAA0B;EACvC,cAAc,OAAO,KAAK;GAAE,MAAM;GAAgB,OAAO;GAAW,CAAC;EACrE,CAAC,EACF,OAAO,MAAM,wBAAwB,EACrC,OAAO,OAAO,QAAgC;AAC7C,SAAO,OAAO,WAAW,qDAAqD,CAAC,KAC9E,OAAO,aAAa;IAClB,SAAS,WAAW;IACpB,SAAS,aAAa,eAAe,IAAI,MAAM;GAChD,CAAC,EACF,OAAO,GAAG,KAAK,CACf;GACA,CACF;AACD,KAAI,QAAQ,QAAQ,QAAQ,KAAA,EAAW,QAAO;AAC9C,QAAO,OAAO,cAAc,0BAA0B,KAAK;EAC1D,QAAQ;EACR,UAAU,UAAU;EACpB,CAAC,CAAC,KACF,OAAO,OAAO,UACb,OAAO,WACN,qEACA,CAAC,KACD,OAAO,aAAa;GAClB,SAAS,WAAW;GACpB,SAAS,aAAa,eAAe,MAAM,SAAS,MAAM;EAC3D,CAAC,EACF,OAAO,GAAG,KAAmC,CAC7C,CACD,CACD;EACA,CAAC,KAAK,OAAO,SAAS,uBAAuB,EAAE,YAAY,EAAE,cAAc,EAAE,CAAC,CAAC;;;;;;AAmClF,MAAa,kBAAkB,MAAuB;AACrD,KAAI,CAAC,EAAE,WAAW,KAAK,CAAE,QAAO;AAChC,KAAI,CAAC,EAAE,SAAS,KAAK,CAAE,QAAO;AAC9B,KAAI,EAAE,MAAM,KAAK,CAAC,WAAW,EAAG,QAAO;AAKvC,KAAI,EAAE,SAAS,IAAI,IAAI,EAAE,SAAS,IAAI,CAAE,QAAO;AAC/C,QAAO;;;;AAKR,MAAa,wBAAwB,eAAyC;AAC7E,KAAI,WAAW,SAAS,IAAI,IAAI,WAAW,SAAS,IAAI,CACvD,QAAO,UAAU,kBAAkB;EAClC;EACA,SAAS,SAAS,WAAW;EAC7B,CAAC;AAEH,QAAO;;AAGR,MAAM,kBAAkB,UAA2B;AAClD,KAAI,iBAAiB,MAAO,QAAO,MAAM;AACzC,KAAI,OAAO,UAAU,SAAU,QAAO;AACtC,KAAI;AACH,SAAO,KAAK,UAAU,MAAM;SACrB;AACP,SAAO,OAAO,MAAM"}

package/dist/plugins/coin/mint.d.mts

@@ -0,0 +1,34 @@
+import { Effect, Schema, Scope } from "effect";
+
+//#region src/plugins/coin/mint.d.ts
+/** Sign+execute surface narrowed from `AccountValue.signAndExecute`.
+ *  We don't import `AccountValue` directly to avoid a layering cycle —
+ *  the Account plugin imports nothing from coin, so coin re-publishes
+ *  the structural shape. */
+interface MintTransactionSigner {
+  readonly signAndExecute: (tx: Uint8Array) => Effect.Effect<{
+    readonly digest: string;
+    readonly objectChanges: ReadonlyArray<unknown>;
+  }, {
+    readonly _tag: 'AccountSignError';
+    readonly message: string;
+  }>;
+}
+interface MintSigner extends MintTransactionSigner {
+  readonly address: string;
+  readonly withTransactionSigner: <A, E, R>(body: (signer: MintTransactionSigner) => Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+interface MintResult {
+  /** Tx digest of the producing mint. `null` on the verify-hit path:
+   *  the artifact publisher's cache-hit verify returns the decoded probe shape
+   *  (which doesn't carry the digest); callers that need the digest
+   *  on cache hit consult the artifact publisher cache directly. */
+  readonly digest: string | null;
+  readonly mintedCoinId: string;
+  readonly recipient: string;
+  readonly amount: bigint;
+  readonly fullCoinType: string;
+}
+//#endregion
+export { MintResult, MintSigner };
+//# sourceMappingURL=mint.d.mts.map