rdx-cli 0.1.0

package/dist/cli-n0bR-cOj.js

@@ -0,0 +1,2089 @@
+import { ConfigProvider, Console, Data, Effect, Layer, Option, Schema } from "effect";
+import { GatewayApiClient, GetFungibleBalance, GetNonFungibleBalanceService } from "@radix-effects/gateway";
+import { Convert, PublicKey, RadixEngineToolkit, Signature, SignatureWithPublicKey, TransactionV2Builder } from "@steleaio/radix-engine-toolkit";
+import { basename, dirname, join, parse, resolve } from "node:path";
+import { FileSystem } from "@effect/platform";
+import { NodeFileSystem } from "@effect/platform-node";
+import { ed25519 } from "@noble/curves/ed25519";
+import { Args, Command, Options } from "@effect/cli";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+
+//#region src/json.ts
+const JsonValueSchema = Schema.Union(Schema.Null, Schema.Boolean, Schema.JsonNumber, Schema.String, Schema.Array(Schema.suspend(() => JsonValueSchema)), Schema.Record({
+	key: Schema.String,
+	value: Schema.suspend(() => JsonValueSchema)
+}));
+const JsonStringSchema = Schema.parseJson(JsonValueSchema, { space: 2 });
+const isBigNumberLike = (value) => typeof value === "object" && value !== null && "isBigNumber" in value && typeof value.toString === "function";
+const toJsonValue = (value) => {
+	if (value === void 0) return null;
+	if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "bigint" || isBigNumberLike(value)) return value.toString();
+	if (Array.isArray(value)) return value.map(toJsonValue);
+	if (typeof value === "object") {
+		if (typeof value.toJSON === "function") return toJsonValue(value.toJSON());
+		return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, toJsonValue(entry)]));
+	}
+	return String(value);
+};
+const renderJson = (value) => Schema.encodeUnknownSync(JsonStringSchema)(toJsonValue(value));
+
+//#endregion
+//#region src/schemas.ts
+const PLACEHOLDER_PUBLIC_KEY_HEX = "<replace-with-ed25519-public-key-hex>";
+const PLACEHOLDER_SIGNATURE_HEX = "<replace-with-ed25519-signature-hex>";
+const NetworkSchema = Schema.Literal("mainnet", "stokenet").pipe(Schema.brand("Network"));
+const ArtifactScopeSchema = Schema.Literal("local", "global").pipe(Schema.brand("ArtifactScope"));
+const OutputFormatSchema = Schema.Literal("json", "text").pipe(Schema.brand("OutputFormat"));
+const HexStringSchema = Schema.String.pipe(Schema.pattern(/^[0-9a-fA-F]+$/));
+const Ed25519PublicKeyHexSchema = HexStringSchema.pipe(Schema.length(64));
+const Ed25519SignatureHexSchema = HexStringSchema.pipe(Schema.length(128));
+const SubintentIdSchema = Schema.String.pipe(Schema.pattern(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/));
+const PublicKeySchema = Schema.Struct({
+	curve: Schema.Literal("Ed25519"),
+	hex: Ed25519PublicKeyHexSchema
+});
+const PublicKeyOrPlaceholderSchema = Schema.Struct({
+	curve: Schema.Literal("Ed25519"),
+	hex: Schema.Union(Ed25519PublicKeyHexSchema, Schema.Literal(PLACEHOLDER_PUBLIC_KEY_HEX))
+});
+const SignatureValueSchema = Schema.Struct({
+	curve: Schema.Literal("Ed25519"),
+	hex: Ed25519SignatureHexSchema
+});
+const SignatureValueOrPlaceholderSchema = Schema.Struct({
+	curve: Schema.Literal("Ed25519"),
+	hex: Schema.Union(Ed25519SignatureHexSchema, Schema.Literal(PLACEHOLDER_SIGNATURE_HEX))
+});
+const SigningScopeSchema = Schema.Union(Schema.Struct({ kind: Schema.Literal("rootIntent") }), Schema.Struct({
+	kind: Schema.Literal("subintent"),
+	subintentId: SubintentIdSchema
+}), Schema.Struct({ kind: Schema.Literal("notarySignatory") }), Schema.Struct({ kind: Schema.Literal("notary") }));
+const HashSchema = Schema.Struct({
+	id: Schema.NullOr(Schema.String),
+	hex: HexStringSchema
+});
+const SigningRequestSchema = Schema.Struct({
+	type: Schema.Literal("signingRequest"),
+	version: Schema.Literal(1),
+	transactionId: Schema.NonEmptyString,
+	scope: SigningScopeSchema,
+	account: Schema.NullOr(Schema.NonEmptyString),
+	hash: HashSchema,
+	signingRequestPath: Schema.optional(Schema.String)
+});
+const SignatureTemplateSchema = Schema.Struct({
+	type: Schema.Literal("signatureTemplate"),
+	version: Schema.Literal(1),
+	transactionId: Schema.NonEmptyString,
+	scope: SigningScopeSchema,
+	account: Schema.NullOr(Schema.NonEmptyString),
+	hash: HashSchema,
+	signingRequestPath: Schema.optional(Schema.String),
+	publicKey: PublicKeyOrPlaceholderSchema,
+	signature: SignatureValueOrPlaceholderSchema
+});
+const SignatureEntrySchema = Schema.Struct({
+	scope: SigningScopeSchema,
+	account: Schema.NullOr(Schema.NonEmptyString),
+	hash: HashSchema,
+	signingRequestPath: Schema.optional(Schema.String),
+	publicKey: PublicKeySchema.pipe(Schema.filter((value) => value.hex !== PLACEHOLDER_PUBLIC_KEY_HEX, { message: () => "Replace the public key placeholder before importing signatures" })),
+	signature: SignatureValueSchema.pipe(Schema.filter((value) => value.hex !== PLACEHOLDER_SIGNATURE_HEX, { message: () => "Replace the signature placeholder before importing signatures" }))
+});
+const SignatureFileSchema = Schema.Struct({
+	type: Schema.Literal("signatureFile"),
+	version: Schema.Literal(1),
+	transactionId: Schema.NonEmptyString,
+	signatures: Schema.Array(SignatureEntrySchema)
+});
+const BatchSignatureFileSchema = Schema.Struct({
+	type: Schema.Literal("batchSignatureFile"),
+	version: Schema.Literal(1),
+	signatures: Schema.NonEmptyArray(SignatureFileSchema)
+});
+const SubintentsFileSchema = Schema.Struct({
+	type: Schema.Literal("subintents"),
+	version: Schema.Literal(1),
+	subintents: Schema.Record({
+		key: Schema.String,
+		value: Schema.Struct({ manifest: Schema.NonEmptyString })
+	}).pipe(Schema.filter((subintents) => Object.keys(subintents).every((key) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(key)), { message: () => "Subintent IDs must be conservative identifiers" }))
+});
+const NotaryFileSchema = Schema.Struct({
+	type: Schema.Literal("notary"),
+	version: Schema.Literal(1),
+	publicKey: PublicKeySchema,
+	notaryIsSignatory: Schema.optional(Schema.Boolean)
+});
+const ArtifactStatusSchema = Schema.Union(Schema.Literal("prepared"), Schema.Literal("notarized"), Schema.Literal("submitted"));
+const AuthorizationAnalysisSchema = Schema.Struct({
+	rootIntent: Schema.Array(Schema.String),
+	subintents: Schema.Record({
+		key: Schema.String,
+		value: Schema.Array(Schema.String)
+	})
+});
+const PreparedTransactionSchema = Schema.Struct({
+	type: Schema.Literal("preparedTransaction"),
+	version: Schema.Literal(1),
+	transactionId: Schema.NonEmptyString,
+	network: NetworkSchema,
+	intentHash: HashSchema,
+	manifestSourceFile: Schema.String,
+	transactionIntentPath: Schema.String,
+	staticAnalysisPath: Schema.String,
+	signingRequests: Schema.Array(Schema.String),
+	signatureTemplates: Schema.Array(Schema.String),
+	subintentOrder: Schema.Array(Schema.String),
+	authorizationAnalysis: AuthorizationAnalysisSchema,
+	notaryPublicKey: Schema.optional(PublicKeySchema),
+	notaryIsSignatory: Schema.optional(Schema.Boolean)
+});
+const NetworkTransactionStatusSchema = Schema.Struct({
+	transactionId: Schema.NonEmptyString,
+	status: Schema.String,
+	statusDescription: Schema.String,
+	errorMessage: Schema.NullOr(Schema.String),
+	checkedAt: Schema.String
+});
+const SubmitResultSchema = Schema.Struct({
+	type: Schema.Literal("submitResult"),
+	version: Schema.Literal(1),
+	transactionId: Schema.NonEmptyString,
+	networkStatus: NetworkTransactionStatusSchema,
+	attempts: Schema.Array(Schema.Struct({
+		checkedAt: Schema.String,
+		status: Schema.String,
+		statusDescription: Schema.String,
+		errorMessage: Schema.NullOr(Schema.String)
+	}))
+});
+const AccountFungiblesResultSchema = Schema.Struct({
+	type: Schema.Literal("commandResult"),
+	command: Schema.Literal("account fungibles"),
+	result: Schema.Unknown
+});
+const AccountNftsResultSchema = Schema.Struct({
+	type: Schema.Literal("commandResult"),
+	command: Schema.Literal("account nfts"),
+	result: Schema.Unknown
+});
+const AccountShowResultSchema = Schema.Struct({
+	type: Schema.Literal("commandResult"),
+	command: Schema.Literal("account show"),
+	result: Schema.Unknown
+});
+const TransactionHistoryResultSchema = Schema.Struct({
+	type: Schema.Literal("commandResult"),
+	command: Schema.Literal("tx history"),
+	result: Schema.Unknown
+});
+const VirtualAccountDerivationSchema = Schema.Struct({
+	network: NetworkSchema,
+	derivation: Schema.Literal("virtualAccount"),
+	publicKey: PublicKeySchema,
+	accountAddress: Schema.String
+});
+
+//#endregion
+//#region src/accountReads.ts
+var AccountReadError = class extends Data.TaggedError("AccountReadError") {};
+var InvalidPublicKeyError = class extends Data.TaggedError("InvalidPublicKeyError") {};
+const networkId$1 = (network) => network === "stokenet" ? 2 : 1;
+const gatewayConfigLayer = (config) => Layer.setConfigProvider(ConfigProvider.fromJson({
+	NETWORK_ID: networkId$1(config.network),
+	...config.gatewayBaseUrl ? { GATEWAY_URL: config.gatewayBaseUrl } : {}
+}));
+const gatewayApiClientLayer = (config) => GatewayApiClient.Default.pipe(Layer.provide(gatewayConfigLayer(config)));
+const getAccountFungibles = (input) => input.readFungibles(input.accountAddress).pipe(Effect.map((result) => ({
+	type: "commandResult",
+	command: "account fungibles",
+	result: toJsonValue(result)
+})));
+const getAccountNfts = (input) => input.readNfts(input.accountAddress).pipe(Effect.map((result) => ({
+	type: "commandResult",
+	command: "account nfts",
+	result: toJsonValue(result)
+})));
+const gatewayAccountFungibles = (input) => {
+	const gatewayLayer = gatewayApiClientLayer(input.config);
+	const accountFungiblesLayer = Layer.merge(gatewayLayer, GetFungibleBalance.Default.pipe(Layer.provide(gatewayLayer)));
+	return Effect.gen(function* () {
+		const status = yield* (yield* GatewayApiClient).status.getCurrent();
+		return yield* (yield* GetFungibleBalance)({
+			addresses: [input.accountAddress],
+			at_ledger_state: { state_version: status.ledger_state.state_version },
+			options: { explicit_metadata: ["name", "symbol"] }
+		});
+	}).pipe(Effect.provide(accountFungiblesLayer), Effect.mapError((reason) => new AccountReadError({
+		accountAddress: input.accountAddress,
+		reason
+	})));
+};
+const gatewayAccountNfts = (input) => {
+	const gatewayLayer = gatewayApiClientLayer(input.config);
+	const accountNftsLayer = Layer.merge(gatewayLayer, GetNonFungibleBalanceService.Default.pipe(Layer.provide(gatewayLayer)));
+	return Effect.gen(function* () {
+		const status = yield* (yield* GatewayApiClient).status.getCurrent();
+		return yield* (yield* GetNonFungibleBalanceService)({
+			addresses: [input.accountAddress],
+			at_ledger_state: { state_version: status.ledger_state.state_version }
+		});
+	}).pipe(Effect.provide(accountNftsLayer), Effect.mapError((reason) => new AccountReadError({
+		accountAddress: input.accountAddress,
+		reason
+	})));
+};
+const gatewayAccountDetails = (input) => Effect.gen(function* () {
+	return yield* (yield* GatewayApiClient).state.innerClient.stateEntityDetails({ stateEntityDetailsRequest: {
+		addresses: [input.accountAddress],
+		aggregation_level: "Vault",
+		opt_ins: {
+			explicit_metadata: ["name", "description"],
+			ancestor_identities: true,
+			component_royalty_config: true,
+			package_royalty_vault_balance: true
+		}
+	} });
+}).pipe(Effect.provide(gatewayApiClientLayer(input.config)), Effect.mapError((reason) => new AccountReadError({
+	accountAddress: input.accountAddress,
+	reason
+})));
+const gatewayAccountHistory = (input) => Effect.gen(function* () {
+	return yield* (yield* GatewayApiClient).stream.innerClient.streamTransactions({ streamTransactionsRequest: {
+		limit_per_page: input.limit,
+		affected_global_entities_filter: [input.accountAddress]
+	} });
+}).pipe(Effect.provide(gatewayApiClientLayer(input.config)), Effect.mapError((reason) => new AccountReadError({
+	accountAddress: input.accountAddress,
+	reason
+})));
+const getAccountDetails = (input) => input.readDetails(input.accountAddress).pipe(Effect.map((result) => ({
+	type: "commandResult",
+	command: "account show",
+	result: toJsonValue(result)
+})));
+const getAccountTransactionHistory = (input) => input.readHistory(input.accountAddress, input.limit).pipe(Effect.map((result) => ({
+	type: "commandResult",
+	command: "tx history",
+	result: toJsonValue(result)
+})));
+const deriveVirtualAccountAddress = (input) => Effect.gen(function* () {
+	const publicKey = yield* Schema.decodeUnknown(PublicKeySchema)({
+		curve: "Ed25519",
+		hex: input.publicKeyHex
+	}).pipe(Effect.mapError(() => new InvalidPublicKeyError({
+		code: "INVALID_PUBLIC_KEY",
+		publicKeyHex: input.publicKeyHex
+	})));
+	const accountAddress = yield* Effect.tryPromise(async () => RadixEngineToolkit.Derive.virtualAccountAddressFromPublicKey(new PublicKey.Ed25519(publicKey.hex), networkId$1(input.network)));
+	return {
+		type: "commandResult",
+		command: "account derive",
+		network: input.network,
+		derivation: "virtualAccount",
+		publicKey,
+		accountAddress
+	};
+});
+var AccountReadService = class extends Effect.Service()("AccountReadService", { sync: () => ({
+	getAccountDetails,
+	getAccountFungibles,
+	getAccountNfts,
+	getAccountTransactionHistory,
+	deriveVirtualAccountAddress,
+	gatewayAccountDetails,
+	gatewayAccountFungibles,
+	gatewayAccountHistory,
+	gatewayAccountNfts
+}) }) {};
+
+//#endregion
+//#region src/platformIo.ts
+const withNodeFileSystem = (effect) => effect.pipe(Effect.provide(NodeFileSystem.layer));
+const fileExists = (path) => withNodeFileSystem(Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).exists(path);
+}).pipe(Effect.catchAll(() => Effect.succeed(false))));
+const makeDirectory = (path, options, mapError) => withNodeFileSystem(Effect.gen(function* () {
+	yield* (yield* FileSystem.FileSystem).makeDirectory(path, options);
+}).pipe(Effect.mapError(mapError)));
+const readDirectory = (path, mapError) => withNodeFileSystem(Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).readDirectory(path);
+}).pipe(Effect.mapError(mapError)));
+const isDirectory = (path, mapError) => withNodeFileSystem(Effect.gen(function* () {
+	return (yield* (yield* FileSystem.FileSystem).stat(path)).type === "Directory";
+}).pipe(Effect.mapError(mapError)));
+const readFileString = (path, mapError) => withNodeFileSystem(Effect.gen(function* () {
+	return yield* (yield* FileSystem.FileSystem).readFileString(path, "utf8");
+}).pipe(Effect.mapError(mapError)));
+const writeFileString = (path, data, mapError) => withNodeFileSystem(Effect.gen(function* () {
+	yield* (yield* FileSystem.FileSystem).writeFileString(path, data);
+}).pipe(Effect.mapError(mapError)));
+const readJsonFile = (path, mapError) => readFileString(path, mapError).pipe(Effect.flatMap((content) => Schema.decodeUnknown(Schema.parseJson())(content).pipe(Effect.mapError(mapError))));
+const writeJsonFile = (path, value, mapError) => writeFileString(path, `${renderJson(value)}\n`, mapError);
+
+//#endregion
+//#region src/artifacts.ts
+var ArtifactStoreError = class extends Data.TaggedError("ArtifactStoreError") {};
+const scopeSortKey = (scope) => {
+	switch (scope.kind) {
+		case "rootIntent": return "0:root";
+		case "subintent": return `1:${scope.subintentId}`;
+		case "notarySignatory": return "2:notarySignatory";
+		case "notary": return "3:notary";
+	}
+};
+const signatureIdentity = (entry) => [
+	scopeSortKey(entry.scope),
+	entry.account ?? "",
+	entry.hash.id ?? "",
+	entry.hash.hex,
+	entry.publicKey.curve,
+	entry.publicKey.hex
+].join("|");
+const sortSignature = (left, right) => signatureIdentity(left).localeCompare(signatureIdentity(right));
+const normalizeSignatures = (input) => {
+	const byIdentity = /* @__PURE__ */ new Map();
+	const warnings = [];
+	let acceptedCount = 0;
+	for (const signature of [...input.existing, ...input.imported]) {
+		const identity = signatureIdentity(signature);
+		const existing = byIdentity.get(identity);
+		if (!existing) {
+			byIdentity.set(identity, signature);
+			if (input.imported.includes(signature)) acceptedCount += 1;
+			continue;
+		}
+		if (existing.signature.hex !== signature.signature.hex) warnings.push(`Ignored differing duplicate signature for ${identity}`);
+	}
+	return {
+		signatureFile: {
+			type: "signatureFile",
+			version: 1,
+			transactionId: input.transactionId,
+			signatures: [...byIdentity.values()].sort(sortSignature)
+		},
+		acceptedCount,
+		warnings
+	};
+};
+const createTransactionArtifactDirectory = (input) => Effect.gen(function* () {
+	yield* makeDirectory(input.artifactRoot, { recursive: true }, (reason) => new ArtifactStoreError({
+		path: input.artifactRoot,
+		reason
+	}));
+	const artifactPath = join(input.artifactRoot, input.transactionId);
+	yield* makeDirectory(artifactPath, void 0, (reason) => new ArtifactStoreError({
+		path: artifactPath,
+		reason
+	}));
+	return artifactPath;
+});
+const writeCanonicalSignatures = (input) => {
+	const result = normalizeSignatures(input);
+	const path = join(input.artifactPath, "signatures.json");
+	return writeJsonFile(path, result.signatureFile, (reason) => new ArtifactStoreError({
+		path,
+		reason
+	})).pipe(Effect.as(path));
+};
+const writeSubmitResult = (input) => {
+	const path = join(input.artifactPath, "submitResult.json");
+	return writeJsonFile(path, input.submitResult, (reason) => new ArtifactStoreError({
+		path,
+		reason
+	})).pipe(Effect.as(path));
+};
+const readPreparedTransaction = (path) => readJsonFile(path, (reason) => new ArtifactStoreError({
+	path,
+	reason
+})).pipe(Effect.flatMap((value) => Schema.decodeUnknown(PreparedTransactionSchema)(value).pipe(Effect.mapError((reason) => new ArtifactStoreError({
+	path,
+	reason
+})))));
+const getArtifactStatus = (artifactPath) => Effect.gen(function* () {
+	if (yield* fileExists(join(artifactPath, "submitResult.json"))) return "submitted";
+	if (yield* fileExists(join(artifactPath, "notarizedTransaction.hex"))) return "notarized";
+	return "prepared";
+});
+const readArtifactSummary = (artifactPath) => Effect.gen(function* () {
+	const prepared = yield* readPreparedTransaction(join(artifactPath, "prepared.json"));
+	const status = yield* getArtifactStatus(artifactPath);
+	return {
+		transactionId: prepared.transactionId,
+		path: artifactPath,
+		network: prepared.network,
+		status,
+		intentHash: prepared.intentHash.id ?? prepared.intentHash.hex,
+		manifestSourceFile: prepared.manifestSourceFile
+	};
+});
+const findTransactionArtifact = (input) => Effect.gen(function* () {
+	const artifactPath = join(input.artifactRoot, input.transactionId);
+	if (!(yield* fileExists(join(artifactPath, "prepared.json")))) return yield* new ArtifactStoreError({
+		path: artifactPath,
+		reason: "Transaction artifact not found"
+	});
+	return artifactPath;
+});
+const findTransactionArtifactOption = (input) => Effect.gen(function* () {
+	const artifactPath = join(input.artifactRoot, input.transactionId);
+	return (yield* fileExists(join(artifactPath, "prepared.json"))) ? artifactPath : void 0;
+});
+const listTransactionArtifacts = (input) => Effect.gen(function* () {
+	if (!(yield* fileExists(input.artifactRoot))) return [];
+	const entries = yield* readDirectory(input.artifactRoot, (reason) => new ArtifactStoreError({
+		path: input.artifactRoot,
+		reason
+	}));
+	const regex = input.regex ? new RegExp(input.regex) : void 0;
+	const pattern = input.pattern?.toLowerCase();
+	const summaries = [];
+	for (const entry of entries) {
+		const artifactPath = join(input.artifactRoot, entry);
+		if (!(yield* isDirectory(artifactPath, (reason) => new ArtifactStoreError({
+			path: artifactPath,
+			reason
+		})))) continue;
+		const summary = yield* readArtifactSummary(artifactPath);
+		const searchable = [
+			summary.transactionId,
+			summary.intentHash,
+			summary.manifestSourceFile
+		];
+		if (input.network && summary.network !== input.network) continue;
+		if (input.status && summary.status !== input.status) continue;
+		if (pattern && !searchable.some((value) => value.toLowerCase().includes(pattern))) continue;
+		if (regex && !searchable.some((value) => regex.test(value))) continue;
+		summaries.push(summary);
+	}
+	return summaries.sort((left, right) => left.transactionId.localeCompare(right.transactionId));
+});
+var ArtifactStore = class extends Effect.Service()("ArtifactStore", { sync: () => ({
+	createTransactionArtifactDirectory,
+	findTransactionArtifactOption,
+	findTransactionArtifact,
+	listTransactionArtifacts,
+	writeSubmitResult,
+	writeCanonicalSignatures
+}) }) {};
+
+//#endregion
+//#region src/signatureImport.ts
+var SignatureImportError = class extends Data.TaggedError("SignatureImportError") {};
+const scopeKey = (scope) => scope.kind === "subintent" ? `subintent:${scope.subintentId}` : scope.kind;
+const requestIdentity = (input) => [
+	input.transactionId,
+	scopeKey(input.scope),
+	input.account ?? "",
+	input.hash.id ?? "",
+	input.hash.hex
+].join("|");
+const templateToSignatureEntry = (template) => ({
+	scope: template.scope,
+	account: template.account,
+	hash: template.hash,
+	signingRequestPath: template.signingRequestPath,
+	publicKey: template.publicKey,
+	signature: template.signature
+});
+const decodeImportableFile = (file) => Effect.gen(function* () {
+	if (typeof file !== "object" || file === null || !("type" in file)) return yield* new SignatureImportError({
+		code: "INVALID_SIGNATURE_FILE",
+		reason: "Workflow file type is missing"
+	});
+	if (file.type === "signatureTemplate") {
+		const template = yield* Schema.decodeUnknown(SignatureTemplateSchema)(file).pipe(Effect.mapError((reason) => new SignatureImportError({
+			code: "INVALID_SIGNATURE_FILE",
+			reason
+		})));
+		return {
+			transactionId: template.transactionId,
+			signatures: [templateToSignatureEntry(template)]
+		};
+	}
+	if (file.type === "batchSignatureFile") return {
+		transactionId: null,
+		signatures: (yield* Schema.decodeUnknown(BatchSignatureFileSchema)(file).pipe(Effect.mapError((reason) => new SignatureImportError({
+			code: "INVALID_SIGNATURE_FILE",
+			reason
+		})))).signatures.flatMap((item) => item.signatures)
+	};
+	return yield* Schema.decodeUnknown(SignatureFileSchema)(file).pipe(Effect.mapError((reason) => new SignatureImportError({
+		code: "INVALID_SIGNATURE_FILE",
+		reason
+	})));
+});
+const rejectPlaceholders = (entry) => {
+	if (entry.publicKey.hex === PLACEHOLDER_PUBLIC_KEY_HEX) return new SignatureImportError({
+		code: "PLACEHOLDER_VALUE",
+		reason: `publicKey.hex is still a placeholder for ${scopeKey(entry.scope)}${entry.signingRequestPath ? ` at ${entry.signingRequestPath}` : ""}`
+	});
+	if (entry.signature.hex === PLACEHOLDER_SIGNATURE_HEX) return new SignatureImportError({
+		code: "PLACEHOLDER_VALUE",
+		reason: `signature.hex is still a placeholder for ${scopeKey(entry.scope)}${entry.signingRequestPath ? ` at ${entry.signingRequestPath}` : ""}`
+	});
+};
+const verifySignature = (entry) => {
+	if (!ed25519.verify(Buffer.from(entry.signature.hex, "hex"), Buffer.from(entry.hash.hex, "hex"), Buffer.from(entry.publicKey.hex, "hex"))) return new SignatureImportError({
+		code: "INVALID_SIGNATURE",
+		reason: entry
+	});
+};
+const importSignatures = (input) => Effect.gen(function* () {
+	const knownRequests = new Set(input.generatedRequests.map((request) => requestIdentity({
+		transactionId: request.transactionId,
+		scope: request.scope,
+		account: request.account,
+		hash: request.hash
+	})));
+	const imported = [];
+	for (const file of input.files) {
+		const decoded = yield* decodeImportableFile(file);
+		if (decoded.transactionId && decoded.transactionId !== input.transactionId) return yield* new SignatureImportError({
+			code: "UNKNOWN_SIGNING_REQUEST",
+			reason: decoded.transactionId
+		});
+		for (const signature of decoded.signatures) {
+			const placeholderError = rejectPlaceholders(signature);
+			if (placeholderError) return yield* placeholderError;
+			const identity = requestIdentity({
+				transactionId: input.transactionId,
+				scope: signature.scope,
+				account: signature.account,
+				hash: signature.hash
+			});
+			if (!knownRequests.has(identity)) return yield* new SignatureImportError({
+				code: "UNKNOWN_SIGNING_REQUEST",
+				reason: identity
+			});
+			const verificationError = verifySignature(signature);
+			if (verificationError) return yield* verificationError;
+			imported.push(signature);
+		}
+	}
+	return normalizeSignatures({
+		transactionId: input.transactionId,
+		existing: input.existing,
+		imported
+	});
+});
+var SignatureImporter = class extends Effect.Service()("SignatureImporter", { sync: () => ({ importSignatures }) }) {};
+
+//#endregion
+//#region src/addSignatures.ts
+const readJson$2 = (path) => readJsonFile(path, (reason) => reason);
+const readPrepared = (artifactPath) => readJson$2(join(artifactPath, "prepared.json")).pipe(Effect.flatMap(Schema.decodeUnknown(PreparedTransactionSchema)));
+const readSigningRequest$1 = (artifactPath, requestPath) => readJson$2(join(artifactPath, requestPath)).pipe(Effect.flatMap(Schema.decodeUnknown(SigningRequestSchema)));
+const readExistingSignatures = (artifactPath) => readJson$2(join(artifactPath, "signatures.json")).pipe(Effect.flatMap(Schema.decodeUnknown(SignatureFileSchema)), Effect.map((file) => file.signatures), Effect.catchAll(() => Effect.succeed([])));
+const requestComplete$2 = (request, signatures) => signatures.some((signature) => signature.scope.kind === request.scope.kind && (signature.scope.kind !== "subintent" || request.scope.kind === "subintent" && signature.scope.subintentId === request.scope.subintentId) && signature.account === request.account && signature.hash.hex === request.hash.hex && signature.hash.id === request.hash.id);
+const addSignaturesToArtifact = (input) => Effect.gen(function* () {
+	const artifactPath = yield* findTransactionArtifact(input);
+	const prepared = yield* readPrepared(artifactPath);
+	const generatedRequests = yield* Effect.all(prepared.signingRequests.map((requestPath) => readSigningRequest$1(artifactPath, requestPath)));
+	const existing = yield* readExistingSignatures(artifactPath);
+	const files = yield* Effect.all(input.signatureFilePaths.map((signatureFilePath) => readJson$2(signatureFilePath)));
+	const importResult = yield* importSignatures({
+		transactionId: input.transactionId,
+		generatedRequests,
+		existing,
+		files
+	});
+	const signaturesPath = yield* writeCanonicalSignatures({
+		artifactPath,
+		transactionId: input.transactionId,
+		existing: [],
+		imported: importResult.signatureFile.signatures
+	});
+	const complete = generatedRequests.every((request) => requestComplete$2(request, importResult.signatureFile.signatures));
+	return {
+		...importResult,
+		signaturesPath,
+		complete
+	};
+});
+var AddSignaturesWorkflow = class extends Effect.Service()("AddSignaturesWorkflow", { sync: () => ({ addSignaturesToArtifact }) }) {};
+
+//#endregion
+//#region src/config.ts
+const RdxConfigNotarySchema = Schema.Struct({
+	publicKey: PublicKeySchema,
+	notaryIsSignatory: Schema.optional(Schema.Boolean)
+});
+const RdxConfigFileSchema = Schema.Struct({
+	network: Schema.optional(NetworkSchema),
+	gatewayBaseUrl: Schema.optional(Schema.String),
+	artifactScope: Schema.optional(ArtifactScopeSchema),
+	artifactDirectory: Schema.optional(Schema.String),
+	notary: Schema.optional(RdxConfigNotarySchema)
+});
+const ResolvedRdxConfigSchema = Schema.Struct({
+	network: NetworkSchema,
+	gatewayBaseUrl: Schema.optional(Schema.String),
+	artifactScope: ArtifactScopeSchema,
+	artifactDirectory: Schema.optional(Schema.String),
+	artifactRoot: Schema.String,
+	notary: Schema.optional(RdxConfigNotarySchema),
+	projectConfigPath: Schema.optional(Schema.String),
+	globalConfigPath: Schema.optional(Schema.String)
+});
+var ConfigResolutionError = class extends Data.TaggedError("ConfigResolutionError") {};
+const defaultConfig = {
+	network: NetworkSchema.make("mainnet"),
+	artifactScope: ArtifactScopeSchema.make("local")
+};
+const findNearestProjectConfig = (cwd) => Effect.gen(function* () {
+	let directory = resolve(cwd);
+	const root = parse(directory).root;
+	while (true) {
+		const candidate = join(directory, ".rdxconfig.json");
+		if (yield* fileExists(candidate)) return candidate;
+		if (directory === root) return;
+		directory = dirname(directory);
+	}
+});
+const readConfigFile = (path) => readJsonFile(path, (reason) => new ConfigResolutionError({
+	path,
+	reason
+})).pipe(Effect.flatMap((value) => Schema.decodeUnknown(RdxConfigFileSchema)(value).pipe(Effect.mapError((reason) => new ConfigResolutionError({
+	path,
+	reason
+})))));
+const maybeReadConfigFile = (path) => path === void 0 ? Effect.succeed(void 0) : readConfigFile(path).pipe(Effect.map((config) => [path, config]));
+const resolveArtifactRoot = (input) => {
+	if (input.config.artifactDirectory) return resolve(input.cwd, input.config.artifactDirectory);
+	if (input.config.artifactScope === "global") return join(input.home, ".rdx", "transactions");
+	return join(input.cwd, ".rdx", "transactions");
+};
+const resolveRdxConfig = (input) => Effect.gen(function* () {
+	const home = input.home ?? homedir();
+	const projectConfigPath = yield* findNearestProjectConfig(input.cwd);
+	const globalConfigPath = join(home, ".rdx", "config.json");
+	const [globalConfig, projectConfig] = yield* Effect.all([fileExists(globalConfigPath).pipe(Effect.flatMap((exists) => exists ? maybeReadConfigFile(globalConfigPath) : Effect.succeed(void 0))), maybeReadConfigFile(projectConfigPath)]);
+	const config = {
+		...defaultConfig,
+		...globalConfig?.[1] ?? {},
+		...projectConfig?.[1] ?? {},
+		...input.overrides ?? {}
+	};
+	return {
+		...config,
+		artifactRoot: resolveArtifactRoot({
+			cwd: input.cwd,
+			home,
+			config
+		}),
+		projectConfigPath: projectConfig?.[0],
+		globalConfigPath: globalConfig?.[0]
+	};
+});
+var ConfigResolver = class extends Effect.Service()("ConfigResolver", { sync: () => ({ resolve: resolveRdxConfig }) }) {};
+
+//#endregion
+//#region src/llm.ts
+const llmGuide = `# rdx Agent Guide
+
+Use \`rdx\` to prepare, inspect, sign-orchestrate, notarize, submit, and track Radix Transaction Manifest V2 workflows from files. It is built for agents: workflow commands are non-interactive and print JSON by default.
+
+## Core Rules
+
+- Run \`rdx config show\` before \`tx prepare\` to verify the resolved network and artifact root.
+- After \`tx prepare\`, check \`startEpochInclusive\` and \`endEpochExclusive\` in the command JSON before collecting signatures.
+- \`rdx\` defaults to Mainnet. Prepare on the intended network; do not reuse prepared artifacts across networks.
+- A transaction lifecycle is network-bound from \`tx prepare\` through signing, notarization, submission, and status.
+- \`rdx\` never stores, accepts, or derives private keys.
+- Participants sign only the requested \`hash.hex\` outside \`rdx\` and return a filled signature template or signature file.
+- v1 CLI workflow files support Ed25519 only. Secp256k1 and other curves are rejected.
+- Use \`rdx account derive --public-key <hex>\` to derive a virtual account address offline from an Ed25519 public key.
+- Do not edit signing request files. Fill signature templates or create signature files instead.
+- Do not rerun \`tx prepare\` expecting overwrite. Existing transaction artifact directories are protected.
+- Do not submit until intent, subintent, notary-signatory, and notary signatures required by the artifacts are complete.
+- Use \`tx path\` and \`tx list\` before manually scanning artifact directories.
+
+## Discover Live Inputs
+
+\`\`\`sh
+rdx config show
+rdx template print subintents
+rdx template print signing-request
+rdx template print signature-template
+rdx template print signature-file
+rdx --help
+rdx tx prepare --help
+\`\`\`
+
+Use template output for workflow file shapes. Do not rely on copied config schemas; use \`rdx config show\` for resolved configuration.
+
+## Transaction Lifecycle
+
+1. Prepare: compile the root manifest plus optional direct child subintents, preview, and write immutable transaction artifacts.
+2. Inspect: read command JSON output, \`prepared.json\`, copied manifests, signing requests, and templates.
+3. Intent signing: each participant signs the relevant request \`hash.hex\` out of band.
+4. Import signatures: use \`tx add-signatures\` one or more times. Imports are normalized into \`signatures.json\`.
+5. Notarize: after intent/subintent signatures are locally complete, \`tx notarize\` previews the signed intent and creates the notary signing request.
+6. Notary signing: the notary signs the notary request \`hash.hex\` out of band.
+7. Import notary signature: use \`tx add-signatures\` again.
+8. Submit: \`tx submit\` compiles from prepared artifacts plus canonical signatures, writes the submitted payload, broadcasts, polls, and records the result.
+9. Track: use \`tx status\`, \`tx path\`, and \`tx list\` to inspect local and Gateway state.
+
+## Stable Artifact Mental Model
+
+Use command JSON outputs for exact paths. Common artifact files include:
+
+- \`prepared.json\`: canonical prepared metadata and signing request/template path index.
+- \`transactionIntent.json\`: encoded Transaction Intent V2 used by later commands.
+- \`staticAnalysis.json\`: full static analysis output.
+- \`rootManifest.rtm\`: copied root manifest.
+- \`subintents/<subintentId>.rtm\`: copied direct child subintent manifests.
+- \`signatures.json\`: canonical normalized signature state.
+- \`notarizedTransaction.hex\`: exact submitted payload.
+- \`submitResult.json\`: submit attempts and network status results.
+
+## Single-party Example
+
+\`\`\`sh
+rdx config show
+rdx template print signature-file
+rdx tx prepare --manifest ./tx/root.rtm --notary-file ./tx/notary.json
+rdx tx path txid_example
+rdx tx add-signatures txid_example --file ./tx/signatures/intent-signature.json
+rdx tx notarize txid_example
+rdx tx add-signatures txid_example --file ./tx/signatures/notary-signature.json
+rdx tx submit txid_example
+rdx tx status txid_example
+\`\`\`
+
+After \`tx prepare\`, inspect the JSON result for \`transactionId\`, \`artifactPath\`, \`preparedPath\`, \`startEpochInclusive\`, \`endEpochExclusive\`, and generated \`signatureTemplatePaths\`. Fill the generated templates by replacing placeholder Ed25519 public key and signature values. Sign only each request's \`hash.hex\`.
+
+## Multi-party And Subintent Example
+
+\`\`\`sh
+rdx config show
+rdx template print subintents
+rdx tx prepare --manifest ./tx/root.rtm --subintents ./tx/subintents.json --notary-file ./tx/notary.json
+rdx tx add-signatures txid_example --file ./party-a/root-signature.json
+rdx tx add-signatures txid_example --file ./party-b/child-one-signature.json
+rdx tx add-signatures txid_example --file ./party-c/batch-signatures.json
+rdx tx notarize txid_example
+rdx tx add-signatures txid_example --file ./notary/notary-signature.json
+rdx tx submit txid_example
+\`\`\`
+
+Subintent IDs in \`subintents.json\` are also Radix \`NamedIntent\` values referenced by root \`YIELD_TO_CHILD\` instructions. v1 supports root plus direct child subintents only. Multiple parties can return signatures asynchronously; repeat \`tx add-signatures\` until local completeness allows \`tx notarize\` and later \`tx submit\`.
+
+## Command Examples
+
+\`\`\`sh
+rdx config show
+rdx account derive --public-key 1111111111111111111111111111111111111111111111111111111111111111
+rdx account show account_rdx1...
+rdx account fungibles account_rdx1...
+rdx account nfts account_rdx1...
+rdx tx history account_rdx1... --limit 10
+rdx tx prepare --manifest ./tx/root.rtm --notary-file ./tx/notary.json
+rdx tx prepare --manifest ./tx/root.rtm --subintents ./tx/subintents.json --notary-file ./tx/notary.json
+rdx tx add-signatures txid_example --file ./signature.json
+rdx tx add-signatures txid_example --file ./signature-a.json --file ./signature-batch.json
+rdx tx notarize txid_example
+rdx tx submit txid_example
+rdx tx status txid_example
+rdx tx status txid_example --read-only
+rdx tx path txid_example
+rdx tx list
+rdx tx list --pattern root.rtm
+rdx tx list --regex '^txid_' --network mainnet --status prepared
+rdx tx list --with-network-status
+rdx tx list --with-network-status --update-network-status
+rdx template print subintents
+rdx template print signing-request
+rdx template print signature-template
+rdx template print signature-file
+\`\`\`
+
+\`account derive\` uses the resolved config network and does not query Gateway. It returns the derived virtual account address, not proof that the account exists on-ledger.
+
+## Troubleshooting
+
+- Workflow command failures print structured JSON errors with \`type\`, \`code\`, and \`message\`.
+- Gateway failures include response details in \`message\` when the Gateway returns a structured error body.
+- Inspect \`code\` and \`message\` first; avoid parsing human help text.
+- Use \`rdx tx status\`, \`rdx tx list\`, and \`rdx tx path\` before reading files manually.
+- If the network is wrong, prepare a new transaction for the intended network.
+- If a placeholder public key or signature remains in a file, replace it with a real Ed25519 value produced outside \`rdx\`.
+`;
+
+//#endregion
+//#region src/gatewayHttp.ts
+const parseResponseBody = (text) => {
+	if (!text) return;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+};
+const gatewayErrorMessage = (label, response) => Effect.gen(function* () {
+	const body = parseResponseBody(yield* Effect.promise(() => response.text()));
+	const detail = body === void 0 ? "" : `: ${renderJson(body)}`;
+	return `${label} failed with status ${response.status}${detail}`;
+});
+
+//#endregion
+//#region src/notarize.ts
+var NotarizeError = class extends Data.TaggedError("NotarizeError") {};
+const readJson$1 = (path) => readJsonFile(path, (reason) => new NotarizeError({
+	code: "READ_FAILED",
+	path,
+	reason
+}));
+const readSignatureFile = (input) => Effect.gen(function* () {
+	const path = join(input.artifactPath, "signatures.json");
+	const exists = yield* fileExists(path);
+	if (!exists && input.requiredSignatureCount === 0) return SignatureFileSchema.make({
+		type: "signatureFile",
+		version: 1,
+		transactionId: input.transactionId,
+		signatures: []
+	});
+	if (!exists) return yield* new NotarizeError({
+		code: "MISSING_SIGNATURE_FILE",
+		path,
+		reason: "Run `rdx tx add-signatures <transactionId> --file <signature-file>` before `rdx tx notarize`."
+	});
+	return yield* readJson$1(path).pipe(Effect.flatMap(Schema.decodeUnknown(SignatureFileSchema)));
+});
+const writeJson$1 = (path, value) => Effect.gen(function* () {
+	yield* makeDirectory(dirname(path), { recursive: true }, (reason) => new NotarizeError({
+		code: "WRITE_FAILED",
+		path,
+		reason
+	}));
+	yield* writeJsonFile(path, value, (reason) => new NotarizeError({
+		code: "WRITE_FAILED",
+		path,
+		reason
+	}));
+});
+const requestComplete$1 = (request, signatures) => signatures.some((signature) => signature.scope.kind === request.scope.kind && (signature.scope.kind !== "subintent" || request.scope.kind === "subintent" && signature.scope.subintentId === request.scope.subintentId) && signature.account === request.account && signature.hash.hex === request.hash.hex && signature.hash.id === request.hash.id);
+const toTransactionIntent$1 = (stored) => ({
+	transactionHeader: {
+		notaryPublicKey: new PublicKey.Ed25519(stored.transactionHeader.notaryPublicKey),
+		notaryIsSignatory: stored.transactionHeader.notaryIsSignatory,
+		tipBasisPoints: stored.transactionHeader.tipBasisPoints
+	},
+	rootIntentCore: {
+		header: stored.rootIntentCore.header,
+		instructions: stored.rootIntentCore.instructions,
+		blobs: [],
+		message: stored.rootIntentCore.message,
+		children: stored.rootIntentCore.children.map(Convert.HexString.toUint8Array)
+	},
+	nonRootSubintents: stored.nonRootSubintents.map((subintent) => ({ intentCore: {
+		header: subintent.intentCore.header,
+		instructions: subintent.intentCore.instructions,
+		blobs: [],
+		message: subintent.intentCore.message,
+		children: subintent.intentCore.children.map(Convert.HexString.toUint8Array)
+	} }))
+});
+const toSignatureWithPublicKey$1 = (signature) => new SignatureWithPublicKey.Ed25519(signature.signature.hex, signature.publicKey.hex);
+const rootIntentSignatures$1 = (signatures) => signatures.filter((signature) => signature.scope.kind === "rootIntent" || signature.scope.kind === "notarySignatory").map(toSignatureWithPublicKey$1);
+const nonRootSubintentSignatures$1 = (signatures, subintentOrder) => subintentOrder.map((subintentId) => signatures.filter((signature) => signature.scope.kind === "subintent" && signature.scope.subintentId === subintentId).map(toSignatureWithPublicKey$1));
+const rootSignerPublicKeys = (signatures) => signatures.filter((signature) => signature.scope.kind === "rootIntent" || signature.scope.kind === "notarySignatory").map((signature) => new PublicKey.Ed25519(signature.publicKey.hex));
+const nonRootSignerPublicKeys = (signatures, subintentOrder) => subintentOrder.map((subintentId) => signatures.filter((signature) => signature.scope.kind === "subintent" && signature.scope.subintentId === subintentId).map((signature) => new PublicKey.Ed25519(signature.publicKey.hex)));
+const buildNotarizePreviewHex = (input) => Effect.gen(function* () {
+	let builderStep = (yield* Effect.tryPromise(() => TransactionV2Builder.new())).header(input.transactionIntent.transactionHeader).rootIntentCore(input.transactionIntent.rootIntentCore);
+	const subintentSignatures = nonRootSubintentSignatures$1(input.signatures, input.subintentOrder);
+	for (let index = 0; index < input.transactionIntent.nonRootSubintents.length; index += 1) builderStep = builderStep.addSignedSubintent(input.transactionIntent.nonRootSubintents[index], subintentSignatures[index] ?? []);
+	const previewTransaction = builderStep.buildPreviewTransaction({
+		rootSignerPublicKeys: rootSignerPublicKeys(input.signatures),
+		nonRootSubintentSignerPublicKeys: nonRootSignerPublicKeys(input.signatures, input.subintentOrder)
+	});
+	const compiled = yield* Effect.tryPromise(() => RadixEngineToolkit.PreviewTransactionV2.compile(previewTransaction));
+	return Convert.Uint8Array.toHexString(compiled);
+});
+const gatewayBaseUrl$3 = (network) => network === "stokenet" ? "https://stokenet.radixdlt.com" : "https://mainnet.radixdlt.com";
+const gatewayNotarizePreview = (input) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${input.config.gatewayBaseUrl ?? gatewayBaseUrl$3(input.config.network)}/transaction/preview-v2`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				preview_transaction: {
+					type: "Compiled",
+					preview_transaction_hex: input.previewTransactionHex
+				},
+				flags: {
+					assume_all_signature_proofs: false,
+					skip_epoch_check: true,
+					use_free_credit: true
+				},
+				opt_ins: { core_api_receipt: false }
+			})
+		});
+		if (!response.ok) throw new Error(await Effect.runPromise(gatewayErrorMessage("Gateway preview", response)));
+		const body = await response.json();
+		if (body.receipt && body.receipt.status !== "Succeeded") throw new Error(body.receipt.error_message ?? "Preview failed");
+	},
+	catch: (reason) => new NotarizeError({
+		code: "PREVIEW_FAILED",
+		reason
+	})
+});
+const notarizeTransactionArtifact = (input) => Effect.gen(function* () {
+	const artifactPath = yield* findTransactionArtifact(input);
+	const preparedPath = join(artifactPath, "prepared.json");
+	const prepared = yield* readJson$1(preparedPath).pipe(Effect.flatMap(Schema.decodeUnknown(PreparedTransactionSchema)));
+	if (!prepared.notaryPublicKey) return yield* new NotarizeError({
+		code: "MISSING_NOTARY_PUBLIC_KEY",
+		path: preparedPath
+	});
+	const requestsRequiringSignatures = (yield* Effect.all(prepared.signingRequests.map((requestPath$1) => readJson$1(join(artifactPath, requestPath$1)).pipe(Effect.flatMap(Schema.decodeUnknown(SigningRequestSchema)))))).filter((request$1) => request$1.scope.kind !== "notary");
+	const signatureFile = yield* readSignatureFile({
+		artifactPath,
+		transactionId: prepared.transactionId,
+		requiredSignatureCount: requestsRequiringSignatures.length
+	});
+	const missingRequest = requestsRequiringSignatures.find((request$1) => !requestComplete$1(request$1, signatureFile.signatures));
+	if (missingRequest) {
+		const nextCommand = `rdx tx add-signatures ${prepared.transactionId} --file <signature-file>`;
+		return yield* new NotarizeError({
+			code: "INCOMPLETE_SIGNATURES",
+			path: missingRequest.signingRequestPath ?? join(artifactPath, "signatures.json"),
+			reason: `Missing signature for ${missingRequest.scope.kind}${missingRequest.account ? ` (${missingRequest.account})` : ""}. Next: ${nextCommand}`
+		});
+	}
+	const transactionIntent = toTransactionIntent$1((yield* readJson$1(join(artifactPath, prepared.transactionIntentPath)).pipe(Effect.map((value) => value))).encoded.value);
+	const signedIntent = {
+		transactionIntent,
+		transactionIntentSignatures: rootIntentSignatures$1(signatureFile.signatures),
+		nonRootSubintentSignatures: nonRootSubintentSignatures$1(signatureFile.signatures, prepared.subintentOrder)
+	};
+	const signedIntentHash = yield* Effect.tryPromise({
+		try: () => RadixEngineToolkit.SignedTransactionIntentV2.hash(signedIntent),
+		catch: (reason) => new NotarizeError({
+			code: "READ_FAILED",
+			path: prepared.transactionIntentPath,
+			reason
+		})
+	});
+	const signedIntentCompiled = yield* Effect.tryPromise({
+		try: () => RadixEngineToolkit.SignedTransactionIntentV2.compile(signedIntent),
+		catch: (reason) => new NotarizeError({
+			code: "READ_FAILED",
+			path: prepared.transactionIntentPath,
+			reason
+		})
+	});
+	if (input.previewSignedTransactionIntent) {
+		const previewTransactionHex = yield* buildNotarizePreviewHex({
+			transactionIntent,
+			signatures: signatureFile.signatures,
+			subintentOrder: prepared.subintentOrder
+		});
+		yield* input.previewSignedTransactionIntent(previewTransactionHex);
+	}
+	const hash = {
+		id: signedIntentHash.id,
+		hex: Convert.Uint8Array.toHexString(signedIntentHash.hash)
+	};
+	const requestPath = "signing-requests/notary.json";
+	const templatePath = "signature-templates/notary.json";
+	const request = {
+		type: "signingRequest",
+		version: 1,
+		transactionId: prepared.transactionId,
+		scope: { kind: "notary" },
+		account: null,
+		hash,
+		signingRequestPath: requestPath
+	};
+	const template = {
+		type: "signatureTemplate",
+		version: 1,
+		transactionId: prepared.transactionId,
+		scope: { kind: "notary" },
+		account: null,
+		hash,
+		signingRequestPath: requestPath,
+		publicKey: prepared.notaryPublicKey,
+		signature: {
+			curve: "Ed25519",
+			hex: PLACEHOLDER_SIGNATURE_HEX
+		}
+	};
+	const notarySigningRequestPath = join(artifactPath, requestPath);
+	const notarySignatureTemplatePath = join(artifactPath, templatePath);
+	const signedTransactionIntentPath = join(artifactPath, "signedTransactionIntent.json");
+	yield* writeJson$1(signedTransactionIntentPath, {
+		type: "signedTransactionIntent",
+		version: 1,
+		transactionId: prepared.transactionId,
+		encoded: {
+			kind: "signedTransactionIntentV2",
+			compiledHex: Convert.Uint8Array.toHexString(signedIntentCompiled)
+		}
+	});
+	yield* writeJson$1(notarySigningRequestPath, request);
+	yield* writeJson$1(notarySignatureTemplatePath, template);
+	yield* writeJson$1(preparedPath, {
+		...prepared,
+		signingRequests: [...new Set([...prepared.signingRequests, requestPath])],
+		signatureTemplates: [...new Set([...prepared.signatureTemplates, templatePath])]
+	});
+	return {
+		transactionId: prepared.transactionId,
+		artifactPath,
+		signedTransactionIntentPath,
+		notarySigningRequestPath,
+		notarySignatureTemplatePath
+	};
+});
+var NotarizationCoordinator = class extends Effect.Service()("NotarizationCoordinator", { sync: () => ({
+	notarizeTransactionArtifact,
+	gatewayNotarizePreview
+}) }) {};
+
+//#endregion
+//#region src/signingRequests.ts
+const scopePath = (scope) => {
+	switch (scope.kind) {
+		case "rootIntent": return "root";
+		case "subintent": return `subintents/${scope.subintentId}`;
+		case "notarySignatory": return "notary-signatory";
+		case "notary": return "notary";
+	}
+};
+const workflowFilePath = (directory, scope, account) => account ? `${directory}/${scopePath(scope)}/${account}.json` : `${directory}/${scopePath(scope)}.json`;
+const makeRequestAndTemplate = (input) => {
+	const requestPath = workflowFilePath("signing-requests", input.scope, input.account);
+	const templatePath = workflowFilePath("signature-templates", input.scope, input.account);
+	const request = {
+		type: "signingRequest",
+		version: 1,
+		transactionId: input.transactionId,
+		scope: input.scope,
+		account: input.account,
+		hash: input.hash,
+		signingRequestPath: requestPath
+	};
+	const template = {
+		type: "signatureTemplate",
+		version: 1,
+		transactionId: input.transactionId,
+		scope: input.scope,
+		account: input.account,
+		hash: input.hash,
+		signingRequestPath: requestPath,
+		publicKey: input.publicKey ?? {
+			curve: "Ed25519",
+			hex: PLACEHOLDER_PUBLIC_KEY_HEX
+		},
+		signature: {
+			curve: "Ed25519",
+			hex: PLACEHOLDER_SIGNATURE_HEX
+		}
+	};
+	return {
+		request: {
+			path: requestPath,
+			file: request
+		},
+		template: {
+			path: templatePath,
+			file: template
+		}
+	};
+};
+const generateSigningRequests = (input) => Effect.sync(() => {
+	const requests = [];
+	const templates = [];
+	const push = (item) => {
+		requests.push(item.request);
+		templates.push(item.template);
+	};
+	for (const account of input.authorizationAnalysis.rootIntent) push(makeRequestAndTemplate({
+		transactionId: input.transactionId,
+		scope: { kind: "rootIntent" },
+		account,
+		hash: input.rootIntentHash
+	}));
+	for (const [subintentId, accounts] of Object.entries(input.authorizationAnalysis.subintents)) for (const account of accounts) push(makeRequestAndTemplate({
+		transactionId: input.transactionId,
+		scope: {
+			kind: "subintent",
+			subintentId
+		},
+		account,
+		hash: input.subintentHashes[subintentId]
+	}));
+	if (input.notary.notaryIsSignatory) push(makeRequestAndTemplate({
+		transactionId: input.transactionId,
+		scope: { kind: "notarySignatory" },
+		account: null,
+		hash: input.rootIntentHash,
+		publicKey: input.notary.publicKey
+	}));
+	return {
+		requests,
+		templates
+	};
+});
+var SigningRequestGenerator = class extends Effect.Service()("SigningRequestGenerator", { sync: () => ({ generateSigningRequests }) }) {};
+
+//#endregion
+//#region src/subintentAssembly.ts
+var SubintentAssemblyError = class extends Data.TaggedError("SubintentAssemblyError") {};
+const subintentIdPattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const yieldToChildPattern = /YIELD_TO_CHILD\s+NamedIntent\("([^"]+)"\)/g;
+const uniqueInOrder = (items) => {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const item of items) if (!seen.has(item)) {
+		seen.add(item);
+		result.push(item);
+	}
+	return result;
+};
+const extractYieldedSubintentIds = (manifest) => uniqueInOrder([...manifest.matchAll(yieldToChildPattern)].map((match) => match[1]));
+const useChildDeclaration = (subintentId, intentHash) => `USE_CHILD
+  NamedIntent("${subintentId}")
+  Intent("${intentHash}")
+;`;
+const assembleRootManifest = (input) => Effect.gen(function* () {
+	const providedIds = Object.keys(input.childIntentHashes);
+	const yieldedIds = extractYieldedSubintentIds(input.rootManifest);
+	for (const subintentId of [...providedIds, ...yieldedIds]) if (!subintentIdPattern.test(subintentId)) return yield* new SubintentAssemblyError({
+		code: "INVALID_SUBINTENT_ID",
+		subintentId
+	});
+	for (const subintentId of yieldedIds) if (!(subintentId in input.childIntentHashes)) return yield* new SubintentAssemblyError({
+		code: "MISSING_SUBINTENT",
+		subintentId
+	});
+	for (const subintentId of providedIds) if (!yieldedIds.includes(subintentId)) return yield* new SubintentAssemblyError({
+		code: "UNREFERENCED_SUBINTENT",
+		subintentId
+	});
+	if (providedIds.length === 0) return {
+		rootManifest: input.rootManifest,
+		subintentOrder: []
+	};
+	return {
+		rootManifest: `${yieldedIds.map((subintentId) => useChildDeclaration(subintentId, input.childIntentHashes[subintentId])).join("\n\n")}\n\n${input.rootManifest.trimStart()}`,
+		subintentOrder: yieldedIds
+	};
+});
+var SubintentAssembly = class extends Effect.Service()("SubintentAssembly", { sync: () => ({ assembleRootManifest }) }) {};
+
+//#endregion
+//#region src/prepare.ts
+var PreparePreviewError = class extends Data.TaggedError("PreparePreviewError") {};
+const networkId = (network) => network === "mainnet" ? 1 : 2;
+const gatewayBaseUrl$2 = (network) => network === "stokenet" ? "https://stokenet.radixdlt.com" : "https://mainnet.radixdlt.com";
+const defaultEpochWindow = () => ({
+	startEpochInclusive: 1,
+	endEpochExclusive: 10
+});
+const epochWindowFromCurrentEpoch = (currentEpoch) => currentEpoch === void 0 ? defaultEpochWindow() : {
+	startEpochInclusive: currentEpoch,
+	endEpochExclusive: currentEpoch + 100
+};
+const intentDiscriminator = (input) => Number.parseInt(createHash("sha256").update(input.network).update("\n").update(input.notaryPublicKeyHex).update("\n").update(input.manifest).digest("hex").slice(0, 8), 16);
+const buildTransactionIntent = (input) => {
+	const id = networkId(input.network);
+	const epochWindow = input.epochWindow ?? defaultEpochWindow();
+	return {
+		transactionHeader: {
+			notaryPublicKey: new PublicKey.Ed25519(input.notary.publicKey.hex),
+			notaryIsSignatory: input.notary.notaryIsSignatory ?? true,
+			tipBasisPoints: 0
+		},
+		rootIntentCore: {
+			header: {
+				networkId: id,
+				startEpochInclusive: epochWindow.startEpochInclusive,
+				endEpochExclusive: epochWindow.endEpochExclusive,
+				intentDiscriminator: intentDiscriminator({
+					manifest: input.manifest,
+					network: input.network,
+					notaryPublicKeyHex: input.notary.publicKey.hex
+				})
+			},
+			instructions: input.manifest,
+			blobs: [],
+			message: { kind: "None" },
+			children: input.childHashes ?? []
+		},
+		nonRootSubintents: input.nonRootSubintents ?? []
+	};
+};
+const buildSubintent = (input) => ({ intentCore: {
+	header: {
+		networkId: networkId(input.network),
+		startEpochInclusive: input.epochWindow?.startEpochInclusive ?? defaultEpochWindow().startEpochInclusive,
+		endEpochExclusive: input.epochWindow?.endEpochExclusive ?? defaultEpochWindow().endEpochExclusive,
+		intentDiscriminator: intentDiscriminator({
+			manifest: `${input.subintentId}\n${input.manifest}`,
+			network: input.network,
+			notaryPublicKeyHex: input.notaryPublicKeyHex
+		})
+	},
+	instructions: input.manifest,
+	blobs: [],
+	message: { kind: "None" },
+	children: []
+} });
+const encodeIntentCore = (core) => ({
+	header: core.header,
+	instructions: core.instructions,
+	blobs: [],
+	message: core.message,
+	children: core.children.map((child) => Convert.Uint8Array.toHexString(child))
+});
+const encodeTransactionIntent = (intent, compiledHex) => ({
+	kind: "transactionIntentV2",
+	value: {
+		transactionHeader: {
+			notaryPublicKey: intent.transactionHeader.notaryPublicKey.hex(),
+			notaryIsSignatory: intent.transactionHeader.notaryIsSignatory,
+			tipBasisPoints: intent.transactionHeader.tipBasisPoints
+		},
+		rootIntentCore: encodeIntentCore(intent.rootIntentCore),
+		nonRootSubintents: intent.nonRootSubintents.map((subintent) => ({ intentCore: encodeIntentCore(subintent.intentCore) }))
+	},
+	compiledHex
+});
+const fallbackHashManifest = (manifest) => {
+	const hex = createHash("sha256").update(manifest).digest("hex");
+	return {
+		transactionId: `txid_cli_${hex.slice(0, 32)}`,
+		intentHash: {
+			id: `intent_cli_${hex.slice(0, 32)}`,
+			hex
+		}
+	};
+};
+const writeJson = (path, value) => writeJsonFile(path, value, (reason) => reason);
+const writeWorkflowFile = (artifactPath, relativePath, value) => Effect.gen(function* () {
+	const path = join(artifactPath, relativePath);
+	yield* makeDirectory(join(path, ".."), { recursive: true }, (reason) => reason);
+	yield* writeJson(path, value);
+	return path;
+});
+const buildPreparePreviewHex = (intent) => Effect.gen(function* () {
+	let builderStep = (yield* Effect.tryPromise(() => TransactionV2Builder.new())).header(intent.transactionHeader).rootIntentCore(intent.rootIntentCore);
+	for (const subintent of intent.nonRootSubintents) builderStep = builderStep.addSignedSubintent(subintent, []);
+	const previewTransaction = builderStep.buildPreviewTransaction({
+		rootSignerPublicKeys: [],
+		nonRootSubintentSignerPublicKeys: intent.nonRootSubintents.map(() => [])
+	});
+	const compiled = yield* Effect.tryPromise(() => RadixEngineToolkit.PreviewTransactionV2.compile(previewTransaction));
+	return Convert.Uint8Array.toHexString(compiled);
+});
+const gatewayPreparePreview = (input) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${input.config.gatewayBaseUrl ?? gatewayBaseUrl$2(input.config.network)}/transaction/preview-v2`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				preview_transaction: {
+					type: "Compiled",
+					preview_transaction_hex: input.previewTransactionHex
+				},
+				flags: {
+					assume_all_signature_proofs: true,
+					skip_epoch_check: true,
+					use_free_credit: true
+				},
+				opt_ins: { core_api_receipt: false }
+			})
+		});
+		if (!response.ok) throw new Error(await Effect.runPromise(gatewayErrorMessage("Gateway preview", response)));
+		const body = await response.json();
+		if (body.receipt && body.receipt.status !== "Succeeded") throw new Error(body.receipt.error_message ?? "Preview failed");
+	},
+	catch: (reason) => new PreparePreviewError({ reason })
+});
+const gatewayCurrentEpoch = (input) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${input.config.gatewayBaseUrl ?? gatewayBaseUrl$2(input.config.network)}/status/gateway-status`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: "{}"
+		});
+		if (!response.ok) throw new Error(await Effect.runPromise(gatewayErrorMessage("Gateway status", response)));
+		const body = await response.json();
+		if (typeof body.ledger_state?.epoch !== "number") throw new Error("Gateway status response did not include an epoch");
+		return body.ledger_state.epoch;
+	},
+	catch: (reason) => new PreparePreviewError({ reason })
+});
+const prepareTransactionArtifacts = (input) => Effect.gen(function* () {
+	const manifest = yield* readFileString(input.manifestPath, (reason) => reason);
+	const subintentsFile = input.subintentsPath ? yield* readJsonFile(input.subintentsPath, (reason) => reason).pipe(Effect.flatMap(Schema.decodeUnknown(SubintentsFileSchema))) : void 0;
+	const childSubintents = yield* Effect.all(Object.entries(subintentsFile?.subintents ?? {}).map(([subintentId, subintent]) => Effect.gen(function* () {
+		const transactionSubintent = buildSubintent({
+			subintentId,
+			manifest: subintent.manifest,
+			network: input.network,
+			notaryPublicKeyHex: input.notary.publicKey.hex,
+			epochWindow: epochWindowFromCurrentEpoch(input.currentEpoch)
+		});
+		const hash = yield* Effect.tryPromise(() => RadixEngineToolkit.SubintentV2.hash(transactionSubintent));
+		return {
+			subintentId,
+			manifest: subintent.manifest,
+			subintent: transactionSubintent,
+			hash
+		};
+	})));
+	const assembled = yield* assembleRootManifest({
+		rootManifest: manifest,
+		childIntentHashes: Object.fromEntries(childSubintents.map((subintent) => [subintent.subintentId, subintent.hash.id]))
+	});
+	const orderedChildSubintents = assembled.subintentOrder.map((subintentId) => childSubintents.find((subintent) => subintent.subintentId === subintentId));
+	const epochWindow = epochWindowFromCurrentEpoch(input.currentEpoch);
+	const intent = buildTransactionIntent({
+		manifest: assembled.rootManifest,
+		network: input.network,
+		notary: input.notary,
+		epochWindow,
+		childHashes: orderedChildSubintents.map((subintent) => subintent.hash.hash.slice()),
+		nonRootSubintents: orderedChildSubintents.map((subintent) => subintent.subintent)
+	});
+	const intentHashResult = yield* Effect.tryPromise(() => RadixEngineToolkit.TransactionIntentV2.hash(intent));
+	const compiledIntent = yield* Effect.tryPromise(() => RadixEngineToolkit.TransactionIntentV2.compile(intent));
+	const staticAnalysisResult = yield* Effect.tryPromise(() => RadixEngineToolkit.TransactionIntentV2.staticallyAnalyze(intent));
+	if (input.previewPreparedTransaction) {
+		const previewTransactionHex = yield* buildPreparePreviewHex(intent);
+		yield* input.previewPreparedTransaction(previewTransactionHex);
+	}
+	const fallback = fallbackHashManifest(manifest);
+	const intentHash = {
+		id: intentHashResult.id,
+		hex: Convert.Uint8Array.toHexString(intentHashResult.hash) ?? fallback.intentHash.hex
+	};
+	const transactionId = intentHashResult.id ?? fallback.transactionId;
+	const artifactPath = yield* createTransactionArtifactDirectory({
+		artifactRoot: input.artifactRoot,
+		transactionId
+	});
+	yield* writeFileString(join(artifactPath, "rootManifest.rtm"), assembled.rootManifest, (reason) => reason);
+	yield* Effect.all(orderedChildSubintents.map((subintent) => Effect.gen(function* () {
+		const path = join(artifactPath, "subintents", `${subintent.subintentId}.rtm`);
+		yield* makeDirectory(join(path, ".."), { recursive: true }, (reason) => reason);
+		yield* writeFileString(path, subintent.manifest, (reason) => reason);
+	})));
+	const transactionIntent = {
+		type: "transactionIntent",
+		version: 1,
+		transactionId,
+		encoded: encodeTransactionIntent(intent, Convert.Uint8Array.toHexString(compiledIntent))
+	};
+	const staticAnalysis = {
+		type: "staticAnalysis",
+		version: 1,
+		transactionId,
+		analysis: staticAnalysisResult
+	};
+	const authorizationAnalysis = {
+		rootIntent: staticAnalysisResult.root_intent.accounts_requiring_auth,
+		subintents: Object.fromEntries(staticAnalysisResult.non_root_subintents.map((subintent, index) => [assembled.subintentOrder[index] ?? `subintent-${index}`, subintent.accounts_requiring_auth]))
+	};
+	const generated = yield* generateSigningRequests({
+		transactionId,
+		rootIntentHash: intentHash,
+		subintentHashes: Object.fromEntries(orderedChildSubintents.map((subintent) => [subintent.subintentId, {
+			id: subintent.hash.id,
+			hex: Convert.Uint8Array.toHexString(subintent.hash.hash)
+		}])),
+		authorizationAnalysis,
+		notary: {
+			publicKey: input.notary.publicKey,
+			notaryIsSignatory: input.notary.notaryIsSignatory ?? true
+		}
+	});
+	yield* Effect.all(generated.requests.map((request) => writeWorkflowFile(artifactPath, request.path, request.file)));
+	const signatureTemplatePaths = yield* Effect.all(generated.templates.map((template) => writeWorkflowFile(artifactPath, template.path, template.file)));
+	const prepared = {
+		type: "preparedTransaction",
+		version: 1,
+		transactionId,
+		network: input.network,
+		intentHash,
+		manifestSourceFile: basename(input.manifestPath),
+		transactionIntentPath: "transactionIntent.json",
+		staticAnalysisPath: "staticAnalysis.json",
+		signingRequests: generated.requests.map((request) => request.path),
+		signatureTemplates: generated.templates.map((template) => template.path),
+		subintentOrder: assembled.subintentOrder,
+		authorizationAnalysis,
+		notaryPublicKey: input.notary.publicKey,
+		notaryIsSignatory: input.notary.notaryIsSignatory ?? true
+	};
+	const transactionIntentPath = join(artifactPath, "transactionIntent.json");
+	const staticAnalysisPath = join(artifactPath, "staticAnalysis.json");
+	const preparedPath = join(artifactPath, "prepared.json");
+	yield* writeJson(transactionIntentPath, transactionIntent);
+	yield* writeJson(staticAnalysisPath, staticAnalysis);
+	yield* writeJson(preparedPath, prepared);
+	return {
+		transactionId,
+		artifactPath,
+		preparedPath,
+		transactionIntentPath,
+		staticAnalysisPath,
+		signatureTemplatePaths,
+		startEpochInclusive: epochWindow.startEpochInclusive,
+		endEpochExclusive: epochWindow.endEpochExclusive
+	};
+});
+var TransactionPreparer = class extends Effect.Service()("TransactionPreparer", { sync: () => ({
+	prepareTransactionArtifacts,
+	gatewayPreparePreview,
+	gatewayCurrentEpoch
+}) }) {};
+
+//#endregion
+//#region src/status.ts
+var TransactionStatusError = class extends Data.TaggedError("TransactionStatusError") {};
+const gatewayBaseUrl$1 = (network) => network === "stokenet" ? "https://stokenet.radixdlt.com" : "https://mainnet.radixdlt.com";
+const readExistingSubmitResult$1 = (artifactPath) => readJsonFile(join(artifactPath, "submitResult.json"), (reason) => reason).pipe(Effect.flatMap(Schema.decodeUnknown(SubmitResultSchema)), Effect.catchAll(() => Effect.succeed(void 0)));
+const gatewayTransactionStatus = (input) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${input.config.gatewayBaseUrl ?? gatewayBaseUrl$1(input.config.network)}/transaction/status`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ intent_hash: input.transactionId })
+		});
+		if (!response.ok) throw new Error(await Effect.runPromise(gatewayErrorMessage("Gateway status", response)));
+		const body = await response.json();
+		return {
+			transactionId: input.transactionId,
+			status: body.intent_status ?? "Unknown",
+			statusDescription: body.intent_status_description ?? "",
+			errorMessage: body.error_message ?? null,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	},
+	catch: (reason) => new TransactionStatusError({
+		transactionId: input.transactionId,
+		reason
+	})
+});
+const queryTransactionStatus = (input) => Effect.gen(function* () {
+	const artifactPath = yield* findTransactionArtifactOption({
+		artifactRoot: input.artifactRoot,
+		transactionId: input.transactionId
+	});
+	const networkStatus = yield* input.getNetworkStatus(input.transactionId);
+	if (!artifactPath || input.readOnly) return {
+		transactionId: input.transactionId,
+		artifactPath: artifactPath ?? null,
+		networkStatus,
+		updatedSubmitResultPath: null
+	};
+	const existingSubmitResult = yield* readExistingSubmitResult$1(artifactPath);
+	const updatedSubmitResultPath = yield* writeSubmitResult({
+		artifactPath,
+		submitResult: {
+			type: "submitResult",
+			version: 1,
+			transactionId: input.transactionId,
+			networkStatus,
+			attempts: [...existingSubmitResult?.attempts ?? [], {
+				checkedAt: networkStatus.checkedAt,
+				status: networkStatus.status,
+				statusDescription: networkStatus.statusDescription,
+				errorMessage: networkStatus.errorMessage
+			}]
+		}
+	});
+	return {
+		transactionId: input.transactionId,
+		artifactPath,
+		networkStatus,
+		updatedSubmitResultPath
+	};
+});
+const listTransactionArtifactsWithNetworkStatus = (input) => Effect.gen(function* () {
+	const artifacts = yield* listTransactionArtifacts({
+		artifactRoot: input.artifactRoot,
+		pattern: input.pattern,
+		regex: input.regex,
+		network: input.network,
+		status: input.status
+	});
+	return yield* Effect.all(artifacts.map((artifact) => queryTransactionStatus({
+		artifactRoot: input.artifactRoot,
+		transactionId: artifact.transactionId,
+		readOnly: !input.update,
+		getNetworkStatus: input.getNetworkStatus
+	}).pipe(Effect.map((statusResult) => ({
+		...artifact,
+		networkStatus: statusResult.networkStatus,
+		updatedSubmitResultPath: statusResult.updatedSubmitResultPath
+	})))));
+});
+var StatusLifecycle = class extends Effect.Service()("StatusLifecycle", { sync: () => ({
+	queryTransactionStatus,
+	listTransactionArtifactsWithNetworkStatus,
+	gatewayTransactionStatus
+}) }) {};
+
+//#endregion
+//#region src/submit.ts
+var SubmitError = class extends Data.TaggedError("SubmitError") {};
+const readJson = (path) => readJsonFile(path, (reason) => new SubmitError({
+	code: "READ_FAILED",
+	path,
+	reason
+}));
+const toTransactionIntent = (stored) => ({
+	transactionHeader: {
+		notaryPublicKey: new PublicKey.Ed25519(stored.transactionHeader.notaryPublicKey),
+		notaryIsSignatory: stored.transactionHeader.notaryIsSignatory,
+		tipBasisPoints: stored.transactionHeader.tipBasisPoints
+	},
+	rootIntentCore: {
+		header: stored.rootIntentCore.header,
+		instructions: stored.rootIntentCore.instructions,
+		blobs: [],
+		message: stored.rootIntentCore.message,
+		children: stored.rootIntentCore.children.map(Convert.HexString.toUint8Array)
+	},
+	nonRootSubintents: stored.nonRootSubintents.map((subintent) => ({ intentCore: {
+		header: subintent.intentCore.header,
+		instructions: subintent.intentCore.instructions,
+		blobs: [],
+		message: subintent.intentCore.message,
+		children: subintent.intentCore.children.map(Convert.HexString.toUint8Array)
+	} }))
+});
+const toSignatureWithPublicKey = (signature) => new SignatureWithPublicKey.Ed25519(signature.signature.hex, signature.publicKey.hex);
+const rootIntentSignatures = (signatures) => signatures.filter((signature) => signature.scope.kind === "rootIntent" || signature.scope.kind === "notarySignatory").map(toSignatureWithPublicKey);
+const nonRootSubintentSignatures = (signatures, subintentOrder) => subintentOrder.map((subintentId) => signatures.filter((signature) => signature.scope.kind === "subintent" && signature.scope.subintentId === subintentId).map(toSignatureWithPublicKey));
+const findNotarySignature = (signatures) => signatures.find((signature) => signature.scope.kind === "notary");
+const readSigningRequest = (artifactPath, requestPath) => readJson(join(artifactPath, requestPath)).pipe(Effect.flatMap(Schema.decodeUnknown(SigningRequestSchema)));
+const requestComplete = (request, signatures) => signatures.some((signature) => signature.scope.kind === request.scope.kind && (signature.scope.kind !== "subintent" || request.scope.kind === "subintent" && signature.scope.subintentId === request.scope.subintentId) && signature.account === request.account && signature.hash.hex === request.hash.hex && signature.hash.id === request.hash.id);
+const readExistingSubmitResult = (artifactPath) => readJson(join(artifactPath, "submitResult.json")).pipe(Effect.flatMap(Schema.decodeUnknown(SubmitResultSchema)), Effect.catchAll(() => Effect.succeed(void 0)));
+const successfulSubmitStatuses = new Set(["CommittedSuccess"]);
+const isSuccessfulSubmitResult = (submitResult) => submitResult ? successfulSubmitStatuses.has(submitResult.networkStatus.status) : false;
+const gatewayBaseUrl = (network) => network === "stokenet" ? "https://stokenet.radixdlt.com" : "https://mainnet.radixdlt.com";
+const gatewaySubmitNotarizedTransaction = (input) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${input.config.gatewayBaseUrl ?? gatewayBaseUrl(input.config.network)}/transaction/submit`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ notarized_transaction_hex: input.notarizedTransactionHex })
+		});
+		if (!response.ok) throw new Error(await Effect.runPromise(gatewayErrorMessage("Gateway submit", response)));
+		return NetworkTransactionStatusSchema.make({
+			transactionId: input.transactionId,
+			status: "Submitted",
+			statusDescription: "Submitted to Gateway",
+			errorMessage: null,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	},
+	catch: (reason) => new SubmitError({
+		code: "WRITE_FAILED",
+		reason
+	})
+});
+const submitTransactionArtifact = (input) => Effect.gen(function* () {
+	const artifactPath = yield* findTransactionArtifact(input);
+	const existingSubmitResult = yield* readExistingSubmitResult(artifactPath);
+	if (isSuccessfulSubmitResult(existingSubmitResult)) return yield* new SubmitError({
+		code: "ALREADY_SUBMITTED",
+		path: join(artifactPath, "submitResult.json")
+	});
+	const prepared = yield* readJson(join(artifactPath, "prepared.json")).pipe(Effect.flatMap(Schema.decodeUnknown(PreparedTransactionSchema)));
+	const storedIntentFile = yield* readJson(join(artifactPath, prepared.transactionIntentPath)).pipe(Effect.map((value) => value));
+	const signatureFile = yield* readJson(join(artifactPath, "signatures.json")).pipe(Effect.flatMap(Schema.decodeUnknown(SignatureFileSchema)));
+	const missingRequest = (yield* Effect.all(prepared.signingRequests.map((requestPath) => readSigningRequest(artifactPath, requestPath)))).find((request) => !requestComplete(request, signatureFile.signatures));
+	if (missingRequest) return yield* new SubmitError({
+		code: "MISSING_SIGNATURE",
+		path: missingRequest.signingRequestPath,
+		reason: missingRequest
+	});
+	const notarySignatureEntry = findNotarySignature(signatureFile.signatures);
+	if (!notarySignatureEntry) return yield* new SubmitError({
+		code: "MISSING_NOTARY_SIGNATURE",
+		path: join(artifactPath, "signatures.json")
+	});
+	const notarizedTransaction = {
+		signedTransactionIntent: {
+			transactionIntent: toTransactionIntent(storedIntentFile.encoded.value),
+			transactionIntentSignatures: rootIntentSignatures(signatureFile.signatures),
+			nonRootSubintentSignatures: nonRootSubintentSignatures(signatureFile.signatures, prepared.subintentOrder)
+		},
+		notarySignature: new Signature.Ed25519(notarySignatureEntry.signature.hex)
+	};
+	const compiled = yield* Effect.tryPromise({
+		try: () => RadixEngineToolkit.NotarizedTransactionV2.compile(notarizedTransaction),
+		catch: (reason) => new SubmitError({
+			code: "WRITE_FAILED",
+			reason
+		})
+	});
+	const notarizedTransactionHex = Convert.Uint8Array.toHexString(compiled);
+	const notarizedTransactionPath = join(artifactPath, "notarizedTransaction.hex");
+	yield* writeFileString(notarizedTransactionPath, `${notarizedTransactionHex}\n`, (reason) => new SubmitError({
+		code: "WRITE_FAILED",
+		path: notarizedTransactionPath,
+		reason
+	}));
+	const submittedStatus = yield* input.submitNotarizedTransaction(notarizedTransactionHex);
+	const networkStatus = input.pollTransactionStatus ? yield* input.pollTransactionStatus(prepared.transactionId) : submittedStatus;
+	const newAttempts = input.pollTransactionStatus ? [{
+		checkedAt: submittedStatus.checkedAt,
+		status: submittedStatus.status,
+		statusDescription: submittedStatus.statusDescription,
+		errorMessage: submittedStatus.errorMessage
+	}, {
+		checkedAt: networkStatus.checkedAt,
+		status: networkStatus.status,
+		statusDescription: networkStatus.statusDescription,
+		errorMessage: networkStatus.errorMessage
+	}] : [{
+		checkedAt: networkStatus.checkedAt,
+		status: networkStatus.status,
+		statusDescription: networkStatus.statusDescription,
+		errorMessage: networkStatus.errorMessage
+	}];
+	const submitResultPath = yield* writeSubmitResult({
+		artifactPath,
+		submitResult: {
+			type: "submitResult",
+			version: 1,
+			transactionId: prepared.transactionId,
+			networkStatus,
+			attempts: [...existingSubmitResult?.attempts ?? [], ...newAttempts]
+		}
+	});
+	return {
+		transactionId: prepared.transactionId,
+		artifactPath,
+		notarizedTransactionPath,
+		submitResultPath,
+		networkStatus
+	};
+});
+var SubmitLifecycle = class extends Effect.Service()("SubmitLifecycle", { sync: () => ({
+	submitTransactionArtifact,
+	gatewaySubmitNotarizedTransaction
+}) }) {};
+
+//#endregion
+//#region src/templates.ts
+const sampleHash = {
+	id: "intent_or_subintent_hash_id",
+	hex: "aa"
+};
+const sampleScope = { kind: "rootIntent" };
+const workflowTemplate = (kind) => {
+	switch (kind) {
+		case "subintents": return {
+			type: "subintents",
+			version: 1,
+			subintents: { child_one: { manifest: "child-one.rtm" } }
+		};
+		case "signing-request": return {
+			type: "signingRequest",
+			version: 1,
+			transactionId: "txid...",
+			scope: sampleScope,
+			account: "account_rdx1...",
+			hash: sampleHash,
+			signingRequestPath: "signing-requests/root/account_rdx1....json"
+		};
+		case "signature-template": return {
+			type: "signatureTemplate",
+			version: 1,
+			transactionId: "txid...",
+			scope: sampleScope,
+			account: "account_rdx1...",
+			hash: sampleHash,
+			signingRequestPath: "signing-requests/root/account_rdx1....json",
+			publicKey: {
+				curve: "Ed25519",
+				hex: PLACEHOLDER_PUBLIC_KEY_HEX
+			},
+			signature: {
+				curve: "Ed25519",
+				hex: PLACEHOLDER_SIGNATURE_HEX
+			}
+		};
+		case "signature-file": return {
+			type: "signatureFile",
+			version: 1,
+			transactionId: "txid...",
+			signatures: []
+		};
+	}
+};
+
+//#endregion
+//#region src/cli.ts
+const formatOption = Options.choice("format", ["json", "text"]).pipe(Options.withDefault("json"), Options.withDescription("Output format"));
+const renderConfigShow = (format, config) => {
+	const result = {
+		type: "commandResult",
+		command: "config show",
+		network: config.network,
+		artifactScope: config.artifactScope,
+		artifactRoot: config.artifactRoot
+	};
+	if (format === "text") return `network: ${result.network}\nartifactScope: ${result.artifactScope}`;
+	return renderJson(result);
+};
+const renderTxPath = (format, input) => {
+	const result = {
+		type: "commandResult",
+		command: "tx path",
+		transactionId: input.transactionId,
+		artifactPath: input.artifactPath
+	};
+	if (format === "text") return input.artifactPath;
+	return renderJson(result);
+};
+const renderTxList = (format, artifacts) => {
+	const result = {
+		type: "commandResult",
+		command: "tx list",
+		artifacts
+	};
+	if (format === "text") return artifacts.map((artifact) => `${artifact.transactionId}\t${artifact.network}\t${artifact.status}\t${artifact.networkStatus?.status ?? "local"}\t${artifact.path}`).join("\n");
+	return renderJson(result);
+};
+const renderTemplate = (kind) => renderJson(workflowTemplate(kind));
+const renderLlmGuide = () => llmGuide;
+const renderAddSignatures = (format, result) => {
+	const commandResult = {
+		type: "commandResult",
+		command: "tx add-signatures",
+		acceptedCount: result.acceptedCount,
+		warnings: result.warnings,
+		complete: result.complete,
+		signaturesPath: result.signaturesPath
+	};
+	if (format === "text") return `accepted: ${result.acceptedCount}\ncomplete: ${result.complete}\nsignaturesPath: ${result.signaturesPath}`;
+	return renderJson(commandResult);
+};
+const renderTxStatus = (format, result) => {
+	const commandResult = {
+		type: "commandResult",
+		command: "tx status",
+		transactionId: result.transactionId,
+		artifactPath: result.artifactPath,
+		networkStatus: result.networkStatus,
+		updatedSubmitResultPath: result.updatedSubmitResultPath
+	};
+	if (format === "text") return `${result.transactionId}\t${result.networkStatus.status}`;
+	return renderJson(commandResult);
+};
+const renderPrepare = (format, result) => {
+	const commandResult = {
+		type: "commandResult",
+		command: "tx prepare",
+		transactionId: result.transactionId,
+		artifactPath: result.artifactPath,
+		preparedPath: result.preparedPath,
+		transactionIntentPath: result.transactionIntentPath,
+		staticAnalysisPath: result.staticAnalysisPath,
+		signatureTemplatePaths: result.signatureTemplatePaths,
+		startEpochInclusive: result.startEpochInclusive,
+		endEpochExclusive: result.endEpochExclusive
+	};
+	if (format === "text") return result.preparedPath;
+	return renderJson(commandResult);
+};
+const renderNotarize = (format, result) => {
+	const commandResult = {
+		type: "commandResult",
+		command: "tx notarize",
+		transactionId: result.transactionId,
+		artifactPath: result.artifactPath,
+		signedTransactionIntentPath: result.signedTransactionIntentPath,
+		notarySigningRequestPath: result.notarySigningRequestPath,
+		notarySignatureTemplatePath: result.notarySignatureTemplatePath
+	};
+	if (format === "text") return result.notarySignatureTemplatePath;
+	return renderJson(commandResult);
+};
+const renderSubmit = (format, result) => {
+	const commandResult = {
+		type: "commandResult",
+		command: "tx submit",
+		transactionId: result.transactionId,
+		artifactPath: result.artifactPath,
+		notarizedTransactionPath: result.notarizedTransactionPath,
+		submitResultPath: result.submitResultPath,
+		networkStatus: result.networkStatus
+	};
+	if (format === "text") return `${result.transactionId}\t${result.networkStatus.status}`;
+	return renderJson(commandResult);
+};
+const renderCommandResult = (format, result) => {
+	if (format === "text") return JSON.stringify(result);
+	return renderJson(result);
+};
+const renderAccountDerive = (format, result) => {
+	if (format === "text") return result.accountAddress;
+	return renderJson(result);
+};
+const rdxCommand = Command.make("rdx", { format: formatOption }).pipe(Command.withDescription("Agent-first Radix transaction workflow CLI"));
+const configCommand = Command.make("config").pipe(Command.withDescription("Inspect rdx configuration"));
+const configShowCommand = Command.make("show", {}, () => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	yield* Console.log(renderConfigShow(format, config));
+})).pipe(Command.withDescription("Print resolved configuration"));
+const llmCommand = Command.make("llm", {}, () => Console.log(renderLlmGuide())).pipe(Command.withDescription("Print compact Markdown instructions for agents"));
+const accountCommand = Command.make("account").pipe(Command.withDescription("Read account state"));
+const accountAddressArg = Args.text({ name: "accountAddress" }).pipe(Args.withDescription("Radix account address"));
+const publicKeyOption = Options.text("public-key").pipe(Options.withDescription("Ed25519 public key hex"));
+const accountDeriveCommand = Command.make("derive", { publicKey: publicKeyOption }, ({ publicKey }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const result = yield* deriveVirtualAccountAddress({
+		network: (yield* resolveRdxConfig({ cwd: process.cwd() })).network,
+		publicKeyHex: publicKey
+	});
+	yield* Console.log(renderAccountDerive(format, result));
+})).pipe(Command.withDescription("Derive a virtual account address"));
+const accountFungiblesCommand = Command.make("fungibles", { accountAddress: accountAddressArg }, ({ accountAddress }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* getAccountFungibles({
+		accountAddress,
+		readFungibles: (address) => gatewayAccountFungibles({
+			config,
+			accountAddress: address
+		})
+	});
+	yield* Console.log(renderCommandResult(format, result));
+})).pipe(Command.withDescription("Read account fungible tokens"));
+const accountNftsCommand = Command.make("nfts", { accountAddress: accountAddressArg }, ({ accountAddress }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* getAccountNfts({
+		accountAddress,
+		readNfts: (address) => gatewayAccountNfts({
+			config,
+			accountAddress: address
+		})
+	});
+	yield* Console.log(renderCommandResult(format, result));
+})).pipe(Command.withDescription("Read account NFTs"));
+const accountShowCommand = Command.make("show", { accountAddress: accountAddressArg }, ({ accountAddress }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* getAccountDetails({
+		accountAddress,
+		readDetails: (address) => gatewayAccountDetails({
+			config,
+			accountAddress: address
+		})
+	});
+	yield* Console.log(renderCommandResult(format, result));
+})).pipe(Command.withDescription("Read account details"));
+const txCommand = Command.make("tx").pipe(Command.withDescription("Work with transaction artifacts"));
+const manifestOption = Options.file("manifest", { exists: "yes" }).pipe(Options.withDescription("Root Transaction Manifest V2 file"));
+const notaryFileOption = Options.file("notary-file", { exists: "yes" }).pipe(Options.optional, Options.withDescription("Notary public key workflow file"));
+const subintentsOption = Options.file("subintents", { exists: "yes" }).pipe(Options.optional, Options.withDescription("Direct child subintents workflow file"));
+const transactionIdArg = Args.text({ name: "transactionId" }).pipe(Args.withDescription("Deterministic Radix transaction ID"));
+const txPathCommand = Command.make("path", { transactionId: transactionIdArg }, ({ transactionId }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const artifactPath = yield* findTransactionArtifact({
+		artifactRoot: (yield* resolveRdxConfig({ cwd: process.cwd() })).artifactRoot,
+		transactionId
+	});
+	yield* Console.log(renderTxPath(format, {
+		transactionId,
+		artifactPath
+	}));
+})).pipe(Command.withDescription("Locate a transaction artifact directory"));
+const txPrepareCommand = Command.make("prepare", {
+	manifest: manifestOption,
+	notaryFile: notaryFileOption,
+	subintents: subintentsOption
+}, ({ manifest, notaryFile, subintents }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const notaryFilePath = Option.getOrUndefined(notaryFile);
+	const notary = notaryFilePath ? yield* readJsonFile(notaryFilePath, (reason) => reason).pipe(Effect.flatMap(Schema.decodeUnknown(NotaryFileSchema))) : config.notary;
+	if (!notary) return yield* Effect.fail(/* @__PURE__ */ new Error("tx prepare requires --notary-file or config notary settings"));
+	const currentEpoch = yield* gatewayCurrentEpoch({ config });
+	const result = yield* prepareTransactionArtifacts({
+		artifactRoot: config.artifactRoot,
+		network: config.network,
+		manifestPath: manifest,
+		subintentsPath: Option.getOrUndefined(subintents),
+		notary,
+		currentEpoch,
+		previewPreparedTransaction: (previewTransactionHex) => gatewayPreparePreview({
+			config,
+			previewTransactionHex
+		})
+	});
+	yield* Console.log(renderPrepare(format, result));
+})).pipe(Command.withDescription("Prepare transaction artifacts"));
+const patternOption = Options.text("pattern").pipe(Options.optional);
+const regexOption = Options.text("regex").pipe(Options.optional);
+const networkOption = Options.choice("network", ["mainnet", "stokenet"]).pipe(Options.optional);
+const statusOption = Options.choice("status", [
+	"prepared",
+	"notarized",
+	"submitted"
+]).pipe(Options.optional);
+const withNetworkStatusOption = Options.boolean("with-network-status").pipe(Options.withDescription("Query Gateway status for each listed artifact"));
+const updateNetworkStatusOption = Options.boolean("update-network-status").pipe(Options.withDescription("Persist refreshed Gateway status into artifacts"));
+const txListCommand = Command.make("list", {
+	pattern: patternOption,
+	regex: regexOption,
+	network: networkOption,
+	status: statusOption,
+	withNetworkStatus: withNetworkStatusOption,
+	updateNetworkStatus: updateNetworkStatusOption
+}, ({ network, pattern, regex, status, updateNetworkStatus, withNetworkStatus }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const listInput = {
+		artifactRoot: config.artifactRoot,
+		pattern: Option.getOrUndefined(pattern),
+		regex: Option.getOrUndefined(regex),
+		network: Option.getOrUndefined(network),
+		status: Option.getOrUndefined(status)
+	};
+	const artifacts = withNetworkStatus || updateNetworkStatus ? yield* listTransactionArtifactsWithNetworkStatus({
+		...listInput,
+		update: updateNetworkStatus,
+		getNetworkStatus: (id) => gatewayTransactionStatus({
+			config,
+			transactionId: id
+		})
+	}) : yield* listTransactionArtifacts(listInput);
+	yield* Console.log(renderTxList(format, artifacts));
+})).pipe(Command.withDescription("List local transaction artifacts"));
+const signatureFileOption = Options.file("file", { exists: "yes" }).pipe(Options.atLeast(1), Options.withDescription("Signature file, batch file, or filled template"));
+const txAddSignaturesCommand = Command.make("add-signatures", {
+	transactionId: transactionIdArg,
+	files: signatureFileOption
+}, ({ files, transactionId }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const result = yield* addSignaturesToArtifact({
+		artifactRoot: (yield* resolveRdxConfig({ cwd: process.cwd() })).artifactRoot,
+		transactionId,
+		signatureFilePaths: files
+	});
+	yield* Console.log(renderAddSignatures(format, result));
+})).pipe(Command.withDescription("Import out-of-band signatures"));
+const txNotarizeCommand = Command.make("notarize", { transactionId: transactionIdArg }, ({ transactionId }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* notarizeTransactionArtifact({
+		artifactRoot: config.artifactRoot,
+		transactionId,
+		previewSignedTransactionIntent: (previewTransactionHex) => gatewayNotarizePreview({
+			config,
+			previewTransactionHex
+		})
+	});
+	yield* Console.log(renderNotarize(format, result));
+})).pipe(Command.withDescription("Create notary signing artifacts"));
+const txSubmitCommand = Command.make("submit", { transactionId: transactionIdArg }, ({ transactionId }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* submitTransactionArtifact({
+		artifactRoot: config.artifactRoot,
+		transactionId,
+		submitNotarizedTransaction: (notarizedTransactionHex) => gatewaySubmitNotarizedTransaction({
+			config,
+			transactionId,
+			notarizedTransactionHex
+		}),
+		pollTransactionStatus: (id) => gatewayTransactionStatus({
+			config,
+			transactionId: id
+		})
+	});
+	yield* Console.log(renderSubmit(format, result));
+})).pipe(Command.withDescription("Compile and submit a notarized transaction"));
+const readOnlyOption = Options.boolean("read-only").pipe(Options.withDescription("Do not update local transaction artifacts"));
+const txStatusCommand = Command.make("status", {
+	transactionId: transactionIdArg,
+	readOnly: readOnlyOption
+}, ({ readOnly, transactionId }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* queryTransactionStatus({
+		artifactRoot: config.artifactRoot,
+		transactionId,
+		readOnly,
+		getNetworkStatus: (id) => gatewayTransactionStatus({
+			config,
+			transactionId: id
+		})
+	});
+	yield* Console.log(renderTxStatus(format, result));
+})).pipe(Command.withDescription("Query Gateway transaction status"));
+const historyLimitOption = Options.integer("limit").pipe(Options.withDefault(10), Options.withDescription("Maximum transactions to return"));
+const txHistoryCommand = Command.make("history", {
+	accountAddress: accountAddressArg,
+	limit: historyLimitOption
+}, ({ accountAddress, limit }) => Effect.gen(function* () {
+	const { format } = yield* rdxCommand;
+	const config = yield* resolveRdxConfig({ cwd: process.cwd() });
+	const result = yield* getAccountTransactionHistory({
+		accountAddress,
+		limit,
+		readHistory: (address, itemLimit) => gatewayAccountHistory({
+			config,
+			accountAddress: address,
+			limit: itemLimit
+		})
+	});
+	yield* Console.log(renderCommandResult(format, result));
+})).pipe(Command.withDescription("Read account transaction history"));
+const templateCommand = Command.make("template").pipe(Command.withDescription("Print workflow file templates"));
+const templateKindArg = Args.choice([
+	["subintents", "subintents"],
+	["signing-request", "signing-request"],
+	["signature-template", "signature-template"],
+	["signature-file", "signature-file"]
+], { name: "kind" }).pipe(Args.withDescription("Workflow template kind"));
+const templatePrintCommand = Command.make("print", { kind: templateKindArg }, ({ kind }) => Console.log(renderTemplate(kind))).pipe(Command.withDescription("Print a JSON workflow template"));
+const command = rdxCommand.pipe(Command.withSubcommands([
+	accountCommand.pipe(Command.withSubcommands([
+		accountDeriveCommand,
+		accountFungiblesCommand,
+		accountNftsCommand,
+		accountShowCommand
+	])),
+	configCommand.pipe(Command.withSubcommands([configShowCommand])),
+	llmCommand,
+	templateCommand.pipe(Command.withSubcommands([templatePrintCommand])),
+	txCommand.pipe(Command.withSubcommands([
+		txAddSignaturesCommand,
+		txNotarizeCommand,
+		txPrepareCommand,
+		txPathCommand,
+		txListCommand,
+		txSubmitCommand,
+		txStatusCommand,
+		txHistoryCommand
+	]))
+]));
+const cli = Command.run(command, {
+	name: "rdx",
+	version: "0.1.0"
+});
+
+//#endregion
+export { findTransactionArtifactOption as $, SubintentAssemblyError as A, OutputFormatSchema as At, ConfigResolver as B, SubintentIdSchema as Bt, queryTransactionStatus as C, BatchSignatureFileSchema as Ct, gatewayPreparePreview as D, NetworkSchema as Dt, gatewayCurrentEpoch as E, HexStringSchema as Et, NotarizeError as F, SignatureEntrySchema as Ft, addSignaturesToArtifact as G, JsonValueSchema as Gt, ResolvedRdxConfigSchema as H, SubmitResultSchema as Ht, gatewayNotarizePreview as I, SignatureFileSchema as It, importSignatures as J, SignatureImportError as K, renderJson as Kt, notarizeTransactionArtifact as L, SignatureTemplateSchema as Lt, SigningRequestGenerator as M, PLACEHOLDER_SIGNATURE_HEX as Mt, generateSigningRequests as N, PreparedTransactionSchema as Nt, prepareTransactionArtifacts as O, NetworkTransactionStatusSchema as Ot, NotarizationCoordinator as P, PublicKeySchema as Pt, findTransactionArtifact as Q, llmGuide as R, SigningRequestSchema as Rt, listTransactionArtifactsWithNetworkStatus as S, AuthorizationAnalysisSchema as St, TransactionPreparer as T, Ed25519SignatureHexSchema as Tt, resolveRdxConfig as U, TransactionHistoryResultSchema as Ut, RdxConfigFileSchema as V, SubintentsFileSchema as Vt, AddSignaturesWorkflow as W, VirtualAccountDerivationSchema as Wt, ArtifactStoreError as X, ArtifactStore as Y, createTransactionArtifactDirectory as Z, gatewaySubmitNotarizedTransaction as _, AccountFungiblesResultSchema as _t, renderConfigShow as a, AccountReadError as at, TransactionStatusError as b, ArtifactScopeSchema as bt, renderPrepare as c, deriveVirtualAccountAddress as ct, renderTxList as d, gatewayAccountHistory as dt, listTransactionArtifacts as et, renderTxPath as f, gatewayAccountNfts as ft, SubmitLifecycle as g, getAccountTransactionHistory as gt, SubmitError as h, getAccountNfts as ht, renderCommandResult as i, readJsonFile as it, assembleRootManifest as j, PLACEHOLDER_PUBLIC_KEY_HEX as jt, SubintentAssembly as k, NotaryFileSchema as kt, renderSubmit as l, gatewayAccountDetails as lt, workflowTemplate as m, getAccountFungibles as mt, renderAccountDerive as n, writeCanonicalSignatures as nt, renderLlmGuide as o, AccountReadService as ot, renderTxStatus as p, getAccountDetails as pt, SignatureImporter as q, toJsonValue as qt, renderAddSignatures as r, writeSubmitResult as rt, renderNotarize as s, InvalidPublicKeyError as st, cli as t, normalizeSignatures as tt, renderTemplate as u, gatewayAccountFungibles as ut, submitTransactionArtifact as v, AccountNftsResultSchema as vt, PreparePreviewError as w, Ed25519PublicKeyHexSchema as wt, gatewayTransactionStatus as x, ArtifactStatusSchema as xt, StatusLifecycle as y, AccountShowResultSchema as yt, ConfigResolutionError as z, SigningScopeSchema as zt };
+//# sourceMappingURL=cli-n0bR-cOj.js.map