@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/modules-cardano-UeXks3sd.cjs

@@ -0,0 +1,1109 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_SodiumBip32Ed25519 = require("./SodiumBip32Ed25519-BaD-kjyx.cjs");
+const require_ChainId = require("./ChainId-CNPSU9nn.cjs");
+const require_PaymentAddress = require("./PaymentAddress-B4n1KZMx.cjs");
+const require_slice = require("./slice-DLflttAu.cjs");
+const require_types = require("./types-Cn6WlQV6.cjs");
+const require_InMemoryKeyAgent = require("./InMemoryKeyAgent-Bc_xZY-v.cjs");
+const require_sdk = require("./sdk-1SRu8Ype.cjs");
+const require__md = require("./_md-6zV2Cme0.cjs");
+const require_util = require("./util-D1YlKzrc.cjs");
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_guarded_transaction_signer = require("./guarded-transaction-signer-DTLjAkif.cjs");
+const require_asyncoption = require("./asyncoption-CYcZNBRM.cjs");
+const require_key_source = require("./key-source-D2tTAag-.cjs");
+const require_sha2 = require("./sha2-DaRJZOjk.cjs");
+const require_store = require("./store-C7AneHEY.cjs");
+const require_in_memory_wallet_integration = require("./in-memory-wallet-integration-DsFm8gLk.cjs");
+const require_cardano_tx_id_vo = require("./cardano-tx-id.vo-lnyO9XaW.cjs");
+const require_const = require("./const-D3mCkwrM.cjs");
+const require_TransactionBuilder = require("./TransactionBuilder-BakTJvsJ.cjs");
+const require_composite_signer_factory = require("./composite-signer-factory-v4Pxn8bA.cjs");
+const require_contract = require("./contract-DD6CGnpB.cjs");
+let rxjs = require("rxjs");
+let ts_log = require("ts-log");
+//#region src/cardano-lazy-in-memory-signer-factory.ts
+/**
+* Signer factory for {@link WalletType.LazyInMemory} Cardano accounts.
+*
+* The mnemonic is never persisted by Lace. Its derived account key must match
+* the selected account before signing, regardless of the mnemonic source.
+*/
+var CardanoLazyInMemorySignerFactory = class {
+	#withMnemonicWords;
+	constructor(props) {
+		this.#withMnemonicWords = props.withMnemonicWords;
+	}
+	canSign(account) {
+		return account.accountType === "LazyInMemory" && account.blockchainName === "Cardano";
+	}
+	createTransactionSigner(context) {
+		this.#assertSupported(context);
+		const { knownAddresses, utxo, auth } = context;
+		const accountProps = this.#extractAccountProps(context);
+		return require_guarded_transaction_signer.withCollateralOwnershipGuard(new require_guarded_transaction_signer.CardanoInMemoryTransactionSigner({
+			withKeyAgent$: this.#buildWithKeyAgent$(accountProps),
+			knownAddresses,
+			utxo,
+			auth
+		}), context);
+	}
+	createDataSigner(context) {
+		this.#assertSupported(context);
+		const { knownAddresses, auth } = context;
+		const accountProps = this.#extractAccountProps(context);
+		return new require_guarded_transaction_signer.CardanoInMemoryDataSigner({
+			withKeyAgent$: this.#buildWithKeyAgent$(accountProps),
+			dRepKeyHash$: (0, rxjs.defer)(() => (0, rxjs.from)(require_guarded_transaction_signer.deriveDRepKeyHash(accountProps))),
+			knownAddresses,
+			auth
+		});
+	}
+	#buildWithKeyAgent$(accountProps) {
+		return (use) => new rxjs.Observable((subscriber) => {
+			const cancelled$ = new rxjs.Subject();
+			const assertActive = () => {
+				if (subscriber.closed) throw new Error("Signing request cancelled.");
+			};
+			this.#withMnemonicWords(async (words) => {
+				assertActive();
+				const mnemonicWords = [...words];
+				const keyAgent = await require_guarded_transaction_signer.createCardanoKeyAgentFromMnemonic({
+					accountIndex: accountProps.accountIndex,
+					chainId: accountProps.chainId,
+					mnemonicWords
+				});
+				try {
+					assertActive();
+					if (keyAgent.extendedAccountPublicKey !== accountProps.extendedAccountPublicKey) throw new require_contract.LazyWalletMismatchError();
+					return await (0, rxjs.lastValueFrom)(use(keyAgent).pipe((0, rxjs.takeUntil)(cancelled$)));
+				} finally {
+					keyAgent.dispose?.();
+				}
+			}).then((result) => {
+				if (!subscriber.closed) {
+					subscriber.next(result);
+					subscriber.complete();
+				}
+			}, (error) => {
+				if (!subscriber.closed) subscriber.error(error);
+			});
+			return () => {
+				cancelled$.next();
+				cancelled$.complete();
+			};
+		});
+	}
+	#assertSupported(context) {
+		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
+		if (!account || !this.canSign(account)) throw new Error(`CardanoLazyInMemorySignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
+	}
+	#extractAccountProps(context) {
+		const { wallet, accountId } = context;
+		const account = wallet.accounts.find((a) => a.accountId === accountId);
+		if (!account) throw new Error(`Account ${accountId} not found in wallet`);
+		if (account.blockchainName !== "Cardano") throw new Error(`Account ${accountId} is not a Cardano account`);
+		const { accountIndex, chainId, extendedAccountPublicKey } = account.blockchainSpecific;
+		return {
+			accountIndex,
+			chainId,
+			extendedAccountPublicKey
+		};
+	}
+};
+//#endregion
+//#region src/create-lazy-in-memory-vault-module.ts
+/**
+* Builds a vault module that signs for {@link WalletType.LazyInMemory}
+* Cardano accounts by asking `withMnemonicWords` for the recovery words at
+* each signature. The words must derive the account's stored key, or signing
+* fails with `LazyWalletMismatchError`.
+*
+* Pass the returned module to `createLaceWallet({ modules: [...] })`. Only the
+* `signer-factory-addon` contract is implemented — `vaultContract` is
+* intentionally omitted because the SDK has no encrypted vault to expose to
+* features such as account management or password verification.
+*
+* @param props - The source of the recovery words.
+* @returns A module for the `modules` array of `createLaceWallet`.
+*/
+const createLazyInMemoryVaultModule = (props) => {
+	const signerFactory = new CardanoLazyInMemorySignerFactory(props);
+	const implementsContracts = require_store.combineContracts([require_sdk.signerFactoryAddonContract]);
+	return require_store.inferModuleContext({
+		moduleName: require_sdk.ModuleName("lazy-in-memory-vault"),
+		implements: implementsContracts,
+		addons: { loadSignerFactory: async () => ({ default: () => signerFactory }) }
+	});
+};
+//#endregion
+//#region src/passkey-vault-module.ts
+/**
+* A lazy vault module whose recovery words come from a fresh assertion of a
+* passkey at each signature: the words derive from the passkey and are
+* checked against the account's stored key before anything is signed. The
+* assertion stays open until the Cardano signature completes.
+*
+* @param props - The passkey.
+* @returns A module for the `modules` array of `createLaceWallet`.
+*/
+const createPasskeyVaultModule = ({ keySource }) => createLazyInMemoryVaultModule({ withMnemonicWords: async (use) => keySource.withPasskeyMnemonic(use) });
+//#endregion
+//#region src/passkey-account-public-key.ts
+/** Use the same CIP-3 Icarus account derivation as Cardano's wallet integration. */
+const passkeyAccountPublicKey = async (words) => {
+	const passphrase = crypto.getRandomValues(new Uint8Array(32));
+	try {
+		return (await require_InMemoryKeyAgent.InMemoryKeyAgent.fromBip39MnemonicWords({
+			accountIndex: 0,
+			chainId: require_ChainId.ChainIds.Mainnet,
+			getPassphrase: async () => passphrase,
+			mnemonicWords: [...words],
+			purpose: require_types.KeyPurpose.STANDARD
+		}, {
+			bip32Ed25519: await require_SodiumBip32Ed25519.SodiumBip32Ed25519.create(),
+			logger: ts_log.dummyLogger
+		})).serializableData.extendedAccountPublicKey;
+	} finally {
+		passphrase.fill(0);
+	}
+};
+//#endregion
+//#region src/passkey-wallet-mismatch-error.ts
+/**
+* The passkey, or the signer, serves another account than the one expected:
+* another credential, relying party or account key than the saved binding or
+* public key names.
+*/
+var PasskeyWalletMismatchError = class extends Error {
+	constructor() {
+		super("Passkey does not match the saved Cardano wallet.");
+		this.name = "PasskeyWalletMismatchError";
+	}
+};
+//#endregion
+//#region src/passkey-wallet-entity.ts
+const fingerprint = (publicKey) => require__md.bytesToHex(require_sha2.sha256(new TextEncoder().encode(publicKey)));
+/**
+* Derives the Cardano wallet of a passkey in one assertion, checks it against
+* an expected binding, and returns its wallet entity with the binding to
+* persist. The entity is a `LazyInMemoryWallet`: it stores only public keys,
+* and `createPasskeyVaultModule` signs for it.
+*
+* @param wallet - The wallet the entity is for.
+* @param props - The key source, the name and the saved binding.
+* @returns The entity, for `wallets.addWallet`, and the binding to persist.
+*   Rejects with `PasskeyWalletMismatchError` when the passkey serves another
+*   account than `expectedBinding`.
+*/
+const createPasskeyWalletEntity = async (wallet, { keySource, walletName, expectedBinding }) => {
+	const ref = keySource.credentialRef();
+	if (expectedBinding && ref && (ref.credentialId !== expectedBinding.credentialId || ref.rpId !== expectedBinding.rpId || ref.recipeVersion !== expectedBinding.recipeVersion)) throw new PasskeyWalletMismatchError();
+	return keySource.withPasskeyMnemonic(async (words) => {
+		const assertedRef = keySource.credentialRef();
+		if (!assertedRef || ref && assertedRef.credentialId !== ref.credentialId) throw new PasskeyWalletMismatchError();
+		const publicKey = await passkeyAccountPublicKey(words);
+		const binding = {
+			...assertedRef,
+			fingerprint: fingerprint(publicKey)
+		};
+		if (expectedBinding && (binding.credentialId !== expectedBinding.credentialId || binding.rpId !== expectedBinding.rpId || binding.recipeVersion !== expectedBinding.recipeVersion || binding.fingerprint !== expectedBinding.fingerprint)) throw new PasskeyWalletMismatchError();
+		const entity = await require_sdk.createBlockchainWalletEntity(wallet, "Cardano", {
+			mnemonicWords: [...words],
+			walletName
+		});
+		const accounts = entity.accounts.filter((account) => account.blockchainName === "Cardano");
+		if (accounts.length === 0 || accounts.some((account) => account.blockchainSpecific.extendedAccountPublicKey !== publicKey)) throw new PasskeyWalletMismatchError();
+		return {
+			entity: {
+				...entity,
+				accounts
+			},
+			binding
+		};
+	});
+};
+//#endregion
+//#region ../../packages/lib/passkey/src/remote/protocol.ts
+/** Whether a channel message is shaped like a signer response. */
+const isSignerResponse = (data) => typeof data === "object" && data !== null && "id" in data && typeof data.id === "number" && "ok" in data && typeof data.ok === "boolean";
+/** Whether a window or channel message carries the given `type` tag. */
+const hasMessageType = (data, type) => typeof data === "object" && data !== null && "type" in data && data.type === type;
+//#endregion
+//#region ../../packages/lib/passkey/src/remote/client.ts
+const POPUP_NAME = "lace-signer";
+const POPUP_FEATURES = "popup,width=420,height=600";
+const POPUP_CLOSED_POLL_INTERVAL = 500;
+/**
+* The low-level client underneath `createRemotePasskeySigner`: it opens the
+* hosted signer page in a popup, completes the handshake over a message
+* channel and carries typed requests to it.
+*
+* Only messages whose origin is the signer's and whose source is the popup
+* this client opened are trusted: any other page that can reach the dApp
+* window could otherwise complete the handshake and receive the port.
+* The hello message is posted to the signer origin alone, so a popup that
+* navigated elsewhere never receives the port either.
+*
+* The popup's loaded message is awaited from `open`, not from `connect`,
+* so a dApp that awaits anything between the two cannot miss it.
+*/
+const createSignerClient = ({ signerUrl, host = window }) => {
+	const signerOrigin = new URL(signerUrl).origin;
+	const pending = /* @__PURE__ */ new Map();
+	let nextId = 1;
+	let opened;
+	let port;
+	let didClose = false;
+	const close = () => {
+		const closing = opened;
+		opened = void 0;
+		if (closing) didClose = true;
+		closing?.stop();
+		if (closing && !closing.popup.closed) closing.popup.close();
+		port?.close();
+		port = void 0;
+		closing?.settleClosed();
+		const error = new require_key_source.SignerClosedError();
+		for (const request of pending.values()) request.reject(error);
+		pending.clear();
+	};
+	const trackPopup = (popup) => {
+		let stopListening = () => {};
+		const loaded = new Promise((resolve) => {
+			const onMessage = (event) => {
+				if (event.origin !== signerOrigin || event.source !== popup) return;
+				if (!hasMessageType(event.data, "signer-loaded")) return;
+				stopListening();
+				resolve();
+			};
+			host.addEventListener("message", onMessage);
+			stopListening = () => {
+				host.removeEventListener("message", onMessage);
+			};
+		});
+		let settleClosed = () => {};
+		const closed = new Promise((_, reject) => {
+			settleClosed = () => {
+				reject(new require_key_source.SignerClosedError());
+			};
+		});
+		closed.catch(() => {});
+		const interval = setInterval(() => {
+			if (popup.closed) close();
+		}, POPUP_CLOSED_POLL_INTERVAL);
+		return {
+			popup,
+			loaded,
+			closed,
+			settleClosed,
+			stop: () => {
+				clearInterval(interval);
+				stopListening();
+			}
+		};
+	};
+	const open = () => {
+		close();
+		const popup = host.open(signerUrl, POPUP_NAME, POPUP_FEATURES);
+		if (!popup) throw new require_key_source.SignerPopupBlockedError();
+		opened = trackPopup(popup);
+		didClose = false;
+		return popup;
+	};
+	const onResponse = (event) => {
+		if (!isSignerResponse(event.data)) return;
+		const response = event.data;
+		const request = pending.get(response.id);
+		if (!request) return;
+		pending.delete(response.id);
+		if (response.ok) request.resolve(response.result);
+		else request.reject(new require_key_source.RemoteSignerError(response.code, response.message, response.details));
+	};
+	const handshake = async ({ popup, loaded, closed }) => {
+		await Promise.race([loaded, closed]);
+		const channel = new MessageChannel();
+		const ready = new Promise((resolve) => {
+			const onReady = (event) => {
+				if (!hasMessageType(event.data, "ready")) return;
+				channel.port1.removeEventListener("message", onReady);
+				resolve();
+			};
+			channel.port1.addEventListener("message", onReady);
+		});
+		channel.port1.addEventListener("message", onResponse);
+		channel.port1.start();
+		port = channel.port1;
+		popup.postMessage({ type: "hello" }, signerOrigin, [channel.port2]);
+		await Promise.race([ready, closed]);
+	};
+	const connect = async () => {
+		if (!opened) throw new Error("The signer popup is not open.");
+		opened.handshake ??= handshake(opened);
+		return opened.handshake;
+	};
+	const request = async (kind, payload) => {
+		const activePort = port;
+		if (!activePort) {
+			if (didClose) throw new require_key_source.SignerClosedError();
+			throw new Error("The signer is not connected.");
+		}
+		const id = nextId;
+		nextId += 1;
+		return new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			try {
+				activePort.postMessage({
+					id,
+					kind,
+					payload
+				});
+			} catch (error) {
+				pending.delete(id);
+				throw error;
+			}
+		});
+	};
+	return {
+		open,
+		connect,
+		request,
+		close
+	};
+};
+//#endregion
+//#region src/cardano-remote-signer-factory.ts
+/** The signer answered a request with a result of the wrong shape. */
+var RemoteSignerResultError = class extends Error {
+	constructor() {
+		super("The signer returned a malformed result.");
+		this.name = "RemoteSignerResultError";
+	}
+};
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const parseSignResult = (result) => {
+	if (!isRecord$1(result) || typeof result.serializedTx !== "string" || typeof result.signatureCount !== "number") throw new RemoteSignerResultError();
+	return {
+		serializedTx: require_bytes_vo.HexBytes(result.serializedTx),
+		signatureCount: result.signatureCount
+	};
+};
+const parseSignDataResult = (result) => {
+	if (!isRecord$1(result) || typeof result.signature !== "string" || typeof result.key !== "string") throw new RemoteSignerResultError();
+	return {
+		signature: require_bytes_vo.HexBytes(result.signature),
+		key: require_bytes_vo.HexBytes(result.key)
+	};
+};
+/**
+* Signer factory for {@link WalletType.LazyInMemory} Cardano accounts whose
+* passkey lives with the Lace signer page. Each sign request travels to the
+* signer with the transaction and the public account data, and only the
+* signed transaction or signature comes back; the mnemonic never reaches
+* the dApp. Consent is the Approve click inside the signer, so no local
+* authentication prompt runs.
+*/
+var CardanoRemoteSignerFactory = class {
+	#client;
+	constructor(props) {
+		this.#client = props.client;
+	}
+	canSign(account) {
+		return account.accountType === "LazyInMemory" && account.blockchainName === "Cardano";
+	}
+	createTransactionSigner(context) {
+		const { knownAddresses, utxo } = context;
+		const account = this.#resolveAccountProps(context);
+		return require_guarded_transaction_signer.withCollateralOwnershipGuard({ sign: ({ serializedTx }) => (0, rxjs.defer)(() => (0, rxjs.from)(this.#client.request("sign-cardano-tx", {
+			serializedTx,
+			knownAddresses,
+			utxo,
+			...account
+		}))).pipe((0, rxjs.map)(parseSignResult)) }, context);
+	}
+	createDataSigner(context) {
+		const { knownAddresses } = context;
+		const account = this.#resolveAccountProps(context);
+		return { signData: ({ signWith, payload }) => (0, rxjs.defer)(() => (0, rxjs.from)(this.#client.request("sign-cardano-data", {
+			signWith,
+			payload,
+			knownAddresses,
+			...account
+		}))).pipe((0, rxjs.map)(parseSignDataResult)) };
+	}
+	/** Reads the public account data the signer needs from the context. */
+	#resolveAccountProps(context) {
+		const account = context.wallet.accounts.find((a) => a.accountId === context.accountId);
+		if (!account || !this.canSign(account)) throw new Error(`CardanoRemoteSignerFactory does not support account type: ${account?.accountType ?? "unknown"}`);
+		const { accountIndex, chainId, extendedAccountPublicKey } = account.blockchainSpecific;
+		return {
+			accountIndex,
+			chainId: {
+				networkId: chainId.networkId,
+				networkMagic: chainId.networkMagic
+			},
+			extendedAccountPublicKey
+		};
+	}
+};
+//#endregion
+//#region src/remote-cardano-vault-module.ts
+/**
+* Builds a vault module that signs for
+* {@link WalletType.LazyInMemory} Cardano accounts through the Lace signer
+* page instead of a local mnemonic. Pass the returned module to
+* `createLaceWallet({ modules: [...] })`. Only the `signer-factory-addon`
+* contract is implemented, as with the local lazy vault: the SDK has no
+* encrypted vault to expose. A `RemotePasskeySigner` carries one ready-made,
+* as `cardanoVaultModule`.
+*
+* @param props - The connected signer client.
+* @returns A module for the `modules` array of `createLaceWallet`.
+*/
+const createRemoteCardanoVaultModule = (props) => {
+	const signerFactory = new CardanoRemoteSignerFactory(props);
+	const implementsContracts = require_store.combineContracts([require_sdk.signerFactoryAddonContract]);
+	return require_store.inferModuleContext({
+		moduleName: require_sdk.ModuleName("remote-cardano-vault"),
+		implements: implementsContracts,
+		addons: { loadSignerFactory: async () => ({ default: () => signerFactory }) }
+	});
+};
+//#endregion
+//#region src/remote-cardano-account-public-key.ts
+const isRecord = (value) => typeof value === "object" && value !== null;
+const parseAccountPublicKeyResult = (result, accountIndex) => {
+	if (!isRecord(result) || result.accountIndex !== accountIndex || typeof result.extendedAccountPublicKey !== "string") throw new RemoteSignerResultError();
+	try {
+		return require_Address.Bip32PublicKeyHex(result.extendedAccountPublicKey);
+	} catch {
+		throw new RemoteSignerResultError();
+	}
+};
+/**
+* Asks the signer for the extended public key of one Cardano account. The
+* signer asks the user to share it, so it is one consent per call; the
+* result is public and safe for the dApp to persist.
+*/
+const requestRemoteCardanoAccountPublicKey = async (client, accountIndex) => parseAccountPublicKeyResult(await client.request("cardano-account-public-key", { accountIndex }), accountIndex);
+//#endregion
+//#region src/remote-passkey-signer.ts
+/**
+* Creates one connection to the hosted Lace signer page and everything a dApp
+* signs Cardano transactions and data with through it: the connection's
+* `open`, `connect`, `close` and `request`, the `cardanoVaultModule` and
+* `accountPublicKey(index)`.
+*
+* It composes {@link createSignerClient} with the remote Cardano vault
+* module, so a dApp gets one connection to the Lace signer page instead of
+* building its own key source. The passkey stays with the signer page; the
+* dApp receives public keys and signatures only.
+*
+* `open` must run synchronously inside the user's click handler: browsers
+* refuse a popup opened after an await. Call `connect` right after `open`
+* to complete the handshake; calling it before the popup is open rejects.
+*
+* Each Cardano signature is its own Approve click in the signer window and
+* its own fresh passkey assertion.
+*
+* @param props - The signer page's URL and the window that opens it.
+* @returns The signer. Call `open()` synchronously in a click handler, then
+*   `await connect()`.
+*/
+const createRemotePasskeySigner = ({ signerUrl, host }) => {
+	const client = createSignerClient({
+		signerUrl,
+		host
+	});
+	return {
+		open: client.open,
+		connect: client.connect,
+		close: client.close,
+		request: client.request,
+		cardanoVaultModule: createRemoteCardanoVaultModule({ client }),
+		accountPublicKey: async (accountIndex) => requestRemoteCardanoAccountPublicKey(client, accountIndex)
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/sdk-contracts.ts
+const implementsContracts = require_store.combineContracts([
+	require_sdk.inMemoryIntegrationAddonContract,
+	require_sdk.tokensStoreContract,
+	require_sdk.addressesStoreContract,
+	require_sdk.signerFactoryAddonContract,
+	require_sdk.syncStoreContract,
+	require_contract.addressBookAddressValidatorAddonContract,
+	require_sdk.delegationTxBuilderAddonContract,
+	require_sdk.cardanoInMemorySigningDependencyContract,
+	require_contract.tokenIdMapperAddonContract,
+	require_sdk.deregistrationTxBuilderAddonContract,
+	require_sdk.voteDelegationTxBuilderAddonContract,
+	require_sdk.earnRewardsTxBuilderAddonContract
+]);
+const dependsOnContracts = require_store.combineContracts([
+	require_sdk.featureStoreContract,
+	require_sdk.cardanoProviderStoreContract,
+	require_sdk.walletRepoStoreContract
+]);
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/index.ts
+var store_default$1 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-MDKB6tGI2.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/sdk.ts
+/**
+* Cardano accounts: their addresses, tokens and sync, signing, and the
+* transaction builders for delegation, voting and rewards. Loads when
+* `FEATURE_FLAG_CARDANO` is enabled, and needs a Cardano provider module such
+* as `m.cardanoProviderBlockfrost`.
+*/
+var sdk_default$2 = require_store.inferModuleContext({
+	moduleName: require_sdk.ModuleName("blockchain-cardano"),
+	implements: implementsContracts,
+	dependsOn: dependsOnContracts,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.FEATURE_FLAG_CARDANO),
+		metadata: {
+			name: "Cardano",
+			description: "Cardano blockchain support"
+		}
+	},
+	store: store_default$1,
+	addons: {
+		loadInMemoryWalletIntegration: async () => Promise.resolve().then(() => require("./in-memory-wallet-integration-aW_SF-go.cjs")),
+		loadAddressBookAddressValidators: async () => Promise.resolve().then(() => require("./address-book-address-validator-CGIcqn5W.cjs")),
+		loadDelegationTxBuilder: async () => Promise.resolve().then(() => require("./delegation-tx-builder-Cp30jtj9.cjs")),
+		loadTokenIdMapper: async () => Promise.resolve().then(() => require("./token-id-mapper-D0wFdbOy.cjs")),
+		loadDeregistrationTxBuilder: async () => Promise.resolve().then(() => require("./deregistration-tx-builder-B-ZeY-dR.cjs")),
+		loadVoteDelegationTxBuilder: async () => Promise.resolve().then(() => require("./vote-delegation-tx-builder-BjZxCOd3.cjs")),
+		loadEarnRewardsTxBuilder: async () => Promise.resolve().then(() => require("./earn-rewards-tx-builder-cOUNV58E.cjs")),
+		loadSignerFactory: async () => Promise.resolve().then(() => require("./signer-factory-D95jQIPV.cjs"))
+	}
+});
+//#endregion
+//#region src/remote-passkey-wallet-entity.ts
+/**
+* Builds the Cardano wallet entity of the account the hosted signer holds,
+* from the account public key the user agrees to share there. It fails
+* closed with {@link PasskeyWalletMismatchError} when that key differs from
+* `expectedPublicKey`.
+*
+* The entity is a {@link WalletType.LazyInMemory} wallet built from the
+* public account key alone:
+* no mnemonic, PRF output or encrypted root ever reaches the dApp, so there
+* is nothing secret to persist. The wallet id is derived from that key.
+*
+* Mainnet and testnet accounts are returned; consumers choose which to expose.
+*
+* @param props - The signer, the name, the account and the saved key.
+* @returns The entity and the public key to persist.
+*/
+const createRemotePasskeyWalletEntity = async ({ signer, walletName, accountIndex = 0, expectedPublicKey, order = 0 }) => {
+	const publicKey = await signer.accountPublicKey(accountIndex);
+	if (expectedPublicKey !== void 0 && publicKey !== expectedPublicKey) throw new PasskeyWalletMismatchError();
+	const walletId = require_sdk.WalletId.deriveFromBip32PublicKey(publicKey);
+	return {
+		entity: {
+			accounts: require_in_memory_wallet_integration.createLazyAccountsFromAccountPublicKey({
+				walletId,
+				accountIndex,
+				extendedAccountPublicKey: publicKey
+			}),
+			blockchainSpecific: {},
+			metadata: {
+				name: walletName,
+				order
+			},
+			type: require_sdk.WalletType.LazyInMemory,
+			walletId
+		},
+		publicKey
+	};
+};
+//#endregion
+//#region src/create-tx-builder.ts
+/**
+* Creates a {@link TransactionBuilder} pre-configured with the active Cardano
+* network and protocol parameters from the wallet's Redux state.
+*
+* Call {@link waitForNetworkInfo} first to ensure the state is ready.
+*
+* @param wallet - A wallet with the Cardano modules loaded (see
+*   {@link WalletWithCardanoContext}), whose network info has arrived.
+* @returns `Ok` with the builder, or `Err` until the chain ID and protocol
+*   parameters are in the wallet's state.
+*/
+const createTxBuilder = (wallet) => {
+	const state = wallet.getState();
+	const chainId = require_slice.cardanoContextSelectors.cardanoContext.selectChainId(state);
+	if (!chainId) return require_asyncoption.Err(/* @__PURE__ */ new Error("Cardano network not initialized — ensure a wallet entity has been created and the Cardano blockchain module is loaded"));
+	const protocolParameters = require_slice.cardanoContextSelectors.cardanoContext.selectProtocolParameters(state);
+	if (!protocolParameters) return require_asyncoption.Err(/* @__PURE__ */ new Error("Protocol parameters not available — ensure the Cardano provider has synced"));
+	return require_asyncoption.Ok(new require_TransactionBuilder.TransactionBuilder(chainId.networkMagic, protocolParameters));
+};
+/**
+* Returns a promise that resolves once the Cardano network info (chain ID and
+* protocol parameters) is available in the wallet state. Await this before
+* calling {@link createTxBuilder} to guarantee it succeeds.
+*
+* @param wallet - A wallet with the Cardano modules loaded (see
+*   {@link WalletWithCardanoContext}).
+* @param options - Optional configuration.
+* @returns The chain ID and protocol parameters, once both are in state.
+*/
+const waitForNetworkInfo = async (wallet, options) => (0, rxjs.firstValueFrom)((0, rxjs.combineLatest)([wallet.stateObservables.cardanoContext.selectChainId$, wallet.stateObservables.cardanoContext.selectProtocolParameters$]).pipe((0, rxjs.filter)((pair) => pair[0] != null && pair[1] != null), (0, rxjs.map)(([chainId, protocolParameters]) => ({
+	chainId,
+	protocolParameters
+})), options?.timeout != null ? (0, rxjs.timeout)({ first: options.timeout }) : passthrough()));
+const passthrough = () => (source$) => source$;
+//#endregion
+//#region src/sign-cardano-tx.ts
+const isSignableCardanoWallet = (wallet) => wallet.type === require_sdk.WalletType.InMemory || wallet.type === require_sdk.WalletType.LazyInMemory;
+/**
+* Signs a Cardano transaction with the wallet's keys, through the signer of
+* its wallet kind, with no confirmation prompt of the SDK's own: confirm with
+* the user before calling it. The account is `props.accountId`, or the only
+* signable Cardano account on the active network.
+*
+* @param wallet - A wallet holding the signing account (see
+*   {@link WalletWithCardanoSigning}).
+* @param props - The unsigned transaction, and the password and account when
+*   needed.
+* @returns `Ok` with the signed transaction, ready for `submitCardanoTx`, or
+*   `Err` when no account matches, the password is missing or signing fails.
+*   It never rejects.
+*/
+const signCardanoTx = async (wallet, props) => {
+	const { serializedTx, password, accountId: requestedAccountId } = props;
+	try {
+		const { stateObservables: obs } = wallet;
+		const allWallets = await (0, rxjs.firstValueFrom)(obs.wallets.selectAll$);
+		const activeNetworkIds = await (0, rxjs.firstValueFrom)(obs.network.selectAllActiveNetworkIds$);
+		const allAddresses = await (0, rxjs.firstValueFrom)(obs.addresses.selectAllAddresses$);
+		const accountUtxos = await (0, rxjs.firstValueFrom)(obs.cardanoContext.selectCollateralOwnershipUtxos$);
+		const signableWallets = allWallets.filter(isSignableCardanoWallet);
+		const cardanoAccounts = signableWallets.flatMap((w) => w.accounts.filter((a) => a.blockchainName === "Cardano" && activeNetworkIds.includes(a.blockchainNetworkId)));
+		let accountId;
+		let walletEntity;
+		if (requestedAccountId) {
+			const found = cardanoAccounts.find((a) => a.accountId === requestedAccountId);
+			if (!found) return require_asyncoption.Err(/* @__PURE__ */ new Error(`Cardano account "${requestedAccountId}" not found on the active network`));
+			accountId = found.accountId;
+			walletEntity = signableWallets.find((w) => w.walletId === found.walletId);
+		} else {
+			if (cardanoAccounts.length === 0) return require_asyncoption.Err(/* @__PURE__ */ new Error("No Cardano accounts found on the active network"));
+			if (cardanoAccounts.length > 1) return require_asyncoption.Err(/* @__PURE__ */ new Error(`Multiple Cardano accounts found (${cardanoAccounts.length}) — specify accountId to disambiguate`));
+			const account = cardanoAccounts[0];
+			accountId = account.accountId;
+			walletEntity = signableWallets.find((w) => w.walletId === account.walletId);
+		}
+		if (walletEntity.type === require_sdk.WalletType.InMemory && !password) return require_asyncoption.Err(/* @__PURE__ */ new Error("password is required for InMemory wallets — supply props.password or use a LazyInMemory wallet"));
+		const knownAddresses = allAddresses.filter((addr) => addr.accountId === accountId && addr.blockchainName === "Cardano").filter(require_util.isCardanoAddress).map((addr) => ({
+			data: addr.data,
+			address: addr.address
+		})).filter((addr) => !!addr.data).map((addr) => ({
+			type: addr.data.type,
+			index: addr.data.index,
+			networkId: addr.data.networkId,
+			accountIndex: addr.data.accountIndex,
+			address: require_PaymentAddress.PaymentAddress(addr.address),
+			rewardAccount: require_Address.RewardAccount(addr.data.rewardAccount),
+			stakeKeyDerivationPath: addr.data.stakeKeyDerivationPath
+		}));
+		const utxo = accountUtxos[accountId] ?? [];
+		const auth = {
+			authenticate: () => (0, rxjs.of)(true),
+			accessAuthSecret: (callback) => password ? callback(require_sdk.AuthSecret(require_bytes_vo.ByteArray(password))) : (0, rxjs.throwError)(() => /* @__PURE__ */ new Error("accessAuthSecret called on a wallet that has no password — this is a LazyInMemory wallet; signer factories must not access the auth secret"))
+		};
+		const signerFactory = new require_composite_signer_factory.CompositeSignerFactory(await wallet._loadModules("addons.loadSignerFactory"));
+		const context = {
+			wallet: walletEntity,
+			accountId,
+			knownAddresses,
+			utxo,
+			collateralInputResolver: require_util.createInputResolver(utxo),
+			auth
+		};
+		return require_asyncoption.Ok(await (0, rxjs.firstValueFrom)(signerFactory.createTransactionSigner(context).sign({ serializedTx: require_bytes_vo.HexBytes(serializedTx) })));
+	} catch (error) {
+		return require_asyncoption.Err(error instanceof Error ? error : new Error(String(error)));
+	}
+};
+//#endregion
+//#region src/submit-cardano-tx.ts
+const SUBMIT_TX_TIMEOUT_MS = 6e4;
+/**
+* Submits a signed transaction through the wallet's Cardano provider and
+* waits up to 60 seconds for the provider's answer.
+*
+* @param wallet - A wallet with the Cardano modules loaded (see
+*   {@link WalletWithCardanoSubmit}).
+* @param props - The signed transaction.
+* @returns `Ok` with the transaction ID once the provider accepts it, or
+*   `Err` with the provider's refusal or a timeout. It never rejects.
+*/
+const submitCardanoTx = async (wallet, props) => {
+	const { serializedTx } = props;
+	try {
+		const txId = require_cardano_tx_id_vo.CardanoTxId.fromCbor(serializedTx);
+		const resultPromise = (0, rxjs.firstValueFrom)((0, rxjs.merge)(wallet.actionObservables.cardanoContext.submitTxCompleted$.pipe((0, rxjs.filter)(({ payload }) => payload.txId === txId), (0, rxjs.map)(({ payload }) => require_asyncoption.Ok({ txId: payload.txId }))), wallet.actionObservables.cardanoContext.submitTxFailed$.pipe((0, rxjs.filter)(({ payload }) => payload.txId === txId), (0, rxjs.map)(({ payload }) => require_asyncoption.Err(new Error(payload.error))))).pipe((0, rxjs.timeout)(SUBMIT_TX_TIMEOUT_MS)));
+		wallet.dispatch("cardanoContext.submitTx", { serializedTx });
+		return await resultPromise;
+	} catch (error) {
+		return require_asyncoption.Err(error instanceof Error ? error : new Error(String(error)));
+	}
+};
+//#endregion
+//#region ../../packages/module/swap-provider-steelswap/src/steelswap/steelswap-mappers.ts
+const STEELSWAP_PROVIDER_ID = "steelswap";
+const STEELSWAP_PARTNER = "lace-aggregator";
+const STEELSWAP_PARTNER_ADDRESS = "$lace@steelswap";
+const LOVELACE_DECIMALS = 6;
+const QUOTE_EXPIRY_MS = 15e3;
+const DEFAULT_PARTNER = {
+	name: STEELSWAP_PARTNER,
+	address: STEELSWAP_PARTNER_ADDRESS
+};
+const lovelaceToAda = (lovelace) => (lovelace / 10 ** LOVELACE_DECIMALS).toFixed(2);
+const makeLovelaceFee = (label, amount) => ({
+	label,
+	amount: String(amount),
+	tokenId: "lovelace",
+	displayAmount: lovelaceToAda(amount),
+	displayCurrency: "ADA"
+});
+const toSmallestUnit = (displayAmount, decimals) => {
+	const number_ = Number(displayAmount);
+	if (Number.isNaN(number_) || number_ === 0) return 0;
+	return Math.round(number_ * 10 ** decimals);
+};
+const toEstimateRequest = (request, partner = DEFAULT_PARTNER) => ({
+	tokenA: request.sellTokenId,
+	tokenB: request.buyTokenId,
+	quantity: toSmallestUnit(request.sellAmount, request.sellTokenDecimals),
+	ignoreDexes: request.excludedDexes,
+	partner: partner.name,
+	hop: true,
+	da: []
+});
+const fromEstimateResponse = (response, request) => {
+	const route = (response.pools ?? (response.splitGroup ?? []).flat().flatMap((split) => split.pools ?? [])).map((pool) => ({
+		dexName: pool.dex,
+		sellTokenId: response.tokenA,
+		buyTokenId: response.tokenB,
+		percentage: response.quantityA > 0 ? pool.quantityA / response.quantityA : 0
+	}));
+	const fees = [makeLovelaceFee("v2.swap.review.network-fee", response.totalFee), makeLovelaceFee("v2.swap.review.service-fee", response.steelswapFee)];
+	const deposit = response.totalDeposit > 0 ? {
+		amount: String(response.totalDeposit),
+		displayAmount: lovelaceToAda(response.totalDeposit),
+		displayCurrency: "ADA"
+	} : void 0;
+	const totalFeeLovelace = response.totalFee + response.steelswapFee;
+	return {
+		routeId: `steelswap-${request.sellTokenId}-${request.buyTokenId}-${Date.now()}`,
+		providerId: STEELSWAP_PROVIDER_ID,
+		sellTokenId: response.tokenA,
+		buyTokenId: response.tokenB,
+		sellAmount: String(response.quantityA),
+		expectedBuyAmount: String(response.quantityB),
+		price: response.price,
+		priceDisplay: `${response.price.toFixed(6)}`,
+		fees,
+		totalFeeDisplay: `${lovelaceToAda(totalFeeLovelace)} ADA`,
+		deposit,
+		route,
+		quoteExpiresAt: Date.now() + QUOTE_EXPIRY_MS
+	};
+};
+const toBuildRequest = (request, partner = DEFAULT_PARTNER) => ({
+	tokenA: request.quote.sellTokenId,
+	tokenB: request.quote.buyTokenId,
+	quantity: Number(request.quote.sellAmount),
+	ignoreDexes: [],
+	partner: partner.name,
+	hop: true,
+	da: [],
+	address: request.userAddress,
+	forwardAddress: "",
+	utxos: request.utxos,
+	collateral: request.collateralUtxos,
+	slippage: Math.round(request.slippage * 100),
+	pAddress: partner.address,
+	feeAdust: true,
+	ttl: request.ttl
+});
+const fromBuildResponse = (response) => ({
+	unsignedTxCbor: response.tx,
+	providerId: STEELSWAP_PROVIDER_ID
+});
+const getCardanoTokenIconUrl = (nftCdnUrl, policyId, assetName) => {
+	try {
+		return `${nftCdnUrl}/lace/image/${require_Address.AssetFingerprint.fromParts(require_Address.PolicyId(policyId), require_Address.AssetName(assetName))}?size=64`;
+	} catch {
+		return;
+	}
+};
+const fromTokenSummary = (token, nftCdnUrl) => {
+	const tokenKey = token.policyId && token.policyName ? `${token.policyId}${token.policyName}` : "lovelace";
+	const iconUrl = token.policyId && token.policyName ? getCardanoTokenIconUrl(nftCdnUrl, token.policyId, token.policyName) : void 0;
+	return {
+		id: tokenKey,
+		ticker: token.ticker,
+		name: token.name,
+		decimals: token.decimals,
+		policyId: token.policyId || void 0,
+		icon: iconUrl
+	};
+};
+const fromDexList = (dexNames) => dexNames.map((name) => ({
+	id: name,
+	name
+}));
+const extractDetailFromErrorMessage = (message) => {
+	const jsonStart = message.indexOf("{");
+	if (jsonStart === -1) return message;
+	try {
+		return JSON.parse(message.slice(jsonStart)).detail ?? message;
+	} catch {
+		return message;
+	}
+};
+const toSwapProviderError = (error) => {
+	if (error instanceof Error) return {
+		code: "PROVIDER_UNAVAILABLE",
+		message: extractDetailFromErrorMessage(error.message)
+	};
+	return {
+		code: "UNKNOWN",
+		message: String(error)
+	};
+};
+//#endregion
+//#region ../../packages/module/swap-provider-steelswap/src/steelswap/steelswap-provider.ts
+const jsonPost = async (url, body) => {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body)
+	});
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new Error(`SteelSwap API error (${response.status}): ${text || response.statusText}`);
+	}
+	return await response.json();
+};
+const jsonGet = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`SteelSwap API error (${response.status}): ${response.statusText}`);
+	return await response.json();
+};
+/**
+* A {@link SwapProvider} over the SteelSwap aggregator's API: it quotes swap
+* routes across Cardano DEXes, builds the unsigned swap transaction for a
+* quote, and lists and searches the tokens and DEXes it serves. Each call
+* emits one `Result`; a failed request is an `Err` with a `SwapProviderError`.
+*/
+const createSteelSwapProvider = (config) => {
+	const partner = config.partner ?? {
+		name: "lace-aggregator",
+		address: "$lace@steelswap"
+	};
+	return {
+		getQuote: (request) => (0, rxjs.from)(jsonPost(`${config.steelswapApiBaseUrl}/swap/estimate/`, toEstimateRequest(request, partner)).then((response) => require_asyncoption.Ok(fromEstimateResponse(response, request))).catch((error) => {
+			return require_asyncoption.Err(toSwapProviderError(error));
+		})),
+		buildSwapTx: (request) => (0, rxjs.from)(jsonPost(`${config.steelswapApiBaseUrl}/swap/build/`, toBuildRequest(request, partner)).then((response) => require_asyncoption.Ok(fromBuildResponse(response))).catch((error) => {
+			return require_asyncoption.Err(toSwapProviderError(error));
+		})),
+		listTokens: () => (0, rxjs.from)(jsonGet(`${config.steelswapApiBaseUrl}/tokens/list/`).then((tokens) => require_asyncoption.Ok(tokens.map((t) => fromTokenSummary(t, config.nftCdnUrl)))).catch((error) => require_asyncoption.Err(toSwapProviderError(error)))),
+		listDexes: () => (0, rxjs.from)(jsonGet(`${config.steelswapApiBaseUrl}/dex/list/`).then((dexes) => require_asyncoption.Ok(fromDexList(dexes))).catch((error) => require_asyncoption.Err(toSwapProviderError(error)))),
+		searchTokens: (_networkId, query) => (0, rxjs.from)(jsonPost(`${config.steelswapApiBaseUrl}/tokens/find-pairs/`, { token: query }).then((tokens) => require_asyncoption.Ok(tokens.map((t) => fromTokenSummary(t, config.nftCdnUrl)))).catch((error) => require_asyncoption.Err(toSwapProviderError(error))))
+	};
+};
+//#endregion
+//#region ../../packages/contract/crypto/src/contract.ts
+const cryptoAddonContract = require_store.inferContractContext({
+	name: require_sdk.ContractName("crypto-addon"),
+	instance: "exactly-one",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["bip32Ed25519", "blake2b"] }
+});
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/store/index.ts
+var store_default = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-BC2CZZOu2.cjs")),
+	context: {
+		actions: {},
+		selectors: {}
+	}
+});
+//#endregion
+//#region ../../packages/module/cardano-provider-blockfrost/src/sdk.ts
+/**
+* Cardano chain data through Blockfrost: UTxOs, transactions, stake
+* information and protocol parameters, configured by
+* `config.cardanoProvider.blockfrostConfigs`. Loads when
+* `FEATURE_FLAG_CARDANO` is enabled, and needs a crypto module such as
+* `m.cryptoCardanoSdk`.
+*/
+var sdk_default$1 = require_store.inferModuleContext({
+	moduleName: require_sdk.ModuleName("cardano-provider-blockfrost"),
+	dependsOn: require_store.combineContracts([cryptoAddonContract]),
+	implements: require_store.combineContracts([require_sdk.cardanoProviderStoreContract, require_sdk.cardanoProviderDependencyContract]),
+	store: store_default,
+	feature: {
+		willLoad: (featureFlags) => featureFlags.some((flag) => flag.key === require_const.FEATURE_FLAG_CARDANO),
+		metadata: {
+			name: "Blockfrost",
+			description: "Blockfrost provider for Cardano"
+		}
+	},
+	addons: {}
+});
+//#endregion
+//#region ../../packages/module/crypto-cardano-sdk/src/sdk.ts
+/** Cardano cryptography: BIP32-Ed25519 key derivation and Blake2b hashing. */
+var sdk_default = require_store.inferModuleContext({
+	moduleName: require_sdk.ModuleName("crypto-cardano-sdk"),
+	implements: require_store.combineContracts([cryptoAddonContract]),
+	addons: {
+		bip32Ed25519: async () => Promise.resolve().then(() => require("./bip32ed25519-CRiG-Kjg.cjs")),
+		blake2b: async () => Promise.resolve().then(() => require("./blake2b-Iy324FwH.cjs"))
+	}
+});
+//#endregion
+//#region src/modules-cardano.ts
+var modules_cardano_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	blockchainCardano: () => sdk_default$2,
+	cardanoProviderBlockfrost: () => sdk_default$1,
+	cryptoCardanoSdk: () => sdk_default,
+	featureDev: () => require_sdk.sdk_default$2,
+	storageInMemory: () => require_sdk.sdk_default$1,
+	storageWebIndexeddb: () => require_sdk.sdk_default
+});
+//#endregion
+Object.defineProperty(exports, "CardanoRemoteSignerFactory", {
+	enumerable: true,
+	get: function() {
+		return CardanoRemoteSignerFactory;
+	}
+});
+Object.defineProperty(exports, "PasskeyWalletMismatchError", {
+	enumerable: true,
+	get: function() {
+		return PasskeyWalletMismatchError;
+	}
+});
+Object.defineProperty(exports, "RemoteSignerResultError", {
+	enumerable: true,
+	get: function() {
+		return RemoteSignerResultError;
+	}
+});
+Object.defineProperty(exports, "createLazyInMemoryVaultModule", {
+	enumerable: true,
+	get: function() {
+		return createLazyInMemoryVaultModule;
+	}
+});
+Object.defineProperty(exports, "createPasskeyVaultModule", {
+	enumerable: true,
+	get: function() {
+		return createPasskeyVaultModule;
+	}
+});
+Object.defineProperty(exports, "createPasskeyWalletEntity", {
+	enumerable: true,
+	get: function() {
+		return createPasskeyWalletEntity;
+	}
+});
+Object.defineProperty(exports, "createRemoteCardanoVaultModule", {
+	enumerable: true,
+	get: function() {
+		return createRemoteCardanoVaultModule;
+	}
+});
+Object.defineProperty(exports, "createRemotePasskeySigner", {
+	enumerable: true,
+	get: function() {
+		return createRemotePasskeySigner;
+	}
+});
+Object.defineProperty(exports, "createRemotePasskeyWalletEntity", {
+	enumerable: true,
+	get: function() {
+		return createRemotePasskeyWalletEntity;
+	}
+});
+Object.defineProperty(exports, "createSignerClient", {
+	enumerable: true,
+	get: function() {
+		return createSignerClient;
+	}
+});
+Object.defineProperty(exports, "createSteelSwapProvider", {
+	enumerable: true,
+	get: function() {
+		return createSteelSwapProvider;
+	}
+});
+Object.defineProperty(exports, "createTxBuilder", {
+	enumerable: true,
+	get: function() {
+		return createTxBuilder;
+	}
+});
+Object.defineProperty(exports, "modules_cardano_exports", {
+	enumerable: true,
+	get: function() {
+		return modules_cardano_exports;
+	}
+});
+Object.defineProperty(exports, "sdk_default", {
+	enumerable: true,
+	get: function() {
+		return sdk_default;
+	}
+});
+Object.defineProperty(exports, "sdk_default$1", {
+	enumerable: true,
+	get: function() {
+		return sdk_default$1;
+	}
+});
+Object.defineProperty(exports, "sdk_default$2", {
+	enumerable: true,
+	get: function() {
+		return sdk_default$2;
+	}
+});
+Object.defineProperty(exports, "signCardanoTx", {
+	enumerable: true,
+	get: function() {
+		return signCardanoTx;
+	}
+});
+Object.defineProperty(exports, "submitCardanoTx", {
+	enumerable: true,
+	get: function() {
+		return submitCardanoTx;
+	}
+});
+Object.defineProperty(exports, "waitForNetworkInfo", {
+	enumerable: true,
+	get: function() {
+		return waitForNetworkInfo;
+	}
+});