@radix-effects/tx-tool 0.0.1

package/dist/index.js

@@ -0,0 +1,900 @@
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import { Amount, Base64String, Epoch, FungibleResourceAddress, HexString, NetworkId, Nonce, TransactionId, TransactionManifestString, TransactionMessageString } from "@radix-effects/shared";
+import { Convert, PrivateKey, PublicKey, RadixEngineToolkit, Signature, SignatureWithPublicKey, TransactionBuilder, generateRandomNonce } from "@radixdlt/radix-engine-toolkit";
+import { Array, Cause, Config, Context, Data, Duration, Effect, Fiber, Layer, Option, ParseResult, Record, Redacted, Schedule, Schema, String, TestClock, flow, pipe } from "effect";
+import { FileSystem, HttpBody, HttpClient } from "@effect/platform";
+import { NodeFileSystem, NodeHttpClient } from "@effect/platform-node";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { AccountAddress as AccountAddress$1 } from "shared/brandedTypes";
+import { GatewayApiClient, GetFungibleBalance, GetLedgerStateService } from "@radix-effects/gateway";
+
+//#region src/manifests/addFeePayer.ts
+const addFeePayer = (input) => {
+	if (input.account.type === "unsecurifiedAccount") return TransactionManifestString.make(`
+    CALL_METHOD
+      Address("${input.account.address}")
+      "lock_fee"
+      Decimal("${input.amount}")
+    ;
+  `);
+	return TransactionManifestString.make(`
+  CALL_METHOD
+    Address("${input.account.accessControllerAddress}")
+    "create_proof"
+  ;
+
+  CALL_METHOD
+    Address("${input.account.address}")
+    "lock_fee"
+    Decimal("${input.amount}")
+  ;
+`);
+};
+
+//#endregion
+//#region src/manifests/createBadge.ts
+const createBadge = (account, initialSupply = 1) => TransactionManifestString.make(`      
+    CREATE_FUNGIBLE_RESOURCE_WITH_INITIAL_SUPPLY
+        Enum<0u8>()
+        true
+        0u8
+        Decimal("${initialSupply}")
+        Tuple(
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            ),
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            ),
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            ),
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            ),
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<0u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            ),
+            Enum<1u8>(
+                Tuple(
+                    Enum<1u8>(
+                        Enum<0u8>()
+                    ),
+                    Enum<1u8>(
+                        Enum<1u8>()
+                    )
+                )
+            )
+        )
+        Tuple(
+            Map<String, Tuple>(
+                "name" => Tuple(
+                    Enum<1u8>(
+                        Enum<0u8>(
+                            "Badge"
+                        )
+                    ),
+                    false
+                )
+            ),
+            Map<String, Enum>(
+                "metadata_setter" => Enum<0u8>(),
+                "metadata_setter_updater" => Enum<0u8>(),
+                "metadata_locker" => Enum<0u8>(),
+                "metadata_locker_updater" => Enum<0u8>()
+            )
+        )
+        Enum<0u8>()
+    ;
+  
+    CALL_METHOD
+      Address("${account.address}")
+      "try_deposit_batch_or_abort"
+      Expression("ENTIRE_WORKTOP")
+      Enum<0u8>()
+    ;`);
+
+//#endregion
+//#region src/manifests/createFungibleToken.ts
+const createFungibleTokenManifest = (input) => TransactionManifestString.make(`CREATE_FUNGIBLE_RESOURCE_WITH_INITIAL_SUPPLY
+None
+true
+0u8
+Decimal("${input.initialSupply}")
+Tuple(
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::DenyAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  ),
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::DenyAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  ),
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::DenyAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  ),
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::DenyAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  ),
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::AllowAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  ),
+  Some(         
+    Tuple(
+      Some(Enum<AccessRule::AllowAll>()),  
+      Some(Enum<AccessRule::DenyAll>())
+    )
+  )
+)
+Tuple(
+    Map<String, Tuple>(
+      "name" => Tuple(
+Some(Enum<Metadata::String>("${input.name}")),                  
+false                                                         
+),"symbol" => Tuple(
+Some(Enum<Metadata::String>("${input.symbol}")),                  
+false                                                         
+)
+    ),
+    Map<String, Enum>(
+      "metadata_setter" => None,
+      "metadata_setter_updater" => None,
+      "metadata_locker" => None,          
+      "metadata_locker_updater" => None
+    )
+)
+None
+;
+
+CALL_METHOD
+Address("${input.account.address}")
+"try_deposit_batch_or_abort"
+Expression("ENTIRE_WORKTOP")
+Enum<0u8>()
+;`);
+
+//#endregion
+//#region src/manifests/faucet.ts
+const faucet = (accountAddress) => Effect.gen(function* () {
+	const knownAddresses = yield* Effect.tryPromise(() => RadixEngineToolkit.Utils.knownAddresses(2));
+	return TransactionManifestString.make(`
+      CALL_METHOD
+        Address("${knownAddresses.componentAddresses.faucet}")
+        "lock_fee"
+        Decimal("10")
+      ;
+    
+      CALL_METHOD
+        Address("${knownAddresses.componentAddresses.faucet}")
+        "free"
+      ;
+    
+      CALL_METHOD
+        Address("${accountAddress}")
+        "try_deposit_batch_or_abort"
+        Expression("ENTIRE_WORKTOP")
+        Enum<0u8>()
+      ;`);
+});
+
+//#endregion
+//#region src/manifests/manifestHelper.ts
+var ManifestHelper = class extends Effect.Service()("ManifestHelper", { effect: Effect.gen(function* () {
+	return { addFeePayer: (input) => Effect.gen(function* () {
+		if (input.account.type === "unsecurifiedAccount") return TransactionManifestString.make(`
+                CALL_METHOD
+                  Address("${input.account.address}")
+                  "lock_fee"
+                  Decimal("${input.amount}")
+                ;
+              `);
+		return TransactionManifestString.make(`
+              CALL_METHOD
+                Address("${input.account.accessControllerAddress}")
+                "create_proof"
+              ;
+
+              CALL_METHOD
+                Address("${input.account.address}")
+                "lock_fee"
+                Decimal("${input.amount}")
+              ;
+            `);
+	}) };
+}) }) {};
+
+//#endregion
+//#region src/schemas.ts
+var schemas_exports = /* @__PURE__ */ __export({
+	BadgeDecodedSchema: () => BadgeDecodedSchema,
+	BadgeSchema: () => BadgeSchema,
+	Base64FromHexSchema: () => Base64FromHexSchema,
+	Ed25519PrivateKeySchema: () => Ed25519PrivateKeySchema,
+	Ed25519PublicKeySchema: () => Ed25519PublicKeySchema,
+	Ed25519SignatureWithPublicKeySchema: () => Ed25519SignatureWithPublicKeySchema,
+	HexFromBase64Schema: () => HexFromBase64Schema,
+	ManifestSchema: () => ManifestSchema,
+	TransactionHeaderSchema: () => TransactionHeaderSchema,
+	TransactionIntentSchema: () => TransactionIntentSchema,
+	TransactionMessageSchema: () => TransactionMessageSchema
+});
+const Base64FromHexSchema = Schema.asSchema(Schema.transformOrFail(HexString, Base64String, {
+	decode: (hex) => Effect.succeed(Base64String.make(Buffer.from(hex, "hex").toString("base64"))),
+	encode: (base64) => Effect.succeed(HexString.make(Buffer.from(base64, "base64").toString("hex")))
+}));
+const HexFromBase64Schema = Schema.asSchema(Schema.transformOrFail(Base64String, HexString, {
+	decode: (base64) => Effect.succeed(HexString.make(Buffer.from(base64, "base64").toString("hex"))),
+	encode: (hex) => Effect.succeed(Base64String.make(Buffer.from(hex, "hex").toString("base64")))
+}));
+const Ed25519PublicKeySchema = Schema.asSchema(Schema.transformOrFail(HexString, Schema.instanceOf(PublicKey.Ed25519), {
+	decode: (hex) => Effect.succeed(new PublicKey.Ed25519(hex)),
+	encode: (publicKey) => Effect.succeed(HexString.make(publicKey.hex()))
+}));
+const Ed25519PrivateKeySchema = Schema.asSchema(Schema.transformOrFail(HexString, Schema.instanceOf(PrivateKey.Ed25519), {
+	decode: (hex) => Effect.succeed(new PrivateKey.Ed25519(hex)),
+	encode: (publicKey) => Effect.succeed(HexString.make(Convert.Uint8Array.toHexString(publicKey.bytes)))
+}));
+const ManifestSchema = Schema.asSchema(Schema.transformOrFail(TransactionManifestString, Schema.Struct({
+	instructions: Schema.Struct({
+		kind: Schema.Literal("String"),
+		value: TransactionManifestString
+	}),
+	blobs: Schema.mutable(Schema.Array(Schema.Uint8Array))
+}), {
+	decode: (value) => Effect.succeed({
+		instructions: {
+			kind: "String",
+			value
+		},
+		blobs: []
+	}),
+	encode: (input) => Effect.succeed(TransactionManifestString.make(input.instructions.value))
+}));
+const PlainTextMessageSchema = Schema.Struct({
+	kind: Schema.Literal("PlainText"),
+	value: Schema.Struct({
+		message: Schema.Struct({
+			kind: Schema.Literal("String"),
+			value: TransactionMessageString
+		}),
+		mimeType: Schema.Literal("text/plain")
+	})
+});
+const EmptyMessageSchema = Schema.Struct({ kind: Schema.Literal("None") });
+const TransactionMessageSchema = Schema.asSchema(Schema.transformOrFail(Schema.OptionFromUndefinedOr(TransactionMessageString), Schema.Union(PlainTextMessageSchema, EmptyMessageSchema), {
+	decode: (value) => Option.match(value, {
+		onNone: () => Effect.succeed({ kind: "None" }),
+		onSome: (value$1) => Effect.succeed({
+			kind: "PlainText",
+			value: {
+				message: {
+					kind: "String",
+					value: value$1
+				},
+				mimeType: "text/plain"
+			}
+		})
+	}),
+	encode: (input) => Effect.succeed(input.kind === "None" ? Option.none() : Option.some(TransactionMessageString.make(input.value.message.value)))
+}));
+const TransactionHeaderSchema = Schema.Struct({
+	networkId: NetworkId,
+	startEpochInclusive: Epoch,
+	endEpochExclusive: Epoch,
+	notaryPublicKey: Ed25519PublicKeySchema,
+	nonce: Nonce,
+	notaryIsSignatory: Schema.Boolean,
+	tipPercentage: Schema.Number
+});
+const TransactionIntentSchema = Schema.Struct({
+	header: TransactionHeaderSchema,
+	message: TransactionMessageSchema,
+	manifest: ManifestSchema
+});
+const Ed25519SignatureWithPublicKeySchema = Schema.asSchema(Schema.transformOrFail(Schema.Struct({
+	signature: HexString,
+	signerPublicKey: HexString,
+	curve: Schema.Literal("Ed25519")
+}), Schema.instanceOf(SignatureWithPublicKey.Ed25519), {
+	strict: false,
+	decode: (value) => Effect.succeed(new SignatureWithPublicKey.Ed25519(value.signature, value.signerPublicKey)),
+	encode: (input) => Effect.succeed({
+		signature: HexString.make(Convert.Uint8Array.toHexString(input.signature)),
+		signerPublicKey: HexString.make(Convert.Uint8Array.toHexString(input.publicKey))
+	})
+}));
+const BadgeDecodedSchema = Schema.Struct({
+	type: Schema.Literal("fungibleResource"),
+	resourceAddress: FungibleResourceAddress
+});
+const BadgeSchema = Schema.transformOrFail(Schema.Struct({
+	type: Schema.String,
+	resourceAddress: Schema.String
+}), BadgeDecodedSchema, {
+	strict: false,
+	decode: (value) => Effect.succeed(Schema.Struct({
+		type: Schema.Literal("fungibleResource"),
+		resourceAddress: FungibleResourceAddress
+	}).make({
+		type: "fungibleResource",
+		resourceAddress: FungibleResourceAddress.make(value.resourceAddress)
+	})),
+	encode: (value) => Effect.succeed(value)
+});
+
+//#endregion
+//#region src/signer/vault.ts
+const SignResponseSchema = Schema.asSchema(Schema.transformOrFail(Schema.Struct({ data: Schema.Struct({ signature: Schema.String }) }), HexString, {
+	strict: true,
+	decode: (input) => pipe(input.data.signature, String.split(":"), Array.last, Option.getOrThrow, Base64String.make, Schema.decode(HexFromBase64Schema), Effect.catchTag("ParseError", (error) => ParseResult.fail(error.issue))),
+	encode: (value, _, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, value, "Encoding signatures back to response format is forbidden."))
+}));
+const PublicKeyResponseSchema = Schema.asSchema(Schema.transformOrFail(Schema.Struct({ data: Schema.Struct({ keys: Schema.Record({
+	key: Schema.String,
+	value: Schema.Struct({ public_key: Base64String })
+}) }) }), HexString, {
+	strict: true,
+	decode: (input) => pipe(input.data.keys, (keys) => Record.values(keys), Array.head, Option.map((item) => item.public_key), Option.getOrThrow, Schema.decode(HexFromBase64Schema), Effect.catchTag("ParseError", (error) => ParseResult.fail(error.issue))),
+	encode: (value, _, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, value, "Encoding public keys back to response format is forbidden."))
+}));
+/**
+* Reads the Vault token from a file or falls back to environment variable.
+* In production, Vault Agent writes the token to a file and handles renewal.
+* For local development, you can use either VAULT_TOKEN_FILE or VAULT_TOKEN.
+*/
+const getVaultToken = (fs) => Effect.gen(function* () {
+	const tokenFilePath = yield* Config.string("VAULT_TOKEN_FILE").pipe(Config.option, Effect.map(Option.getOrUndefined));
+	if (tokenFilePath) return (yield* fs.readFileString(tokenFilePath)).trim();
+	return yield* Config.string("VAULT_TOKEN");
+});
+const NodeHttpClientLive = NodeHttpClient.layerWithoutAgent.pipe(Layer.provide(NodeHttpClient.makeAgentLayer({ rejectUnauthorized: false })));
+var Vault = class extends Effect.Service()("Vault", {
+	dependencies: [NodeHttpClientLive, NodeFileSystem.layer],
+	effect: Effect.gen(function* () {
+		const keyName = yield* Config.string("VAULT_KEY_NAME").pipe(Config.withDefault("xrd-distribution"));
+		const baseUrl = yield* Config.string("VAULT_BASE_URL").pipe(Config.withDefault("http://localhost:8200"), Effect.orDie);
+		const httpClient = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+			schedule: Schedule.exponential(Duration.millis(100)),
+			times: 3
+		}), HttpClient.tapError((error) => Effect.logError("Vault request error", { error })), HttpClient.tap((response) => response.status >= 200 && response.status < 300 ? Effect.void : response.json.pipe(Effect.tap((body) => Effect.logError("Vault request failed", {
+			status: response.status,
+			url: response.request.url,
+			body
+		})), Effect.ignore)), HttpClient.filterStatusOk);
+		const fs = yield* FileSystem.FileSystem;
+		const getPublicKey = () => Effect.gen(function* () {
+			const token = yield* getVaultToken(fs);
+			return yield* httpClient.get(`${baseUrl}/v1/transit/keys/${keyName}`, { headers: { "X-Vault-Token": token } }).pipe(Effect.tapError(Effect.logError), Effect.flatMap((response) => response.json), Effect.flatMap(Schema.decodeUnknown(PublicKeyResponseSchema)));
+		}).pipe(Effect.orDie);
+		const toSignatureWithPublicKey = (hash) => Effect.gen(function* () {
+			const token = yield* getVaultToken(fs);
+			const encoded = {
+				signature: yield* httpClient.post(`${baseUrl}/v1/transit/sign/${keyName}`, {
+					headers: {
+						"X-Vault-Token": token,
+						"Content-Type": "application/json"
+					},
+					body: yield* Schema.decode(Base64FromHexSchema)(hash).pipe(Effect.flatMap((base64) => HttpBody.json({ input: base64 })))
+				}).pipe(Effect.flatMap((response) => response.json), Effect.tap((response) => Effect.log(response)), Effect.flatMap(Schema.decodeUnknown(SignResponseSchema))),
+				signerPublicKey: yield* getPublicKey(),
+				curve: "Ed25519"
+			};
+			return yield* Schema.decode(Ed25519SignatureWithPublicKeySchema)(encoded);
+		}).pipe(Effect.annotateLogs({
+			signer: "Vault",
+			keyName
+		}));
+		return {
+			getPublicKey,
+			toSignatureWithPublicKey
+		};
+	})
+}) {};
+
+//#endregion
+//#region src/signer/signer.ts
+var FailedToSignTransactionError = class extends Data.TaggedError("FailedToSignTransactionError") {};
+var Signer = class Signer extends Context.Tag("Signer")() {
+	static VaultLive = Layer.effect(Signer, Effect.gen(function* () {
+		const vault = yield* Vault;
+		return {
+			signToSignatureWithPublicKey: (hash) => vault.toSignatureWithPublicKey(hash).pipe(Effect.map((signatureWithPublicKey) => [signatureWithPublicKey]), Effect.catchAll(Effect.die)),
+			publicKey: () => vault.getPublicKey().pipe(Effect.map((publicKey) => new PublicKey.Ed25519(publicKey)))
+		};
+	})).pipe(Layer.provide(Vault.Default));
+	static makePrivateKeySigner = (privateKey) => Layer.effect(Signer, Effect.gen(function* () {
+		return {
+			signToSignatureWithPublicKey: (hash) => Effect.gen(function* () {
+				const value = Redacted.value(privateKey);
+				const Ed25519PrivateKey = yield* Schema.decode(Ed25519PrivateKeySchema)(value);
+				return [{
+					curve: "Ed25519",
+					signature: Ed25519PrivateKey.signToSignatureWithPublicKey(Convert.HexString.toUint8Array(hash)).signature,
+					publicKey: Ed25519PrivateKey.publicKey().bytes
+				}];
+			}).pipe(Effect.orDie, Effect.annotateLogs({ signer: "PrivateKey" })),
+			publicKey: () => Effect.gen(function* () {
+				const value = Redacted.value(privateKey);
+				return (yield* Schema.decode(Ed25519PrivateKeySchema)(value)).publicKey();
+			}).pipe(Effect.orDie)
+		};
+	}));
+};
+
+//#endregion
+//#region src/test-helpers/createAccount.ts
+const createAccount = (input) => Effect.gen(function* () {
+	const privateKey = input?.privateKey ? input.privateKey : ed25519.keygen().secretKey;
+	const publicKey = ed25519.getPublicKey(privateKey);
+	const publicKeyHex = Buffer.from(publicKey).toString("hex");
+	const keypair = new PrivateKey.Ed25519(privateKey);
+	const address = yield* Effect.tryPromise(() => RadixEngineToolkit.Derive.virtualAccountAddressFromPublicKey(keypair.publicKey(), input?.networkId ?? 1));
+	return {
+		address: AccountAddress$1.make(address),
+		sign: (hash) => {
+			const signature = ed25519.sign(hexToBytes(hash), privateKey);
+			return Buffer.from(signature).toString("hex");
+		},
+		publicKeyHex,
+		privateKeyHex: Buffer.from(privateKey).toString("hex")
+	};
+});
+
+//#endregion
+//#region src/test-helpers/disableTestClock.ts
+const resolveFiber = (fiber) => Effect.gen(function* () {
+	while (Option.isNone(yield* Fiber.poll(fiber))) {
+		yield* Effect.promise(async () => new Promise((resolve) => setTimeout(resolve, 1e3)));
+		yield* TestClock.adjust(Duration.seconds(1));
+	}
+	return yield* Fiber.join(fiber);
+});
+const DisableTestClock = (effect) => Effect.gen(function* () {
+	return yield* resolveFiber(yield* effect.pipe(Effect.fork));
+});
+
+//#endregion
+//#region src/notaryKeyPair.ts
+var NotaryKeyPair = class extends Effect.Service()("NotaryKeyPair", { effect: Effect.gen(function* () {
+	const signer = yield* Signer;
+	return {
+		publicKey: () => signer.publicKey(),
+		signToSignature: (hash) => signer.signToSignatureWithPublicKey(hash).pipe(Effect.map(flow(Array.head, Option.map((signature) => new Signature.Ed25519(signature.signature)), Option.getOrThrow)))
+	};
+}) }) {};
+
+//#endregion
+//#region src/compileTransaction.ts
+var FailedToCompileTransactionError = class extends Data.TaggedError("FailedToCompileTransactionError") {};
+var FailedToNotarizeTransactionError = class extends Data.TaggedError("FailedToNotarizeTransactionError") {};
+Schema.Struct({
+	intent: TransactionIntentSchema,
+	signatures: Schema.Array(Ed25519SignatureWithPublicKeySchema)
+});
+var CompileTransaction = class extends Effect.Service()("CompileTransaction", {
+	dependencies: [NotaryKeyPair.Default],
+	effect: Effect.gen(function* () {
+		const notaryKeyPair = yield* NotaryKeyPair;
+		const TransactionBuilder$1 = Effect.tryPromise(() => TransactionBuilder.new()).pipe(Effect.catchAll(Effect.orDie));
+		const notarySignToSignature = (hash) => pipe(Convert.Uint8Array.toHexString(hash), HexString.make, notaryKeyPair.signToSignature).pipe(Effect.runPromise);
+		const notarizeTransaction = (input) => Effect.gen(function* () {
+			const builder = yield* TransactionBuilder$1;
+			return yield* Effect.tryPromise({
+				try: () => pipe(builder, (builder$1) => builder$1.header(input.intent.header), (builder$1) => builder$1.message(input.intent.message), (builder$1) => builder$1.manifest(input.intent.manifest), (builder$1) => input.signatures.reduce((builder$2, signature) => builder$2.sign(signature), builder$1), (builder$1) => builder$1.notarizeAsync(notarySignToSignature)),
+				catch: (error) => new FailedToNotarizeTransactionError({ error })
+			});
+		});
+		const compileNotarizedTransaction = (input) => Effect.tryPromise({
+			try: () => RadixEngineToolkit.NotarizedTransaction.compile(input),
+			catch: (error) => new FailedToCompileTransactionError({ error })
+		});
+		return (input) => notarizeTransaction(input).pipe(Effect.flatMap(compileNotarizedTransaction));
+	})
+}) {};
+
+//#endregion
+//#region src/staticallyValidateManifest.ts
+var FailedToStaticallyValidateManifestError = class extends Data.TaggedError("FailedToStaticallyValidateManifestError") {};
+var InvalidManifestError = class extends Data.TaggedError("InvalidManifestError") {};
+var StaticallyValidateManifest = class extends Effect.Service()("StaticallyValidateManifest", { effect: Effect.gen(function* () {
+	return (input) => Effect.gen(function* () {
+		const result = yield* Effect.tryPromise({
+			try: () => RadixEngineToolkit.TransactionManifest.staticallyValidate(input.manifest, input.networkId),
+			catch: (error) => {
+				console.error(error);
+				return new FailedToStaticallyValidateManifestError({ error });
+			}
+		});
+		if (result.kind === "Invalid") return yield* Effect.fail(new InvalidManifestError({ message: result.error }));
+	});
+}) }) {};
+
+//#endregion
+//#region src/epoch.ts
+var InvalidEndEpochError = class extends Data.TaggedError("InvalidEndEpochError") {};
+var InvalidStartEpochError = class extends Data.TaggedError("InvalidStartEpochError") {};
+var EpochService = class extends Effect.Service()("EpochService", {
+	dependencies: [GetLedgerStateService.Default],
+	effect: Effect.gen(function* () {
+		const getLedgerStateService = yield* GetLedgerStateService;
+		const getCurrentEpoch = () => Effect.gen(function* () {
+			return yield* getLedgerStateService({ at_ledger_state: { timestamp: /* @__PURE__ */ new Date() } }).pipe(Effect.map((ledgerState) => Epoch.make(ledgerState.epoch)));
+		});
+		return {
+			getCurrentEpoch,
+			verifyEpochBounds: (input) => Effect.gen(function* () {
+				const currentEpoch = yield* getCurrentEpoch();
+				if (currentEpoch < input.transactionIntent.header.startEpochInclusive) return yield* new InvalidStartEpochError({
+					message: `Current epoch ${currentEpoch} is less than start epoch ${input.transactionIntent.header.startEpochInclusive}`,
+					transactionId: input.transactionId
+				});
+				if (currentEpoch >= input.transactionIntent.header.endEpochExclusive) return yield* new InvalidEndEpochError({
+					message: `Current epoch ${currentEpoch} is greater than or equal to end epoch ${input.transactionIntent.header.endEpochExclusive}`,
+					transactionId: input.transactionId
+				});
+			})
+		};
+	})
+}) {};
+
+//#endregion
+//#region src/transactionHeader.ts
+var InvalidEpochError = class extends Data.TaggedError("InvalidEpochError") {};
+var TransactionHeader = class extends Effect.Service()("TransactionHeader", {
+	dependencies: [
+		GetLedgerStateService.Default,
+		NotaryKeyPair.Default,
+		EpochService.Default
+	],
+	effect: Effect.gen(function* () {
+		const notaryKeyPair = yield* NotaryKeyPair;
+		const epochService = yield* EpochService;
+		const generateNonce = () => pipe(generateRandomNonce(), Nonce.make);
+		return (input) => Effect.gen(function* () {
+			const { tipPercentage = 0, nonce = generateNonce(), notaryIsSignatory = false } = input;
+			const currentEpoch = yield* epochService.getCurrentEpoch();
+			const startEpochInclusive = Option.match(input.startEpochInclusive, {
+				onSome: (epoch) => epoch,
+				onNone: () => currentEpoch
+			});
+			if (currentEpoch < startEpochInclusive) return yield* new InvalidEpochError({ message: `Current epoch ${currentEpoch} is less than start epoch ${input.startEpochInclusive}` });
+			const endEpochExclusive = Option.match(input.endEpochExclusive, {
+				onSome: (epoch) => epoch,
+				onNone: () => Epoch.make(currentEpoch + 2)
+			});
+			if (currentEpoch >= endEpochExclusive) return yield* new InvalidEpochError({ message: `Current epoch ${currentEpoch} is greater than or equal to end epoch ${input.endEpochExclusive}` });
+			const notaryPublicKey = yield* notaryKeyPair.publicKey();
+			return TransactionHeaderSchema.make({
+				networkId: input.networkId,
+				startEpochInclusive,
+				endEpochExclusive,
+				notaryPublicKey,
+				nonce,
+				notaryIsSignatory,
+				tipPercentage
+			});
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/createTransactionIntent.ts
+const CreateTransactionIntentInputSchema = Schema.Struct({
+	startEpochInclusive: Schema.optional(Epoch),
+	endEpochExclusive: Schema.optional(Epoch),
+	manifest: TransactionManifestString,
+	message: Schema.optional(TransactionMessageString),
+	tipPercentage: Schema.optional(Schema.Number)
+});
+var CreateTransactionIntent = class extends Effect.Service()("CreateTransactionIntent", {
+	dependencies: [StaticallyValidateManifest.Default, TransactionHeader.Default],
+	effect: Effect.gen(function* () {
+		const staticallyValidateManifest = yield* StaticallyValidateManifest;
+		const createTransactionHeader = yield* TransactionHeader;
+		const gatewayApiClient = yield* GatewayApiClient;
+		const networkId = NetworkId.make(gatewayApiClient.networkId);
+		return (input) => Effect.gen(function* () {
+			const parsedInput = yield* Schema.decodeUnknown(CreateTransactionIntentInputSchema)(input);
+			const header = yield* createTransactionHeader({
+				networkId,
+				startEpochInclusive: Option.fromNullable(parsedInput.startEpochInclusive),
+				endEpochExclusive: Option.fromNullable(parsedInput.endEpochExclusive)
+			});
+			const message = yield* Schema.decodeUnknown(TransactionMessageSchema)(parsedInput.message);
+			const manifest = yield* Schema.decodeUnknown(ManifestSchema)(parsedInput.manifest);
+			const transactionIntent = {
+				header,
+				message,
+				manifest
+			};
+			yield* staticallyValidateManifest({
+				manifest,
+				networkId
+			});
+			return TransactionIntentSchema.make(transactionIntent);
+		});
+	})
+}) {};
+
+//#endregion
+//#region src/intentHash.ts
+var FailedToCreateIntentHashError = class extends Data.TaggedError("FailedToCreateIntentHashError") {};
+var IntentHashService = class extends Effect.Service()("IntentHashService", { effect: Effect.gen(function* () {
+	const createIntentHash = (input) => Effect.tryPromise({
+		try: () => RadixEngineToolkit.Intent.hash(input),
+		catch: (error) => new FailedToCreateIntentHashError({ error })
+	}).pipe(Effect.map((hash) => ({
+		id: TransactionId.make(hash.id),
+		hash: pipe(Convert.Uint8Array.toHexString(hash.hash), HexString.make)
+	})));
+	return { create: createIntentHash };
+}) }) {};
+
+//#endregion
+//#region src/previewTransaction.ts
+var TransactionPreviewError = class extends Data.TaggedError("TransactionPreviewError") {};
+var PreviewTransaction = class extends Effect.Service()("PreviewTransaction", { effect: Effect.gen(function* () {
+	const gatewayApiClient = yield* GatewayApiClient;
+	return (input) => Effect.gen(function* () {
+		const result = yield* gatewayApiClient.transaction.innerClient.transactionPreview({ transactionPreviewRequest: input.payload });
+		const receipt = result.receipt;
+		if (receipt.status !== "Succeeded") return yield* new TransactionPreviewError({ message: receipt.error_message });
+		return result;
+	});
+}) }) {};
+
+//#endregion
+//#region src/submitTransaction.ts
+var SubmitTransaction = class extends Effect.Service()("SubmitTransaction", { effect: Effect.gen(function* () {
+	const gatewayApiClient = yield* GatewayApiClient;
+	return (input) => Effect.gen(function* () {
+		const notarizedTransactionHex = pipe(input.compiledTransaction, Convert.Uint8Array.toHexString, HexString.make);
+		return yield* gatewayApiClient.transaction.innerClient.transactionSubmit({ transactionSubmitRequest: { notarized_transaction_hex: notarizedTransactionHex } });
+	});
+}) }) {};
+
+//#endregion
+//#region src/transactionStatus.ts
+var TransactionNotResolvedError = class extends Data.TaggedError("TransactionNotResolvedError") {};
+var TransactionFailedError = class extends Data.TaggedError("TransactionFailedError") {};
+var TimeoutError = class extends Data.TaggedError("TimeoutError") {};
+var TransactionStatus = class extends Effect.Service()("TransactionStatus", { effect: Effect.gen(function* () {
+	const pollTimeoutDuration = yield* Config.duration("TRANSACTION_STATUS_POLL_TIMEOUT").pipe(Config.withDefault(Duration.minutes(1)), Effect.orDie);
+	const maxPollAttempts = yield* Config.number("TRANSACTION_STATUS_MAX_POLL_ATTEMPTS_COUNT").pipe(Config.withDefault(10), Effect.orDie);
+	const pollDelay = yield* Config.duration("TRANSACTION_STATUS_POLL_DELAY").pipe(Config.withDefault(Duration.millis(100)), Effect.orDie);
+	const retryPolicy = Schedule.exponential(pollDelay).pipe(Schedule.compose(Schedule.recurs(maxPollAttempts)));
+	const gatewayApiClient = yield* GatewayApiClient;
+	const getTransactionStatus = (id) => Effect.gen(function* () {
+		const result = yield* gatewayApiClient.transaction.innerClient.transactionStatus({ transactionStatusRequest: { intent_hash: id } });
+		const { intent_status } = result;
+		if (intent_status === "CommittedSuccess") return result;
+		if (intent_status === "CommittedFailure" || intent_status === "PermanentlyRejected") return yield* new TransactionFailedError({
+			status: intent_status,
+			statusDescription: result.intent_status_description,
+			message: result.error_message,
+			transactionId: id
+		});
+		return yield* new TransactionNotResolvedError({
+			status: intent_status,
+			statusDescription: result.intent_status_description,
+			message: result.error_message,
+			transactionId: id
+		});
+	});
+	return { poll: (input) => getTransactionStatus(input.id).pipe(Effect.tapErrorTag("TransactionFailedError", Effect.logError), Effect.retry({
+		schedule: input.retryPolicy ?? retryPolicy,
+		while: (error) => error._tag === "TransactionNotResolvedError"
+	}), Effect.timeout(input.timeout ?? pollTimeoutDuration), Effect.catchTags({ TimeoutException: () => new TimeoutError({ transactionId: input.id }) })) };
+}) }) {};
+
+//#endregion
+//#region src/transactionHelper.ts
+var FaucetNotAvailableError = class extends Data.TaggedError("FaucetNotAvailableError") {};
+var TransactionLifeCycleHook = class extends Context.Tag("TransactionLifeCycleHook")() {};
+var InsufficientXrdBalanceError = class extends Data.TaggedError("InsufficientXrdBalanceError") {};
+var TransactionHelper = class extends Effect.Service()("TransactionHelper", {
+	dependencies: [
+		CreateTransactionIntent.Default,
+		CompileTransaction.Default,
+		SubmitTransaction.Default,
+		TransactionStatus.Default,
+		ManifestHelper.Default,
+		IntentHashService.Default,
+		EpochService.Default,
+		GetFungibleBalance.Default,
+		GetLedgerStateService.Default
+	],
+	effect: Effect.gen(function* () {
+		const createTransactionIntent = yield* CreateTransactionIntent;
+		const compileTransaction = yield* CompileTransaction;
+		const submitTransactionToNetwork = yield* SubmitTransaction;
+		const transactionStatus = yield* TransactionStatus;
+		const signer = yield* Signer;
+		const manifestHelper = yield* ManifestHelper;
+		const intentHashService = yield* IntentHashService;
+		const epochService = yield* EpochService;
+		const gatewayApiClient = yield* GatewayApiClient;
+		const getLedgerStateService = yield* GetLedgerStateService;
+		const networkId = NetworkId.make(gatewayApiClient.networkId);
+		const knownAddresses = yield* Effect.tryPromise(() => RadixEngineToolkit.Utils.knownAddresses(networkId));
+		const getFungibleBalance = yield* GetFungibleBalance;
+		const lifeCycleHook = yield* Effect.serviceOption(TransactionLifeCycleHook);
+		const onSubmitLifeCycleHook = lifeCycleHook.pipe(Option.flatMap((item) => Option.fromNullable(item.onSubmit)));
+		const onSubmitSuccessLifeCycleHook = lifeCycleHook.pipe(Option.flatMap((item) => Option.fromNullable(item.onSubmitSuccess)));
+		const onStatusFailureLifeCycleHook = lifeCycleHook.pipe(Option.flatMap((item) => Option.fromNullable(item.onStatusFailure)));
+		const onSuccessLifeCycleHook = lifeCycleHook.pipe(Option.flatMap((item) => Option.fromNullable(item.onSuccess)));
+		const xrdBalance = (account, stateVersion) => getFungibleBalance({
+			addresses: [account.address],
+			at_ledger_state: { state_version: stateVersion }
+		}).pipe(Effect.map(flow(Array.head, Option.map((value) => value.items), Option.flatMap(Array.findFirst((item) => item.resource_address === knownAddresses.resourceAddresses.xrd)))));
+		const submitTransaction = (input) => Effect.gen(function* () {
+			yield* Option.fromNullable(input.feePayer).pipe(Option.match({
+				onNone: () => Effect.void,
+				onSome: (feePayer) => getLedgerStateService({ at_ledger_state: { timestamp: /* @__PURE__ */ new Date() } }).pipe(Effect.flatMap((stateVersion) => xrdBalance(feePayer.account, stateVersion.state_version)), Effect.filterOrFail((amount) => Option.match(amount, {
+					onNone: () => false,
+					onSome: (amount$1) => amount$1.amount.gte(feePayer.amount)
+				}), () => new InsufficientXrdBalanceError({ message: `Insufficient XRD balance for account ${feePayer.account.address}` })))
+			}));
+			const { intent, id, hash } = yield* Option.fromNullable(input.transactionIntent).pipe(Option.match({
+				onNone: () => Effect.gen(function* () {
+					yield* Effect.log("Creating transaction intent");
+					const feePayerInstructions = input.feePayer ? yield* manifestHelper.addFeePayer(input.feePayer) : "";
+					return yield* createTransactionIntent({ manifest: TransactionManifestString.make(`
+                    ${feePayerInstructions}
+                    ${input.manifest}
+                  `) }).pipe(Effect.flatMap((intent$1) => intentHashService.create(intent$1).pipe(Effect.map(({ id: id$1, hash: hash$1 }) => ({
+						id: id$1,
+						hash: hash$1,
+						intent: intent$1
+					})))), Effect.catchTags({
+						ParseError: Effect.die,
+						InvalidEpochError: Effect.die
+					}));
+				}),
+				onSome: (intent$1) => intentHashService.create(intent$1).pipe(Effect.flatMap(({ id: id$1, hash: hash$1 }) => epochService.verifyEpochBounds({
+					transactionId: id$1,
+					transactionIntent: intent$1
+				}).pipe(Effect.as({
+					id: id$1,
+					hash: hash$1,
+					intent: intent$1
+				}))))
+			}));
+			return yield* Effect.gen(function* () {
+				yield* Effect.log("Collecting signatures");
+				const compiledTransaction = yield* compileTransaction({
+					intent,
+					signatures: yield* signer.signToSignatureWithPublicKey(hash)
+				}).pipe(Effect.catchAll(Effect.die));
+				yield* Option.match(onSubmitLifeCycleHook, {
+					onNone: () => Effect.void,
+					onSome: (effect) => Effect.gen(function* () {
+						yield* Effect.log("Executing life cycle hook: onSubmit");
+						yield* effect({
+							id,
+							intent
+						});
+					})
+				});
+				yield* Effect.log("Submitting transaction to network");
+				yield* submitTransactionToNetwork({ compiledTransaction });
+				yield* Option.match(onSubmitSuccessLifeCycleHook, {
+					onNone: () => Effect.void,
+					onSome: (effect) => Effect.gen(function* () {
+						yield* Effect.log("Executing life cycle hook: onSubmitSuccess");
+						yield* effect({
+							id,
+							intent
+						});
+					})
+				});
+				const result = yield* transactionStatus.poll({ id }).pipe(Effect.map((status) => ({
+					statusResponse: status,
+					id
+				})), Effect.catchAllCause((cause) => Effect.gen(function* () {
+					yield* Option.match(onStatusFailureLifeCycleHook, {
+						onNone: () => Effect.void,
+						onSome: (effect) => Effect.gen(function* () {
+							yield* Effect.log("Executing life cycle hook: onFailure");
+							yield* effect({
+								id,
+								permanent: Cause.isFailType(cause) && cause.error._tag === "TransactionFailedError",
+								intent
+							});
+						})
+					});
+					return yield* Effect.failCause(cause);
+				})));
+				yield* Option.match(onSuccessLifeCycleHook, {
+					onNone: () => Effect.void,
+					onSome: (effect) => Effect.gen(function* () {
+						yield* Effect.log("Executing life cycle hook: onSuccess");
+						yield* effect({ id });
+					})
+				});
+				return result;
+			}).pipe(Effect.annotateLogs("transactionId", id));
+		}).pipe(Effect.annotateLogs({
+			networkId,
+			feePayer: input.feePayer?.account.address
+		}));
+		const getCommittedDetails = (input) => gatewayApiClient.transaction.getCommittedDetails(input.id);
+		const createBadge$1 = (input) => submitTransaction({
+			manifest: createBadge(input.account, input.initialSupply),
+			feePayer: {
+				account: input.feePayer,
+				amount: Amount.make("10")
+			}
+		}).pipe(Effect.flatMap(({ id }) => getCommittedDetails({ id })), Effect.map((result) => pipe(Option.fromNullable(result.transaction.balance_changes?.fungible_balance_changes), Option.flatMap(Array.head), Option.flatMap(Record.get("resource_address")), Option.getOrThrow, FungibleResourceAddress.make)));
+		const createFungibleToken = (input) => submitTransaction({
+			manifest: createFungibleTokenManifest(input),
+			feePayer: {
+				account: input.feePayer,
+				amount: Amount.make("10")
+			}
+		}).pipe(Effect.flatMap(({ id }) => getCommittedDetails({ id })), Effect.map((result) => pipe(Option.fromNullable(result.transaction.balance_changes?.fungible_balance_changes), Option.flatMap(Array.head), Option.flatMap(Record.get("resource_address")), Option.getOrThrow, FungibleResourceAddress.make)));
+		const faucet$1 = (input) => Effect.gen(function* () {
+			if (networkId === 1) return yield* new FaucetNotAvailableError({ message: "Faucet is only available on Testnet" }).pipe(Effect.die);
+			return yield* submitTransaction({ manifest: yield* faucet(input.account.address) });
+		});
+		return {
+			submitTransaction,
+			getCommittedDetails,
+			createBadge: createBadge$1,
+			createFungibleToken,
+			faucet: faucet$1
+		};
+	})
+}) {};
+
+//#endregion
+export { CompileTransaction, CreateTransactionIntent, DisableTestClock, EpochService, FailedToCompileTransactionError, FailedToCreateIntentHashError, FailedToNotarizeTransactionError, FailedToSignTransactionError, FailedToStaticallyValidateManifestError, FaucetNotAvailableError, InsufficientXrdBalanceError, IntentHashService, InvalidEndEpochError, InvalidEpochError, InvalidManifestError, InvalidStartEpochError, ManifestHelper, NotaryKeyPair, PreviewTransaction, Signer, StaticallyValidateManifest, SubmitTransaction, TimeoutError, TransactionFailedError, TransactionHeader, TransactionHelper, TransactionLifeCycleHook, TransactionNotResolvedError, TransactionStatus, Vault, addFeePayer, createAccount, createBadge, createFungibleTokenManifest, faucet, schemas_exports as schemas };