@radix-effects/tx-tool 0.0.1

package/dist/chunk-Bp6m_JJh.js

@@ -0,0 +1,13 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+
+//#endregion
+export { __export as t };

package/dist/index.d.ts

@@ -0,0 +1,593 @@
+import { Account, AccountAddress, Amount, Epoch, HexString, NetworkId, Nonce, TransactionId, TransactionManifestString } from "@radix-effects/shared";
+import * as _radixdlt_radix_engine_toolkit1 from "@radixdlt/radix-engine-toolkit";
+import { PublicKey, SignatureWithPublicKey } from "@radixdlt/radix-engine-toolkit";
+import { Cause, Context, Duration, Effect, Layer, Option, ParseResult, Redacted, Schedule, Schema } from "effect";
+import { FileSystem, HttpBody, HttpClient } from "@effect/platform";
+import * as _radix_effects_gateway97 from "@radix-effects/gateway";
+import { GatewayApiClient, GetFungibleBalance, GetLedgerStateService } from "@radix-effects/gateway";
+import * as effect_Brand26 from "effect/Brand";
+import * as effect_Cause13 from "effect/Cause";
+import * as effect_Types13 from "effect/Types";
+import * as effect_ConfigError2 from "effect/ConfigError";
+import * as _effect_platform_HttpClientError0 from "@effect/platform/HttpClientError";
+import * as _effect_platform_Error0 from "@effect/platform/Error";
+import * as effect_Layer0 from "effect/Layer";
+import * as effect_ParseResult0 from "effect/ParseResult";
+import * as _radixdlt_babylon_gateway_api_sdk3 from "@radixdlt/babylon-gateway-api-sdk";
+import { TransactionPreviewOperationRequest, TransactionStatusResponse } from "@radixdlt/babylon-gateway-api-sdk";
+
+//#region src/manifests/addFeePayer.d.ts
+declare const addFeePayer: (input: {
+  account: Account;
+  amount: Amount;
+}) => string & effect_Brand26.Brand<"TransactionManifestString">;
+//#endregion
+//#region src/manifests/createBadge.d.ts
+declare const createBadge: (account: Account, initialSupply?: number) => string & effect_Brand26.Brand<"TransactionManifestString">;
+//#endregion
+//#region src/manifests/createFungibleToken.d.ts
+declare const createFungibleTokenManifest: (input: {
+  name: string;
+  symbol: string;
+  initialSupply: Amount;
+  account: Account;
+}) => string & effect_Brand26.Brand<"TransactionManifestString">;
+//#endregion
+//#region src/manifests/faucet.d.ts
+declare const faucet: (accountAddress: AccountAddress) => Effect.Effect<string & effect_Brand26.Brand<"TransactionManifestString">, effect_Cause13.UnknownException, never>;
+//#endregion
+//#region src/manifests/manifestHelper.d.ts
+declare const ManifestHelper_base: Effect.Service.Class<ManifestHelper, "ManifestHelper", {
+  readonly effect: Effect.Effect<{
+    addFeePayer: (input: {
+      account: Account;
+      amount: Amount;
+    }) => Effect.Effect<string & effect_Brand26.Brand<"TransactionManifestString">, never, never>;
+  }, never, never>;
+}>;
+declare class ManifestHelper extends ManifestHelper_base {}
+declare namespace schemas_d_exports {
+  export { Badge, BadgeDecodedSchema, BadgeSchema, Base64FromHexSchema, Ed25519PrivateKey, Ed25519PrivateKeySchema, Ed25519PublicKey, Ed25519PublicKeySchema, Ed25519SignatureWithPublicKey, Ed25519SignatureWithPublicKeyEncoded, Ed25519SignatureWithPublicKeySchema, HexFromBase64Schema, Manifest, ManifestEncoded, ManifestSchema, TransactionHeader$1 as TransactionHeader, TransactionHeaderSchema, TransactionIntent, TransactionIntentEncoded, TransactionIntentSchema, TransactionMessage, TransactionMessageSchema };
+}
+declare const Base64FromHexSchema: Schema.Schema<string & effect_Brand26.Brand<"Base64String">, string, never>;
+declare const HexFromBase64Schema: Schema.Schema<string & effect_Brand26.Brand<"HexString">, string, never>;
+declare const Ed25519PublicKeySchema: Schema.Schema<{
+  readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+  readonly bytes: Uint8Array;
+  rawBytes: () => Uint8Array;
+  hexString: () => string;
+  toString: () => string;
+  hex: () => string;
+  readonly publicKey: Uint8Array;
+}, string, never>;
+type Ed25519PublicKey = typeof Ed25519PublicKeySchema.Type;
+declare const Ed25519PrivateKeySchema: Schema.Schema<{
+  readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+  readonly bytes: Uint8Array;
+  publicKey(): PublicKey;
+  publicKeyBytes(): Uint8Array;
+  publicKeyHex(): string;
+  sign(messageHash: Uint8Array): Uint8Array;
+  signToSignature(messageHash: Uint8Array): _radixdlt_radix_engine_toolkit1.Signature;
+  signToSignatureWithPublicKey(messageHash: Uint8Array): SignatureWithPublicKey;
+  produceSignature(messageHash: Uint8Array): _radixdlt_radix_engine_toolkit1.SignerResponse;
+}, string, never>;
+type Ed25519PrivateKey = typeof Ed25519PrivateKeySchema.Type;
+declare const ManifestSchema: Schema.Schema<{
+  readonly instructions: {
+    readonly value: string & effect_Brand26.Brand<"TransactionManifestString">;
+    readonly kind: "String";
+  };
+  readonly blobs: Uint8Array<ArrayBufferLike>[];
+}, string, never>;
+type Manifest = typeof ManifestSchema.Type;
+type ManifestEncoded = TransactionManifestString;
+declare const TransactionMessageSchema: Schema.Schema<{
+  readonly value: {
+    readonly message: {
+      readonly value: string & effect_Brand26.Brand<"TransactionMessageString">;
+      readonly kind: "String";
+    };
+    readonly mimeType: "text/plain";
+  };
+  readonly kind: "PlainText";
+} | {
+  readonly kind: "None";
+}, string | undefined, never>;
+type TransactionMessage = typeof TransactionMessageSchema.Type;
+declare const TransactionHeaderSchema: Schema.Struct<{
+  networkId: Schema.brand<typeof Schema.Number, "NetworkId">;
+  startEpochInclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+  endEpochExclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+  notaryPublicKey: Schema.Schema<{
+    readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+    readonly bytes: Uint8Array;
+    rawBytes: () => Uint8Array;
+    hexString: () => string;
+    toString: () => string;
+    hex: () => string;
+    readonly publicKey: Uint8Array;
+  }, string, never>;
+  nonce: Schema.brand<typeof Schema.Number, "Nonce">;
+  notaryIsSignatory: typeof Schema.Boolean;
+  tipPercentage: typeof Schema.Number;
+}>;
+type TransactionHeader$1 = typeof TransactionHeaderSchema.Type;
+declare const TransactionIntentSchema: Schema.Struct<{
+  header: Schema.Struct<{
+    networkId: Schema.brand<typeof Schema.Number, "NetworkId">;
+    startEpochInclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+    endEpochExclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+    notaryPublicKey: Schema.Schema<{
+      readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+      readonly bytes: Uint8Array;
+      rawBytes: () => Uint8Array;
+      hexString: () => string;
+      toString: () => string;
+      hex: () => string;
+      readonly publicKey: Uint8Array;
+    }, string, never>;
+    nonce: Schema.brand<typeof Schema.Number, "Nonce">;
+    notaryIsSignatory: typeof Schema.Boolean;
+    tipPercentage: typeof Schema.Number;
+  }>;
+  message: Schema.Schema<{
+    readonly value: {
+      readonly message: {
+        readonly value: string & effect_Brand26.Brand<"TransactionMessageString">;
+        readonly kind: "String";
+      };
+      readonly mimeType: "text/plain";
+    };
+    readonly kind: "PlainText";
+  } | {
+    readonly kind: "None";
+  }, string | undefined, never>;
+  manifest: Schema.Schema<{
+    readonly instructions: {
+      readonly value: string & effect_Brand26.Brand<"TransactionManifestString">;
+      readonly kind: "String";
+    };
+    readonly blobs: Uint8Array<ArrayBufferLike>[];
+  }, string, never>;
+}>;
+type TransactionIntent = typeof TransactionIntentSchema.Type;
+type TransactionIntentEncoded = typeof TransactionIntentSchema.Encoded;
+declare const Ed25519SignatureWithPublicKeySchema: Schema.Schema<{
+  readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+  readonly signature: Uint8Array;
+  readonly publicKey: Uint8Array;
+}, {
+  readonly signature: string;
+  readonly signerPublicKey: string;
+  readonly curve: "Ed25519";
+}, never>;
+type Ed25519SignatureWithPublicKey = typeof Ed25519SignatureWithPublicKeySchema.Type;
+type Ed25519SignatureWithPublicKeyEncoded = typeof Ed25519SignatureWithPublicKeySchema.Encoded;
+declare const BadgeDecodedSchema: Schema.Struct<{
+  type: Schema.Literal<["fungibleResource"]>;
+  resourceAddress: Schema.brand<typeof Schema.String, "FungibleResourceAddress">;
+}>;
+declare const BadgeSchema: Schema.transformOrFail<Schema.Struct<{
+  type: typeof Schema.String;
+  resourceAddress: typeof Schema.String;
+}>, Schema.Struct<{
+  type: Schema.Literal<["fungibleResource"]>;
+  resourceAddress: Schema.brand<typeof Schema.String, "FungibleResourceAddress">;
+}>, never>;
+type Badge = typeof BadgeSchema.Type;
+//#endregion
+//#region src/signer/signer.d.ts
+declare const FailedToSignTransactionError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "FailedToSignTransactionError";
+} & Readonly<A>;
+declare class FailedToSignTransactionError extends FailedToSignTransactionError_base<{
+  error: unknown;
+}> {}
+declare const Signer_base: Context.TagClass<Signer, "Signer", {
+  signToSignatureWithPublicKey: (hash: HexString) => Effect.Effect<Ed25519SignatureWithPublicKey[], FailedToSignTransactionError, never>;
+  publicKey: () => Effect.Effect<PublicKey, never, never>;
+}>;
+declare class Signer extends Signer_base {
+  static VaultLive: Layer.Layer<Signer, effect_ConfigError2.ConfigError, never>;
+  static makePrivateKeySigner: (privateKey: Redacted.Redacted<HexString>) => Layer.Layer<Signer, never, never>;
+}
+//#endregion
+//#region src/signer/vault.d.ts
+declare const Vault_base: Effect.Service.Class<Vault, "Vault", {
+  readonly dependencies: readonly [Layer.Layer<HttpClient.HttpClient, never, never>, Layer.Layer<FileSystem.FileSystem, never, never>];
+  readonly effect: Effect.Effect<{
+    getPublicKey: () => Effect.Effect<string & effect_Brand26.Brand<"HexString">, never, never>;
+    toSignatureWithPublicKey: (hash: HexString) => Effect.Effect<{
+      readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+      readonly signature: Uint8Array;
+      readonly publicKey: Uint8Array;
+    }, effect_ConfigError2.ConfigError | ParseResult.ParseError | _effect_platform_HttpClientError0.HttpClientError | _effect_platform_Error0.PlatformError | HttpBody.HttpBodyError, never>;
+  }, effect_ConfigError2.ConfigError, HttpClient.HttpClient | FileSystem.FileSystem>;
+}>;
+declare class Vault extends Vault_base {}
+//#endregion
+//#region src/test-helpers/createAccount.d.ts
+declare const createAccount: (input?: Partial<{
+  privateKey: Uint8Array;
+  networkId: number;
+}>) => Effect.Effect<{
+  address: any;
+  sign: (hash: string) => string;
+  publicKeyHex: string;
+  privateKeyHex: string;
+}, effect_Cause13.UnknownException, never>;
+//#endregion
+//#region src/test-helpers/disableTestClock.d.ts
+declare const DisableTestClock: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+//#endregion
+//#region src/notaryKeyPair.d.ts
+declare const NotaryKeyPair_base: Effect.Service.Class<NotaryKeyPair, "NotaryKeyPair", {
+  readonly effect: Effect.Effect<{
+    publicKey: () => Effect.Effect<_radixdlt_radix_engine_toolkit1.PublicKey, never, never>;
+    signToSignature: (hash: HexString) => Effect.Effect<{
+      readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+      readonly bytes: Uint8Array;
+      rawBytes: () => Uint8Array;
+      hexString: () => string;
+      toString: () => string;
+      hex: () => string;
+      readonly signature: Uint8Array;
+    }, FailedToSignTransactionError, never>;
+  }, never, Signer>;
+}>;
+declare class NotaryKeyPair extends NotaryKeyPair_base {}
+//#endregion
+//#region src/compileTransaction.d.ts
+declare const FailedToCompileTransactionError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "FailedToCompileTransactionError";
+} & Readonly<A>;
+declare class FailedToCompileTransactionError extends FailedToCompileTransactionError_base<{
+  error: unknown;
+}> {}
+declare const FailedToNotarizeTransactionError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "FailedToNotarizeTransactionError";
+} & Readonly<A>;
+declare class FailedToNotarizeTransactionError extends FailedToNotarizeTransactionError_base<{
+  error: unknown;
+}> {}
+declare const CompileTransactionInputSchema: Schema.Struct<{
+  intent: Schema.Struct<{
+    header: Schema.Struct<{
+      networkId: Schema.brand<typeof Schema.Number, "NetworkId">;
+      startEpochInclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+      endEpochExclusive: Schema.brand<typeof Schema.Number, "Epoch">;
+      notaryPublicKey: Schema.Schema<{
+        readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+        readonly bytes: Uint8Array;
+        rawBytes: () => Uint8Array;
+        hexString: () => string;
+        toString: () => string;
+        hex: () => string;
+        readonly publicKey: Uint8Array;
+      }, string, never>;
+      nonce: Schema.brand<typeof Schema.Number, "Nonce">;
+      notaryIsSignatory: typeof Schema.Boolean;
+      tipPercentage: typeof Schema.Number;
+    }>;
+    message: Schema.Schema<{
+      readonly value: {
+        readonly message: {
+          readonly value: string & effect_Brand26.Brand<"TransactionMessageString">;
+          readonly kind: "String";
+        };
+        readonly mimeType: "text/plain";
+      };
+      readonly kind: "PlainText";
+    } | {
+      readonly kind: "None";
+    }, string | undefined, never>;
+    manifest: Schema.Schema<{
+      readonly instructions: {
+        readonly value: string & effect_Brand26.Brand<"TransactionManifestString">;
+        readonly kind: "String";
+      };
+      readonly blobs: Uint8Array<ArrayBufferLike>[];
+    }, string, never>;
+  }>;
+  signatures: Schema.Array$<Schema.Schema<{
+    readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+    readonly signature: Uint8Array;
+    readonly publicKey: Uint8Array;
+  }, {
+    readonly signature: string;
+    readonly signerPublicKey: string;
+    readonly curve: "Ed25519";
+  }, never>>;
+}>;
+type CompileTransactionInput = typeof CompileTransactionInputSchema.Type;
+declare const CompileTransaction_base: Effect.Service.Class<CompileTransaction, "CompileTransaction", {
+  readonly dependencies: readonly [effect_Layer0.Layer<NotaryKeyPair, never, Signer>];
+  readonly effect: Effect.Effect<(input: CompileTransactionInput) => Effect.Effect<Uint8Array<ArrayBufferLike>, FailedToCompileTransactionError | FailedToNotarizeTransactionError, never>, never, NotaryKeyPair>;
+}>;
+declare class CompileTransaction extends CompileTransaction_base {}
+//#endregion
+//#region src/epoch.d.ts
+declare const InvalidEndEpochError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "InvalidEndEpochError";
+} & Readonly<A>;
+declare class InvalidEndEpochError extends InvalidEndEpochError_base<{
+  message: string;
+  transactionId: TransactionId;
+}> {}
+declare const InvalidStartEpochError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "InvalidStartEpochError";
+} & Readonly<A>;
+declare class InvalidStartEpochError extends InvalidStartEpochError_base<{
+  message: string;
+  transactionId: TransactionId;
+}> {}
+declare const EpochService_base: Effect.Service.Class<EpochService, "EpochService", {
+  readonly dependencies: readonly [effect_Layer0.Layer<GetLedgerStateService, never, _radix_effects_gateway97.GatewayApiClient>];
+  readonly effect: Effect.Effect<{
+    getCurrentEpoch: () => Effect.Effect<number & effect_Brand26.Brand<"Epoch">, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError, never>;
+    verifyEpochBounds: (input: {
+      transactionId: TransactionId;
+      transactionIntent: TransactionIntent;
+    }) => Effect.Effect<undefined, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InvalidStartEpochError | InvalidEndEpochError, never>;
+  }, never, GetLedgerStateService>;
+}>;
+declare class EpochService extends EpochService_base {}
+//#endregion
+//#region src/transactionHeader.d.ts
+declare const InvalidEpochError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "InvalidEpochError";
+} & Readonly<A>;
+declare class InvalidEpochError extends InvalidEpochError_base<{
+  message: string;
+}> {}
+type CreateTransactionHeaderInput = {
+  networkId: NetworkId;
+  startEpochInclusive: Option.Option<Epoch>;
+  endEpochExclusive: Option.Option<Epoch>;
+  tipPercentage?: number;
+  nonce?: Nonce;
+  notaryIsSignatory?: boolean;
+};
+declare const TransactionHeader_base: Effect.Service.Class<TransactionHeader, "TransactionHeader", {
+  readonly dependencies: readonly [effect_Layer0.Layer<GetLedgerStateService, never, _radix_effects_gateway97.GatewayApiClient>, effect_Layer0.Layer<NotaryKeyPair, never, Signer>, effect_Layer0.Layer<EpochService, never, _radix_effects_gateway97.GatewayApiClient>];
+  readonly effect: Effect.Effect<(input: CreateTransactionHeaderInput) => Effect.Effect<{
+    readonly networkId: number & effect_Brand26.Brand<"NetworkId">;
+    readonly startEpochInclusive: number & effect_Brand26.Brand<"Epoch">;
+    readonly endEpochExclusive: number & effect_Brand26.Brand<"Epoch">;
+    readonly notaryPublicKey: {
+      readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+      readonly bytes: Uint8Array;
+      rawBytes: () => Uint8Array;
+      hexString: () => string;
+      toString: () => string;
+      hex: () => string;
+      readonly publicKey: Uint8Array;
+    };
+    readonly nonce: number & effect_Brand26.Brand<"Nonce">;
+    readonly notaryIsSignatory: boolean;
+    readonly tipPercentage: number;
+  }, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InvalidEpochError, never>, never, NotaryKeyPair | EpochService>;
+}>;
+declare class TransactionHeader extends TransactionHeader_base {}
+//#endregion
+//#region src/staticallyValidateManifest.d.ts
+declare const FailedToStaticallyValidateManifestError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "FailedToStaticallyValidateManifestError";
+} & Readonly<A>;
+declare class FailedToStaticallyValidateManifestError extends FailedToStaticallyValidateManifestError_base<{
+  error: unknown;
+}> {}
+declare const InvalidManifestError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "InvalidManifestError";
+} & Readonly<A>;
+declare class InvalidManifestError extends InvalidManifestError_base<{
+  message: string;
+}> {}
+declare const StaticallyValidateManifest_base: Effect.Service.Class<StaticallyValidateManifest, "StaticallyValidateManifest", {
+  readonly effect: Effect.Effect<(input: {
+    manifest: Manifest;
+    networkId: NetworkId;
+  }) => Effect.Effect<undefined, InvalidManifestError | FailedToStaticallyValidateManifestError, never>, never, never>;
+}>;
+declare class StaticallyValidateManifest extends StaticallyValidateManifest_base {}
+//#endregion
+//#region src/createTransactionIntent.d.ts
+declare const CreateTransactionIntentInputSchema: Schema.Struct<{
+  startEpochInclusive: Schema.optional<Schema.brand<typeof Schema.Number, "Epoch">>;
+  endEpochExclusive: Schema.optional<Schema.brand<typeof Schema.Number, "Epoch">>;
+  manifest: Schema.brand<typeof Schema.String, "TransactionManifestString">;
+  message: Schema.optional<Schema.brand<typeof Schema.String, "TransactionMessageString">>;
+  tipPercentage: Schema.optional<typeof Schema.Number>;
+}>;
+type CreateTransactionIntentInput = typeof CreateTransactionIntentInputSchema.Type;
+declare const CreateTransactionIntent_base: Effect.Service.Class<CreateTransactionIntent, "CreateTransactionIntent", {
+  readonly dependencies: readonly [effect_Layer0.Layer<StaticallyValidateManifest, never, never>, effect_Layer0.Layer<TransactionHeader, never, Signer | GatewayApiClient>];
+  readonly effect: Effect.Effect<(input: CreateTransactionIntentInput) => Effect.Effect<{
+    readonly message: {
+      readonly value: {
+        readonly message: {
+          readonly value: string & effect_Brand26.Brand<"TransactionMessageString">;
+          readonly kind: "String";
+        };
+        readonly mimeType: "text/plain";
+      };
+      readonly kind: "PlainText";
+    } | {
+      readonly kind: "None";
+    };
+    readonly header: {
+      readonly networkId: number & effect_Brand26.Brand<"NetworkId">;
+      readonly startEpochInclusive: number & effect_Brand26.Brand<"Epoch">;
+      readonly endEpochExclusive: number & effect_Brand26.Brand<"Epoch">;
+      readonly notaryPublicKey: {
+        readonly curve: _radixdlt_radix_engine_toolkit1.Curve;
+        readonly bytes: Uint8Array;
+        rawBytes: () => Uint8Array;
+        hexString: () => string;
+        toString: () => string;
+        hex: () => string;
+        readonly publicKey: Uint8Array;
+      };
+      readonly nonce: number & effect_Brand26.Brand<"Nonce">;
+      readonly notaryIsSignatory: boolean;
+      readonly tipPercentage: number;
+    };
+    readonly manifest: {
+      readonly instructions: {
+        readonly value: string & effect_Brand26.Brand<"TransactionManifestString">;
+        readonly kind: "String";
+      };
+      readonly blobs: Uint8Array<ArrayBufferLike>[];
+    };
+  }, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InvalidEpochError | effect_ParseResult0.ParseError | InvalidManifestError | FailedToStaticallyValidateManifestError, never>, never, GatewayApiClient | TransactionHeader | StaticallyValidateManifest>;
+}>;
+declare class CreateTransactionIntent extends CreateTransactionIntent_base {}
+//#endregion
+//#region src/intentHash.d.ts
+declare const FailedToCreateIntentHashError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "FailedToCreateIntentHashError";
+} & Readonly<A>;
+declare class FailedToCreateIntentHashError extends FailedToCreateIntentHashError_base<{
+  error: unknown;
+}> {}
+declare const IntentHashService_base: Effect.Service.Class<IntentHashService, "IntentHashService", {
+  readonly effect: Effect.Effect<{
+    create: (input: TransactionIntent) => Effect.Effect<{
+      id: string & effect_Brand26.Brand<"TransactionId">;
+      hash: string & effect_Brand26.Brand<"HexString">;
+    }, FailedToCreateIntentHashError, never>;
+  }, never, never>;
+}>;
+declare class IntentHashService extends IntentHashService_base {}
+//#endregion
+//#region src/previewTransaction.d.ts
+declare const TransactionPreviewError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "TransactionPreviewError";
+} & Readonly<A>;
+declare class TransactionPreviewError extends TransactionPreviewError_base<{
+  message?: string;
+}> {}
+declare const PreviewTransaction_base: Effect.Service.Class<PreviewTransaction, "PreviewTransaction", {
+  readonly effect: Effect.Effect<(input: {
+    payload: TransactionPreviewOperationRequest["transactionPreviewRequest"];
+  }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk3.TransactionPreviewResponse, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | TransactionPreviewError, never>, never, GatewayApiClient>;
+}>;
+declare class PreviewTransaction extends PreviewTransaction_base {}
+//#endregion
+//#region src/submitTransaction.d.ts
+declare const SubmitTransaction_base: Effect.Service.Class<SubmitTransaction, "SubmitTransaction", {
+  readonly effect: Effect.Effect<(input: {
+    compiledTransaction: Uint8Array<ArrayBufferLike>;
+  }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk3.TransactionSubmitResponse, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError, never>, never, GatewayApiClient>;
+}>;
+declare class SubmitTransaction extends SubmitTransaction_base {}
+//#endregion
+//#region src/transactionStatus.d.ts
+declare const TransactionNotResolvedError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "TransactionNotResolvedError";
+} & Readonly<A>;
+declare class TransactionNotResolvedError extends TransactionNotResolvedError_base<{
+  status: TransactionStatusResponse['intent_status'];
+  statusDescription: string;
+  message: null | undefined | string;
+  transactionId: TransactionId;
+}> {}
+declare const TransactionFailedError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "TransactionFailedError";
+} & Readonly<A>;
+declare class TransactionFailedError extends TransactionFailedError_base<{
+  status: TransactionStatusResponse['intent_status'];
+  statusDescription: string;
+  message: null | undefined | string;
+  transactionId: TransactionId;
+}> {}
+declare const TimeoutError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause13.YieldableError & {
+  readonly _tag: "TimeoutError";
+} & Readonly<A>;
+declare class TimeoutError extends TimeoutError_base<{
+  transactionId: TransactionId;
+}> {}
+declare const TransactionStatus_base: Effect.Service.Class<TransactionStatus, "TransactionStatus", {
+  readonly effect: Effect.Effect<{
+    poll: (input: {
+      id: TransactionId;
+      retryPolicy?: Schedule.Schedule<number, unknown, never>;
+      timeout?: Duration.Duration;
+    }) => Effect.Effect<TransactionStatusResponse, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | TransactionFailedError | TransactionNotResolvedError | TimeoutError, never>;
+  }, never, GatewayApiClient>;
+}>;
+declare class TransactionStatus extends TransactionStatus_base {}
+//#endregion
+//#region src/transactionHelper.d.ts
+declare const FaucetNotAvailableError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "FaucetNotAvailableError";
+} & Readonly<A>;
+declare class FaucetNotAvailableError extends FaucetNotAvailableError_base<{
+  message: string;
+}> {}
+declare const TransactionLifeCycleHook_base: Context.TagClass<TransactionLifeCycleHook, "TransactionLifeCycleHook", {
+  onSubmit?: (input: {
+    id: TransactionId;
+    intent: TransactionIntent;
+  }) => Effect.Effect<void, never, never>;
+  onSubmitSuccess?: (input: {
+    id: TransactionId;
+    intent: TransactionIntent;
+  }) => Effect.Effect<void, never, never>;
+  onStatusFailure?: (input: {
+    id: TransactionId;
+    permanent: boolean;
+    intent: TransactionIntent;
+  }) => Effect.Effect<void, never, never>;
+  onSuccess?: (input: {
+    id: TransactionId;
+  }) => Effect.Effect<void, never, never>;
+}>;
+declare class TransactionLifeCycleHook extends TransactionLifeCycleHook_base {}
+declare const InsufficientXrdBalanceError_base: new <A extends Record<string, any> = {}>(args: effect_Types13.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => Cause.YieldableError & {
+  readonly _tag: "InsufficientXrdBalanceError";
+} & Readonly<A>;
+declare class InsufficientXrdBalanceError extends InsufficientXrdBalanceError_base<{
+  message: string;
+}> {}
+declare const TransactionHelper_base: Effect.Service.Class<TransactionHelper, "TransactionHelper", {
+  readonly dependencies: readonly [effect_Layer0.Layer<CreateTransactionIntent, never, Signer | GatewayApiClient>, effect_Layer0.Layer<CompileTransaction, never, Signer>, effect_Layer0.Layer<SubmitTransaction, never, GatewayApiClient>, effect_Layer0.Layer<TransactionStatus, never, GatewayApiClient>, effect_Layer0.Layer<ManifestHelper, never, never>, effect_Layer0.Layer<IntentHashService, never, never>, effect_Layer0.Layer<EpochService, never, GatewayApiClient>, effect_Layer0.Layer<GetFungibleBalance, effect_ConfigError2.ConfigError, GatewayApiClient>, effect_Layer0.Layer<GetLedgerStateService, never, GatewayApiClient>];
+  readonly effect: Effect.Effect<{
+    submitTransaction: (input: {
+      manifest: TransactionManifestString;
+      feePayer?: {
+        account: Account;
+        amount: Amount;
+      };
+      transactionIntent?: TransactionIntent;
+    }) => Effect.Effect<{
+      statusResponse: _radixdlt_babylon_gateway_api_sdk3.TransactionStatusResponse;
+      id: string & effect_Brand26.Brand<"TransactionId">;
+    }, FailedToSignTransactionError | _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InsufficientXrdBalanceError | InvalidManifestError | FailedToStaticallyValidateManifestError | FailedToCreateIntentHashError | InvalidStartEpochError | InvalidEndEpochError | TransactionFailedError | TransactionNotResolvedError | TimeoutError, never>;
+    getCommittedDetails: (input: {
+      id: TransactionId;
+    }) => Effect.Effect<_radixdlt_babylon_gateway_api_sdk3.TransactionCommittedDetailsResponse, _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError, never>;
+    createBadge: (input: {
+      account: Account;
+      feePayer: Account;
+      initialSupply?: number;
+    }) => Effect.Effect<string & effect_Brand26.Brand<"FungibleResourceAddress">, FailedToSignTransactionError | _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InsufficientXrdBalanceError | InvalidManifestError | FailedToStaticallyValidateManifestError | FailedToCreateIntentHashError | InvalidStartEpochError | InvalidEndEpochError | TransactionFailedError | TransactionNotResolvedError | TimeoutError, never>;
+    createFungibleToken: (input: {
+      account: Account;
+      feePayer: Account;
+      name: string;
+      symbol: string;
+      initialSupply: Amount;
+    }) => Effect.Effect<string & effect_Brand26.Brand<"FungibleResourceAddress">, FailedToSignTransactionError | _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InsufficientXrdBalanceError | InvalidManifestError | FailedToStaticallyValidateManifestError | FailedToCreateIntentHashError | InvalidStartEpochError | InvalidEndEpochError | TransactionFailedError | TransactionNotResolvedError | TimeoutError, never>;
+    faucet: (input: {
+      account: Account;
+    }) => Effect.Effect<{
+      statusResponse: _radixdlt_babylon_gateway_api_sdk3.TransactionStatusResponse;
+      id: string & effect_Brand26.Brand<"TransactionId">;
+    }, FailedToSignTransactionError | Cause.UnknownException | _radix_effects_gateway97.AccountLockerNotFoundError | _radix_effects_gateway97.InvalidRequestError | _radix_effects_gateway97.EntityNotFoundError | _radix_effects_gateway97.InternalServerError | _radix_effects_gateway97.InvalidEntityError | _radix_effects_gateway97.InvalidTransactionError | _radix_effects_gateway97.NotSyncedUpError | _radix_effects_gateway97.TransactionNotFoundError | _radix_effects_gateway97.ErrorResponse | _radix_effects_gateway97.RateLimitExceededError | _radix_effects_gateway97.ResponseError | _radix_effects_gateway97.UnknownGatewayError | InsufficientXrdBalanceError | InvalidManifestError | FailedToStaticallyValidateManifestError | FailedToCreateIntentHashError | InvalidStartEpochError | InvalidEndEpochError | TransactionFailedError | TransactionNotResolvedError | TimeoutError, never>;
+  }, Cause.UnknownException, CompileTransaction | Signer | SubmitTransaction | GatewayApiClient | GetLedgerStateService | EpochService | CreateTransactionIntent | TransactionStatus | ManifestHelper | IntentHashService | GetFungibleBalance>;
+}>;
+declare class TransactionHelper extends TransactionHelper_base {}
+//#endregion
+export { CompileTransaction, CreateTransactionHeaderInput, 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_d_exports as schemas };