@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/SodiumBip32Ed25519-DCikAMsl.js

@@ -0,0 +1,363 @@
+import { a as __toESM } from "./chunk-D6g4UhsZ.js";
+import { c as InvalidArgumentError } from "./errors-CAOTqN4_.js";
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { Gt as Bip32PublicKeyHex, Jt as Ed25519PrivateNormalKeyHex, Ut as Bip32PrivateKeyHex, Wt as Bip32PublicKeyHashHex, Xt as Ed25519SignatureHex, en as require_libsodium_wrappers, qt as Ed25519PrivateExtendedKeyHex } from "./Address-_c_-9hLC.js";
+import { t as Ed25519PublicKey } from "./Ed25519PublicKey-DIE19xHg.js";
+import { t as require_browser } from "./browser-D5jRKv_L.js";
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/arithmetic.js
+const add28Mul8 = (x, y) => {
+	let carry = 0;
+	const out = new Uint8Array(32);
+	for (let i = 0; i < 28; i++) {
+		const r = x[i] + (y[i] << 3) + carry;
+		out[i] = r & 255;
+		carry = r >> 8;
+	}
+	for (let i = 28; i < 32; i++) {
+		const r = x[i] + carry;
+		out[i] = r & 255;
+		carry = r >> 8;
+	}
+	return out;
+};
+const add256bits = (x, y) => {
+	let carry = 0;
+	const out = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) {
+		const r = x[i] + y[i] + carry;
+		out[i] = r;
+		carry = r >> 8;
+	}
+	return out;
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32KeyDerivation.js
+init__polyfill_buffer_patch();
+var import_libsodium_wrappers = /* @__PURE__ */ __toESM(require_libsodium_wrappers(), 1);
+const isHardenedDerivation = (index) => index >= 2147483648;
+const deriveHardened = (index, scalar, iv, chainCode) => {
+	const data = import_buffer.Buffer.allocUnsafe(69);
+	data.writeUInt32LE(index, 65);
+	scalar.copy(data, 1);
+	iv.copy(data, 33);
+	data[0] = 0;
+	const zMac = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode);
+	data[0] = 1;
+	return {
+		ccMac: import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode),
+		zMac
+	};
+};
+const deriveSoft = (index, scalar, chainCode) => {
+	const data = import_buffer.Buffer.allocUnsafe(37);
+	data.writeUInt32LE(index, 33);
+	import_buffer.Buffer.from(import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar)).copy(data, 1);
+	data[0] = 2;
+	const zMac = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode);
+	data[0] = 3;
+	return {
+		ccMac: import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode),
+		zMac
+	};
+};
+const pointOfTrunc28Mul8 = (sk) => {
+	const scalar = add28Mul8(new Uint8Array(32).fill(0), sk);
+	return import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+};
+const derivePrivate = (key, index) => {
+	const kl = key.subarray(0, 32);
+	const kr = key.subarray(32, 64);
+	const cc = key.subarray(64, 96);
+	const { ccMac, zMac } = isHardenedDerivation(index) ? deriveHardened(index, kl, kr, cc) : deriveSoft(index, kl, cc);
+	const chainCode = ccMac.slice(32, 64);
+	const zl = zMac.slice(0, 32);
+	const zr = zMac.slice(32, 64);
+	const left = add28Mul8(kl, zl);
+	const right = add256bits(kr, zr);
+	return import_buffer.Buffer.concat([
+		left,
+		right,
+		chainCode
+	]);
+};
+const derivePublic = (key, index) => {
+	const pk = key.subarray(0, 32);
+	const cc = key.subarray(32, 64);
+	const data = import_buffer.Buffer.allocUnsafe(37);
+	data.writeUInt32LE(index, 33);
+	if (isHardenedDerivation(index)) throw new InvalidArgumentError("index", "Public key can not be derived from a hardened index.");
+	pk.copy(data, 1);
+	data[0] = 2;
+	const z = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, cc);
+	data[0] = 3;
+	const chainCode = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, cc).slice(32, 64);
+	const p = pointOfTrunc28Mul8(z.slice(0, 32));
+	return import_buffer.Buffer.concat([import_libsodium_wrappers.default.crypto_core_ed25519_add(p, pk), chainCode]);
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Ed25519e/Ed25519Signature.js
+init__polyfill_buffer_patch();
+var __classPrivateFieldSet$3 = function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet$3 = function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Ed25519Signature_signature;
+var Ed25519Signature = class Ed25519Signature {
+	constructor(signature) {
+		_Ed25519Signature_signature.set(this, void 0);
+		__classPrivateFieldSet$3(this, _Ed25519Signature_signature, signature, "f");
+	}
+	static fromBytes(signature) {
+		if (signature.length !== 64) throw new InvalidArgumentError("signature", `signature should be 64 bytes; however ${signature.length} bytes were provided.`);
+		return new Ed25519Signature(signature);
+	}
+	static fromHex(signature) {
+		return Ed25519Signature.fromBytes(import_buffer.Buffer.from(signature, "hex"));
+	}
+	bytes() {
+		return __classPrivateFieldGet$3(this, _Ed25519Signature_signature, "f");
+	}
+	hex() {
+		return Ed25519SignatureHex(import_buffer.Buffer.from(__classPrivateFieldGet$3(this, _Ed25519Signature_signature, "f")).toString("hex"));
+	}
+};
+_Ed25519Signature_signature = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Ed25519e/Ed25519PrivateKey.js
+init__polyfill_buffer_patch();
+var __classPrivateFieldSet$2 = function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet$2 = function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Ed25519PrivateKey_keyMaterial;
+const SCALAR_INDEX$1 = 0;
+const SCALAR_SIZE$1 = 32;
+const IV_INDEX = 32;
+const IV_SIZE = 32;
+const extendedScalar$1 = (extendedKey) => extendedKey.slice(SCALAR_INDEX$1, SCALAR_SIZE$1);
+const extendedIv = (extendedKey) => extendedKey.slice(IV_INDEX, IV_INDEX + IV_SIZE);
+const signExtendedDetached = (extendedKey, message) => {
+	const scalar = extendedScalar$1(extendedKey);
+	const publicKey = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+	const nonce = import_libsodium_wrappers.default.crypto_core_ed25519_scalar_reduce(import_libsodium_wrappers.default.crypto_hash_sha512(import_buffer.Buffer.concat([extendedIv(extendedKey), message])));
+	const r = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(nonce);
+	let hram = import_libsodium_wrappers.default.crypto_hash_sha512(import_buffer.Buffer.concat([
+		r,
+		publicKey,
+		message
+	]));
+	hram = import_libsodium_wrappers.default.crypto_core_ed25519_scalar_reduce(hram);
+	return import_buffer.Buffer.concat([r, import_libsodium_wrappers.default.crypto_core_ed25519_scalar_add(import_libsodium_wrappers.default.crypto_core_ed25519_scalar_mul(hram, scalar), nonce)]);
+};
+var Ed25519PrivateKeyType;
+(function(Ed25519PrivateKeyType) {
+	Ed25519PrivateKeyType["Normal"] = "Normal";
+	Ed25519PrivateKeyType["Extended"] = "Extended";
+})(Ed25519PrivateKeyType || (Ed25519PrivateKeyType = {}));
+var Ed25519PrivateKey = class Ed25519PrivateKey {
+	constructor(keyMaterial, type) {
+		_Ed25519PrivateKey_keyMaterial.set(this, void 0);
+		__classPrivateFieldSet$2(this, _Ed25519PrivateKey_keyMaterial, keyMaterial, "f");
+		this.__type = type;
+	}
+	toPublic() {
+		return Ed25519PublicKey.fromBytes(this.__type === Ed25519PrivateKeyType.Extended ? import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(extendedScalar$1(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"))) : import_libsodium_wrappers.default.crypto_sign_seed_keypair(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).publicKey);
+	}
+	sign(message) {
+		return Ed25519Signature.fromBytes(this.__type === Ed25519PrivateKeyType.Extended ? signExtendedDetached(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"), import_buffer.Buffer.from(message, "hex")) : import_libsodium_wrappers.default.crypto_sign_detached(import_buffer.Buffer.from(message, "hex"), import_buffer.Buffer.concat([__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"), this.toPublic().bytes()])));
+	}
+	static fromNormalBytes(keyMaterial) {
+		if (keyMaterial.length !== 32) throw new InvalidArgumentError("keyMaterial", `Key should be 32 bytes; however ${keyMaterial.length} bytes were provided.`);
+		return new Ed25519PrivateKey(keyMaterial, Ed25519PrivateKeyType.Normal);
+	}
+	static fromExtendedBytes(keyMaterial) {
+		if (keyMaterial.length !== 64) throw new InvalidArgumentError("keyMaterial", `Key should be 64 bytes; however ${keyMaterial.length} bytes were provided.`);
+		return new Ed25519PrivateKey(keyMaterial, Ed25519PrivateKeyType.Extended);
+	}
+	static fromNormalHex(keyMaterial) {
+		return Ed25519PrivateKey.fromNormalBytes(import_buffer.Buffer.from(keyMaterial, "hex"));
+	}
+	static fromExtendedHex(keyMaterial) {
+		return Ed25519PrivateKey.fromExtendedBytes(import_buffer.Buffer.from(keyMaterial, "hex"));
+	}
+	bytes() {
+		return __classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f");
+	}
+	hex() {
+		return this.__type === Ed25519PrivateKeyType.Extended ? Ed25519PrivateExtendedKeyHex(import_buffer.Buffer.from(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).toString("hex")) : Ed25519PrivateNormalKeyHex(import_buffer.Buffer.from(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).toString("hex"));
+	}
+};
+_Ed25519PrivateKey_keyMaterial = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32PublicKey.js
+init__polyfill_buffer_patch();
+var __classPrivateFieldSet$1 = function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet$1 = function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Bip32PublicKey_key;
+var Bip32PublicKey = class Bip32PublicKey {
+	constructor(key) {
+		_Bip32PublicKey_key.set(this, void 0);
+		__classPrivateFieldSet$1(this, _Bip32PublicKey_key, key, "f");
+	}
+	static fromBytes(key) {
+		if (key.length !== 64) throw new InvalidArgumentError("key", `Key should be 64 bytes; however ${key.length} bytes were provided.`);
+		return new Bip32PublicKey(key);
+	}
+	static fromHex(key) {
+		return Bip32PublicKey.fromBytes(import_buffer.Buffer.from(key, "hex"));
+	}
+	toRawKey() {
+		return Ed25519PublicKey.fromBytes(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f").slice(0, 32));
+	}
+	derive(derivationIndices) {
+		let key = import_buffer.Buffer.from(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f"));
+		for (const index of derivationIndices) key = derivePublic(key, index);
+		return Bip32PublicKey.fromBytes(key);
+	}
+	bytes() {
+		return __classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f");
+	}
+	hex() {
+		return Bip32PublicKeyHex(import_buffer.Buffer.from(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f")).toString("hex"));
+	}
+	hash() {
+		const hash = import_libsodium_wrappers.default.crypto_generichash(28, __classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f"), null);
+		return Bip32PublicKeyHashHex(import_buffer.Buffer.from(hash).toString("hex"));
+	}
+};
+_Bip32PublicKey_key = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32PrivateKey.js
+init__polyfill_buffer_patch();
+var import_browser = require_browser();
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+	if (kind === "m") throw new TypeError("Private method is not writable");
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Bip32PrivateKey_key;
+const SCALAR_INDEX = 0;
+const SCALAR_SIZE = 32;
+const PBKDF2_ITERATIONS = 4096;
+const PBKDF2_KEY_SIZE = 96;
+const PBKDF2_DIGEST_ALGORITHM = "sha512";
+const CHAIN_CODE_INDEX = 64;
+const CHAIN_CODE_SIZE = 32;
+const clampScalar = (scalar) => {
+	scalar[0] &= 248;
+	scalar[31] &= 31;
+	scalar[31] |= 64;
+	return scalar;
+};
+const extendedScalar = (extendedKey) => extendedKey.slice(SCALAR_INDEX, SCALAR_SIZE);
+var Bip32PrivateKey = class Bip32PrivateKey {
+	constructor(key) {
+		_Bip32PrivateKey_key.set(this, void 0);
+		__classPrivateFieldSet(this, _Bip32PrivateKey_key, key, "f");
+	}
+	static fromBip39Entropy(entropy, password) {
+		const xprv = (0, import_browser.pbkdf2Sync)(password, entropy, PBKDF2_ITERATIONS, PBKDF2_KEY_SIZE, PBKDF2_DIGEST_ALGORITHM);
+		return Bip32PrivateKey.fromBytes(clampScalar(xprv));
+	}
+	static fromBytes(key) {
+		if (key.length !== 96) throw new InvalidArgumentError("key", `Key should be 96 bytes; however ${key.length} bytes were provided.`);
+		return new Bip32PrivateKey(key);
+	}
+	static fromHex(key) {
+		return Bip32PrivateKey.fromBytes(import_buffer.Buffer.from(key, "hex"));
+	}
+	derive(derivationIndices) {
+		let key = import_buffer.Buffer.from(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f"));
+		for (const index of derivationIndices) key = derivePrivate(key, index);
+		return Bip32PrivateKey.fromBytes(key);
+	}
+	toRawKey() {
+		return Ed25519PrivateKey.fromExtendedBytes(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(0, 64));
+	}
+	toPublic() {
+		const scalar = extendedScalar(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(0, 64));
+		const publicKey = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+		return Bip32PublicKey.fromBytes(import_buffer.Buffer.concat([publicKey, __classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(CHAIN_CODE_INDEX, CHAIN_CODE_INDEX + CHAIN_CODE_SIZE)]));
+	}
+	bytes() {
+		return __classPrivateFieldGet(this, _Bip32PrivateKey_key, "f");
+	}
+	hex() {
+		return Bip32PrivateKeyHex(import_buffer.Buffer.from(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f")).toString("hex"));
+	}
+};
+_Bip32PrivateKey_key = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/strategies/SodiumBip32Ed25519.js
+const EXTENDED_KEY_HEX_LENGTH = 128;
+var SodiumBip32Ed25519 = class SodiumBip32Ed25519 {
+	constructor() {}
+	static async create() {
+		await import_libsodium_wrappers.default.ready;
+		return Promise.resolve(new SodiumBip32Ed25519());
+	}
+	fromBip39Entropy(entropy, passphrase) {
+		return Bip32PrivateKey.fromBip39Entropy(entropy, passphrase).hex();
+	}
+	getPublicKey(privateKey) {
+		return (privateKey.length === EXTENDED_KEY_HEX_LENGTH ? Ed25519PrivateKey.fromExtendedHex(privateKey) : Ed25519PrivateKey.fromNormalHex(privateKey)).toPublic().hex();
+	}
+	getPubKeyHash(publicKey) {
+		return Ed25519PublicKey.fromHex(publicKey).hash().hex();
+	}
+	getRawPrivateKey(bip32PrivateKey) {
+		return Bip32PrivateKey.fromHex(bip32PrivateKey).toRawKey().hex();
+	}
+	getRawPublicKey(bip32PublicKey) {
+		return Bip32PublicKey.fromHex(bip32PublicKey).toRawKey().hex();
+	}
+	getBip32PublicKey(privateKey) {
+		return Bip32PrivateKey.fromHex(privateKey).toPublic().hex();
+	}
+	derivePrivateKey(parentKey, derivationIndices) {
+		return Bip32PrivateKey.fromHex(parentKey).derive(derivationIndices).hex();
+	}
+	derivePublicKey(parentKey, derivationIndices) {
+		return Bip32PublicKey.fromHex(parentKey).derive(derivationIndices).hex();
+	}
+	async derivePublicKeyAsync(parentKey, derivationIndices) {
+		return this.derivePublicKey(parentKey, derivationIndices);
+	}
+	sign(privateKey, message) {
+		return (privateKey.length === EXTENDED_KEY_HEX_LENGTH ? Ed25519PrivateKey.fromExtendedHex(privateKey) : Ed25519PrivateKey.fromNormalHex(privateKey)).sign(message).hex();
+	}
+	verify(signature, message, publicKey) {
+		return Ed25519PublicKey.fromHex(publicKey).verify(Ed25519Signature.fromHex(signature), message);
+	}
+};
+//#endregion
+export { Bip32PublicKey as n, Ed25519Signature as r, SodiumBip32Ed25519 as t };

package/dist/{TransactionBuilder-CeJTNzm-.cjs → TransactionBuilder-BakTJvsJ.cjs}

@@ -1,8 +1,7 @@
-require("./chunk-9hOWP6kD.cjs");
-const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_Address = require("./Address-4KjeDt_x.cjs");
-const require_subtractValueQuantities = require("./subtractValueQuantities-C8qDTtgH.cjs");
-const require_ChainId = require("./ChainId-sdLmlIRk.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_fees = require("./fees-DtC71fOx.cjs");
+const require_subtractValueQuantities = require("./subtractValueQuantities-CqR606HV.cjs");
+const require_ChainId = require("./ChainId-CNPSU9nn.cjs");
 //#region ../../packages/contract/cardano-context/src/common/time.ts
 /**
 * Predefined slot configurations for different Cardano networks.
@@ -287,71 +286,6 @@ var InputSelectionError = class extends Error {
 	}
 };
 //#endregion
-//#region ../../node_modules/@cardano-sdk/tx-construction/dist/esm/fees/fees.js
-require__polyfill_buffer_patch.init__polyfill_buffer_patch();
-const MIN_ADA_CONSTANT_OVERHEAD = 160;
-const serializeBigInt = (bigInt) => {
-	const writer = new require_Address.CborWriter();
-	writer.writeInt(BigInt(bigInt));
-	return writer.encode();
-};
-const serializeTxOutputSize = (output) => require_Address.TransactionOutput.fromCore(output).toCbor().length / 2;
-const serializeTx = (tx) => require__polyfill_buffer_patch.import_buffer.Buffer.from(require_Address.Transaction.fromCore(tx).toCbor(), "hex");
-const getTotalExUnits = (redeemers) => {
-	const totalExUnits = {
-		memory: 0,
-		steps: 0
-	};
-	for (const redeemer of redeemers) {
-		totalExUnits.memory += redeemer.executionUnits.memory;
-		totalExUnits.steps += redeemer.executionUnits.steps;
-	}
-	return totalExUnits;
-};
-const minRefScriptFee = (tx, resolvedInputs, coinsPerRefScriptByte) => {
-	if (coinsPerRefScriptByte === 0) return BigInt(0);
-	let base = coinsPerRefScriptByte;
-	const range = 25600;
-	const multiplier = 1.2;
-	let totalRefScriptsSize = 0;
-	const totalInputs = [...tx.body.inputs, ...tx.body.referenceInputs ?? []];
-	for (const output of totalInputs) {
-		const resolvedInput = resolvedInputs.find((input) => input[0].txId === output.txId && input[0].index === output.index);
-		if (resolvedInput && resolvedInput[1].scriptReference) totalRefScriptsSize += require_Address.Script.fromCore(resolvedInput[1].scriptReference).toCbor().length / 2;
-	}
-	let scriptRefFee = 0;
-	while (totalRefScriptsSize > 0) {
-		scriptRefFee += Math.ceil(Math.min(range, totalRefScriptsSize) * base);
-		totalRefScriptsSize = Math.max(totalRefScriptsSize - range, 0);
-		base *= multiplier;
-	}
-	return BigInt(scriptRefFee);
-};
-const minScriptFee = (tx, exUnitsPrice, resolvedInputs, coinsPerRefScriptByte) => {
-	const scriptRefFee = minRefScriptFee(tx, resolvedInputs, coinsPerRefScriptByte);
-	if (!tx.witness.redeemers) return BigInt(scriptRefFee);
-	const totalExUnits = getTotalExUnits(tx.witness.redeemers);
-	return BigInt(Math.ceil(totalExUnits.steps * exUnitsPrice.steps + totalExUnits.memory * exUnitsPrice.memory)) + scriptRefFee;
-};
-const minNoScriptFee = (tx, minFeeConstant, minFeeCoefficient) => {
-	const txSize = serializeTx(tx).length;
-	return BigInt(Math.ceil(txSize * minFeeCoefficient + minFeeConstant));
-};
-const minAdaRequired = (output, coinsPerUtxoByte) => {
-	const oldCoinSize = serializeBigInt(output.value.coins.toString()).length;
-	let latestSize = oldCoinSize;
-	let isDone = false;
-	while (!isDone) {
-		const sizeDiff = latestSize - oldCoinSize;
-		const newCoinSize = serializeBigInt((BigInt(serializeTxOutputSize(output) + MIN_ADA_CONSTANT_OVERHEAD + sizeDiff) * coinsPerUtxoByte).toString()).length;
-		isDone = latestSize === newCoinSize;
-		latestSize = newCoinSize;
-	}
-	const sizeChange = latestSize - oldCoinSize;
-	return BigInt(serializeTxOutputSize(output) + MIN_ADA_CONSTANT_OVERHEAD + sizeChange) * coinsPerUtxoByte;
-};
-const minFee = (tx, resolvedInputs, pparams) => minNoScriptFee(tx, pparams.minFeeConstant, pparams.minFeeCoefficient) + minScriptFee(tx, pparams.prices, resolvedInputs, pparams.minFeeRefScriptCostPerByte ? Number(pparams.minFeeRefScriptCostPerByte) : 0);
-//#endregion
 //#region ../../packages/contract/cardano-context/src/input-selection/change-builder.ts
 /**
 * The largest ada quantity a transaction output can carry (the total lovelace
@@ -365,7 +299,7 @@ const MAX_OUTPUT_COIN = 45000000000000000n;
 * @param utxos - The list of UTxOs to aggregate.
 * @returns A value representing the combined total of all UTxOs.
 */
-const totalValueOf = (utxos) => require_subtractValueQuantities.coalesceValueQuantities(utxos.map(([, out]) => out.value));
+const totalValueOf = (utxos) => require_fees.coalesceValueQuantities(utxos.map(([, out]) => out.value));
 /**
 * Checks whether a value is exactly zero for both ADA and all assets.
 *
@@ -491,7 +425,7 @@ const buildChangeOutputs = ({ selection, remaining, targetValue, changeAddress,
 	for (let iteration = 0;; iteration++) {
 		if (iteration >= maxIterations) throw new Error("Change construction exceeded the UTxO pool bound; the top-up loop failed to terminate");
 		parts = splitChangeAssets(change.assets, protocolParameters.maxValueSize);
-		minAdaPerPart = parts.map((assets) => minAdaRequired({
+		minAdaPerPart = parts.map((assets) => require_fees.minAdaRequired({
 			address: changeAddress,
 			value: {
 				coins: 0n,
@@ -500,7 +434,7 @@ const buildChangeOutputs = ({ selection, remaining, targetValue, changeAddress,
 		}, coinsPerUtxoByte));
 		totalMinAda = minAdaPerPart.reduce((total, minAda) => total + minAda, 0n);
 		if (change.coins >= totalMinAda) break;
-		change = require_subtractValueQuantities.coalesceValueQuantities([change, moveLargestCoinUtxo(finalSelection, finalRemaining)]);
+		change = require_fees.coalesceValueQuantities([change, moveLargestCoinUtxo(finalSelection, finalRemaining)]);
 	}
 	const remainder = change.coins - totalMinAda;
 	return {
@@ -548,7 +482,7 @@ var EvaluatedFeeShortfallError = class extends Error {
 * @returns The combined value of all inputs (missing inputs contribute zero).
 */
 const coalesceValueQuantitiesInInputs = (inputs, resolvedInputs) => {
-	return require_subtractValueQuantities.coalesceValueQuantities(inputs.map((input) => {
+	return require_fees.coalesceValueQuantities(inputs.map((input) => {
 		const utxo = resolvedInputs.find((element) => element[0].txId === input.txId && element[0].index === input.index);
 		return utxo ? utxo[1].value : {
 			coins: 0n,
@@ -625,7 +559,7 @@ const computeVkWitnessesCost = (signatureCount, minFeeCoefficient) => {
 */
 const assertChangeOutputsMeetMinAda = (changeOutputs, protocolParameters) => {
 	for (const changeOutput of changeOutputs) {
-		const minUtxoValue = minAdaRequired(changeOutput, BigInt(protocolParameters.coinsPerUtxoByte));
+		const minUtxoValue = require_fees.minAdaRequired(changeOutput, BigInt(protocolParameters.coinsPerUtxoByte));
 		if (changeOutput.value.coins < minUtxoValue) throw new Error(`Change output is below the minimum UTxO value: holds ${changeOutput.value.coins} lovelace, requires ${minUtxoValue}`);
 	}
 };
@@ -662,7 +596,7 @@ const runBalancingLoop = ({ unbalancedTx, availableUtxo, preSelectedUtxo, collat
 		const body = balancedTx.body;
 		const outputs = body.outputs;
 		balancedTx.body.fee = fee;
-		const requiredInputValue = require_subtractValueQuantities.subtractValueQuantities([require_subtractValueQuantities.coalesceValueQuantities(outputs.map((output) => output.value)), {
+		const requiredInputValue = require_subtractValueQuantities.subtractValueQuantities([require_fees.coalesceValueQuantities(outputs.map((output) => output.value)), {
 			coins: (implicitCoin.withdrawals ?? 0n) + (implicitCoin.reclaimDeposit ?? 0n) - (implicitCoin.deposit ?? 0n) - (fee + donation),
 			assets: mint ?? /* @__PURE__ */ new Map()
 		}]);
@@ -689,7 +623,7 @@ const runBalancingLoop = ({ unbalancedTx, availableUtxo, preSelectedUtxo, collat
 		assertChangeOutputsMeetMinAda(changeOutputs, protocolParameters);
 		body.outputs.push(...changeOutputs);
 		const vkWitnessesCost = computeVkWitnessesCost(getUniqueSignerKeyHashes(balancedTx, [...selection, ...collateralUtxos ?? []]).size, BigInt(protocolParameters.minFeeCoefficient));
-		const computedFee = minFee(balancedTx, [...selection, ...referenceUtxos ?? []], protocolParameters) + vkWitnessesCost;
+		const computedFee = require_fees.minFee(balancedTx, [...selection, ...referenceUtxos ?? []], protocolParameters) + vkWitnessesCost;
 		if (computedFee > fee) {
 			fee = computedFee;
 			body.fee = fee;
@@ -814,7 +748,7 @@ const correctFeeAfterEvaluation = ({ balancedTx, evaluatedRedeemers, resolvedInp
 			}
 		};
 		return {
-			requiredFee: minFee({
+			requiredFee: require_fees.minFee({
 				...balancedTx,
 				body: {
 					...balancedTx.body,
@@ -884,7 +818,7 @@ const isTransactionBalanced = ({ transaction, resolvedInputs, protocolParameters
 	};
 	const outputs = transaction.body.outputs;
 	const inputs = transaction.body.inputs;
-	return isZeroValue(require_subtractValueQuantities.subtractValueQuantities([require_subtractValueQuantities.subtractValueQuantities([require_subtractValueQuantities.coalesceValueQuantities(outputs.map((output) => output.value)), coalesceValueQuantitiesInInputs(inputs, resolvedInputs)]), implicitValue]));
+	return isZeroValue(require_subtractValueQuantities.subtractValueQuantities([require_subtractValueQuantities.subtractValueQuantities([require_fees.coalesceValueQuantities(outputs.map((output) => output.value)), coalesceValueQuantitiesInInputs(inputs, resolvedInputs)]), implicitValue]));
 };
 //#endregion
 //#region ../../packages/contract/cardano-context/src/tx-builder/reference-scripts.ts
@@ -935,7 +869,7 @@ const referenceScriptFee = (size, { minFeeRefScriptCostPerByte }) => {
 * @param utxos - The list of UTxOs to aggregate.
 * @returns A value representing the combined total of all UTxOs.
 */
-const valueOf = (utxos) => require_subtractValueQuantities.coalesceValueQuantities(utxos.map(([, out]) => out.value));
+const valueOf = (utxos) => require_fees.coalesceValueQuantities(utxos.map(([, out]) => out.value));
 /**
 * Retrieves the quantity of a specific native asset from a given {@link Cardano.Value}.
 *
@@ -1042,7 +976,7 @@ var LargeFirstCoinSelector = class {
 				const amt = getAssetAmount(u[1].value, id);
 				if (amt <= 0n) return false;
 				selection.push(u);
-				current = require_subtractValueQuantities.coalesceValueQuantities([current, u[1].value]);
+				current = require_fees.coalesceValueQuantities([current, u[1].value]);
 				have += amt;
 				return true;
 			});
@@ -1057,7 +991,7 @@ var LargeFirstCoinSelector = class {
 				const ada = u[1].value.coins ?? 0n;
 				if (ada <= 0n) return false;
 				selection.push(u);
-				current = require_subtractValueQuantities.coalesceValueQuantities([current, u[1].value]);
+				current = require_fees.coalesceValueQuantities([current, u[1].value]);
 				deficit -= ada;
 				return true;
 			});
@@ -1249,7 +1183,7 @@ const makeChange = (params) => {
 	maps = splitOversizedMaps(maps, protocolParameters.maxValueSize);
 	maps.sort((a, b) => a.assets.size - b.assets.size);
 	const coinsPerUtxoByte = BigInt(protocolParameters.coinsPerUtxoByte);
-	const minAdas = maps.map((map) => minAdaRequired({
+	const minAdas = maps.map((map) => require_fees.minAdaRequired({
 		address: changeAddress,
 		value: {
 			coins: 0n,
@@ -2533,14 +2467,14 @@ var TransactionBuilder = class {
 		for (const utxo of sorted) {
 			if (selected.length >= maxInputs) break;
 			selected.push(utxo);
-			const total = require_subtractValueQuantities.coalesceValueQuantities(selected.map(([, out]) => out.value));
+			const total = require_fees.coalesceValueQuantities(selected.map(([, out]) => out.value));
 			if (total.coins < coverAmount) continue;
 			const returnCoin = total.coins - coverAmount;
 			const hasAssets = (total.assets?.size ?? 0) > 0;
 			if (returnCoin === 0n && !hasAssets) return selected;
 			const returnValue = { coins: returnCoin };
 			if (hasAssets) returnValue.assets = total.assets;
-			if (returnCoin >= minAdaRequired({
+			if (returnCoin >= require_fees.minAdaRequired({
 				address: returnAddress,
 				value: returnValue
 			}, BigInt(this.params.coinsPerUtxoByte))) return selected;
@@ -2560,7 +2494,7 @@ var TransactionBuilder = class {
 	*/
 	buildCollateralFields(reservedCollateral, amount) {
 		const returnAddress = this.collateralReturnAddress;
-		const collateralValue = require_subtractValueQuantities.coalesceValueQuantities(reservedCollateral.map(([, out]) => out.value));
+		const collateralValue = require_fees.coalesceValueQuantities(reservedCollateral.map(([, out]) => out.value));
 		const returnCoin = collateralValue.coins - amount;
 		if (returnCoin < 0n) throw new InsufficientCollateralError(`Collateral inputs hold ${collateralValue.coins} lovelace but the required collateral is ${amount}`);
 		const hasAssets = (collateralValue.assets?.size ?? 0) > 0;
@@ -2571,7 +2505,7 @@ var TransactionBuilder = class {
 			address: returnAddress,
 			value: returnValue
 		};
-		const minReturn = minAdaRequired(collateralReturn, BigInt(this.params.coinsPerUtxoByte));
+		const minReturn = require_fees.minAdaRequired(collateralReturn, BigInt(this.params.coinsPerUtxoByte));
 		if (returnCoin < minReturn) {
 			if (hasAssets) throw new InsufficientCollateralError(`Collateral return needs ${minReturn} lovelace but only ${returnCoin} is available`);
 			return { totalCollateral: collateralValue.coins };
@@ -2659,21 +2593,57 @@ var TransactionBuilder = class {
 	}
 };
 //#endregion
+Object.defineProperty(exports, "EvaluatedFeeShortfallError", {
+	enumerable: true,
+	get: function() {
+		return EvaluatedFeeShortfallError;
+	}
+});
 Object.defineProperty(exports, "InputSelectionError", {
 	enumerable: true,
 	get: function() {
 		return InputSelectionError;
 	}
 });
+Object.defineProperty(exports, "InsufficientCollateralError", {
+	enumerable: true,
+	get: function() {
+		return InsufficientCollateralError;
+	}
+});
+Object.defineProperty(exports, "LargeFirstCoinSelector", {
+	enumerable: true,
+	get: function() {
+		return LargeFirstCoinSelector;
+	}
+});
+Object.defineProperty(exports, "SLOT_CONFIG_NETWORK", {
+	enumerable: true,
+	get: function() {
+		return SLOT_CONFIG_NETWORK;
+	}
+});
 Object.defineProperty(exports, "TransactionBuilder", {
 	enumerable: true,
 	get: function() {
 		return TransactionBuilder;
 	}
 });
-Object.defineProperty(exports, "minAdaRequired", {
+Object.defineProperty(exports, "getUniqueSignerKeyHashes", {
+	enumerable: true,
+	get: function() {
+		return getUniqueSignerKeyHashes;
+	}
+});
+Object.defineProperty(exports, "referenceScriptFee", {
+	enumerable: true,
+	get: function() {
+		return referenceScriptFee;
+	}
+});
+Object.defineProperty(exports, "referenceScriptSize", {
 	enumerable: true,
 	get: function() {
-		return minAdaRequired;
+		return referenceScriptSize;
 	}
 });