@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/init-Bu4iXcTH.cjs

@@ -1,34 +0,0 @@
-require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_util = require("./util-BeG7WXzM.cjs");
-const require_account = require("./account-BlYkEmcs.cjs");
-const require_account_tokens = require("./account-tokens-DXr8DlpW.cjs");
-let _laceio_cardano_core = require("@laceio/cardano/core");
-let rxjs = require("rxjs");
-//#region ../../packages/contract/cardano-context/src/custody/store/track-custody-account-tokens.ts
-/**
-* A custody account holds what its owner can spend through Lace while it is
-* live: plain funds without a reference script, own reserves and withdrawable
-* rewards. No Lace builder spends a plain fund carrying a reference script or
-* a foreign reserve, the control UTxO's lovelace is the state's minimum and
-* the owner's fee reserve, grant UTxOs hold lovelace only a sweep frees,
-* stranded deposits cannot be spent, and account tokens are no holding, so
-* none of them reaches the tokens store.
-*/
-const computeCustodyAccountTokens = (account) => (_, { cardanoCustody: { selectCardanoCustodyAccountState$ } }, { actions }) => selectCardanoCustodyAccountState$.pipe((0, rxjs.map)((selectAccountState) => selectAccountState(account.accountId)), (0, rxjs.distinctUntilChanged)(), (0, rxjs.map)((accountState) => actions.tokens.setAccountTokens({
-	blockchainName: "Cardano",
-	accountId: account.accountId,
-	byAddress: accountState?.status === "live" ? [{
-		address: require_util.CardanoPaymentAddress(account.blockchainSpecific.address),
-		tokens: require_account_tokens.toAccountTokens((0, _laceio_cardano_core.coalesceValueQuantities)([...accountState.funds.filter(([, txOut]) => txOut.scriptReference === void 0), ...accountState.reserves.own].map(([, txOut]) => txOut.value)), accountState.withdrawableRewards)
-	}] : []
-})));
-/**
-* Tracks the tokens of every active custody account, which the Cardano
-* context's own token tracking leaves to this store.
-*/
-const trackCustodyAccountTokens = (actionObservables, stateObservables, dependencies) => stateObservables.cardanoContext.selectActiveCardanoAccounts$.pipe((0, rxjs.mergeAll)(), (0, rxjs.distinct)((account) => account.accountId), (0, rxjs.mergeMap)((account) => require_account.isCardanoCustodyAccount(account) ? computeCustodyAccountTokens(account)(actionObservables, stateObservables, dependencies) : []));
-//#endregion
-//#region ../../packages/contract/cardano-context/src/custody/store/init.ts
-const init = () => ({ sideEffects: [trackCustodyAccountTokens] });
-//#endregion
-exports.default = init;

package/dist/init-C00gw1zi.js

@@ -1,422 +0,0 @@
-import { a as __toESM } from "./rolldown-runtime-OvD0k9op.js";
-import { n as Ok, t as Err } from "./asyncoption-CruEYOBI.js";
-import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Dmgt28wM.js";
-import { a as isNotFoundError, o as toProviderError } from "./error-DIZOY2Lw.js";
-import { n as buildUrl, t as HttpClient } from "./http-client-TRlhDZGh.js";
-import { t as require_lib } from "./lib--iqvW4O_.js";
-import { t as BitcoinTransactionStatus } from "./bitcoin-data-provider-BYPSmuZS.js";
-import { ProviderError, ProviderFailure } from "@laceio/cardano/core";
-import { contextLogger } from "@laceio/cardano/util";
-import { defer, from, of } from "rxjs";
-import memoize from "lodash/memoize.js";
-import { catchError as catchError$1, map as map$1 } from "rxjs/operators";
-//#region ../../packages/lib/bitcoin-provider-core/src/maestro/util.ts
-const SATS_IN_BTC = 1e8;
-/**
-* Converts a Bitcoin amount expressed as a decimal string (I.E `"0.00012345"`)
-* into its integer value in satoshis.
-*
-* @param btcString - Bitcoin amount as a string (e.g. `"2"`, `"0.5"`, `"0.00000001"`).
-* @returns Amount in satoshis as a number.
-*/
-const btcStringToSatoshis = (btcString) => {
-	const [integerPart, fractionPart = ""] = btcString.split(".");
-	const paddedFraction = fractionPart.padEnd(8, "0").slice(0, 8);
-	return Number(integerPart) * SATS_IN_BTC + Number(paddedFraction);
-};
-/**
-* Return the OP_RETURN payload (as hex) if the output is nulldata,
-* otherwise undefined.
-*/
-const getOpReturnData = (output) => {
-	const asm = output.scriptPubKey?.asm;
-	if (!asm) return void 0;
-	if (!(output.scriptPubKey?.type === "nulldata" || asm.startsWith("OP_RETURN"))) return void 0;
-	const [, hexPayload] = asm.split(/\s+/);
-	return hexPayload ?? void 0;
-};
-//#endregion
-//#region ../../packages/lib/bitcoin-provider-core/src/maestro/maestro-provider.ts
-/**
-* High-level REST wrapper around Maestro's Bitcoin API.
-*/
-var MaestroBitcoinProvider = class {
-	logger;
-	#client;
-	#txCache = /* @__PURE__ */ new Map();
-	#rawTxCache = /* @__PURE__ */ new Map();
-	/**
-	* Creates a new instance of the Maestro Bitcoin provider.
-	*
-	* @param client - Pre-configured HTTP client.
-	* @param logger - Any ts-log compatible logger implementation.
-	*/
-	constructor(client, logger) {
-		this.#client = client;
-		this.logger = contextLogger(logger, this.constructor.name);
-	}
-	/**
-	* Fetches the current block height and hash.
-	*
-	* @returns A promise that resolves with the current blockchain information.
-	*/
-	async getLastKnownBlock() {
-		const { data: { last_updated: { block_height, block_hash } } } = await this.request("/rpc/general/info");
-		return {
-			height: Number(block_height),
-			hash: block_hash
-		};
-	}
-	/**
-	* Retrieves detailed information about a specific blockchain transaction by its hash.
-	*
-	* @param txHash - The hash of the transaction to retrieve. This is typically a unique identifier
-	* in hexadecimal format.
-	* @returns A promise that resolves to a `TransactionHistoryEntry`.
-	*
-	* @throws `Error` Throws an error if the transaction cannot be retrieved, which might occur due to network issues,
-	* incorrect transaction hash, or the transaction not existing in the blockchain.
-	*/
-	async getTransaction(txHash) {
-		if (this.#txCache.has(txHash)) return this.#txCache.get(txHash);
-		const { data: { data } } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
-		const entry = this.mapTxEntry(txHash, data);
-		if (entry.confirmations > 0) this.#txCache.set(txHash, entry);
-		return entry;
-	}
-	/**
-	* Fetches the raw serialized transaction (hex) for a given transaction hash.
-	*
-	* Raw bytes of confirmed transactions are immutable, so they are cached
-	* indefinitely; unconfirmed transactions are re-fetched on every call.
-	*
-	* @param txHash - The hash of the transaction to retrieve, in hexadecimal format.
-	* @returns A promise that resolves to the raw transaction hex.
-	*
-	* @throws `Error` Throws an error if the transaction cannot be retrieved, which might occur due to network issues,
-	* incorrect transaction hash, or the transaction not existing in the blockchain.
-	*/
-	async getRawTransaction(txHash) {
-		if (this.#rawTxCache.has(txHash)) return this.#rawTxCache.get(txHash);
-		const { data: { data } } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
-		if (data.confirmations > 0) this.#rawTxCache.set(txHash, data.hex);
-		return data.hex;
-	}
-	/**
-	* Retrieve a **paginated**, (reverse-chronological by default) history of transactions
-	* that involve a given address.
-	*
-	* @param address - The Bitcoin address or script pubkey to query for transactions.
-	* @param parameters - Optional parameters to filter and paginate the transaction history.
-	*
-	* @returns `BitcoinPaginatedResponse` -
-	*          `{ items: TransactionHistoryEntry[]; cursor: string }`.
-	*/
-	async getTransactions(address, parameters) {
-		try {
-			const { data: { data: edges = [], next_cursor } } = await this.request(`/addresses/${address}/txs`, { params: {
-				order: "desc",
-				count: 50,
-				...parameters
-			} });
-			const transactions = [];
-			for (const { tx_hash } of edges) transactions.push(await this.getTransaction(tx_hash));
-			return {
-				items: transactions,
-				cursor: next_cursor ?? ""
-			};
-		} catch (error) {
-			if (isNotFoundError(error)) return {
-				items: [],
-				cursor: ""
-			};
-			throw error;
-		}
-	}
-	/**
-	* Retrieves unconfirmed transactions (as transaction history entries) from the mempool for a given Bitcoin address.
-	*
-	* This function queries pending transactions associated with the specified Bitcoin address.
-	* It returns an array of transaction history entries representing UTXOs that are currently unconfirmed.
-	* Optionally, you can filter transactions to only include those observed after a specified block height.
-	*
-	* @param address - The Bitcoin address or script pubkey to query for pending transactions.
-	* @param parameters - Optional parameters to filter and paginate the transaction history.
-	* @returns `BitcoinPaginatedResponse` -
-	*          `{ items: TransactionHistoryEntry[]; cursor: string }`.
-	*/
-	async getTransactionsInMempool(address, parameters) {
-		try {
-			const { data: { data: utxos = [], next_cursor } } = await this.request(`/mempool/addresses/${address}/utxos`, { params: {
-				order: "desc",
-				...parameters
-			} });
-			if (utxos.length === 0) return {
-				items: [],
-				cursor: ""
-			};
-			const seen = /* @__PURE__ */ new Set();
-			const pendingPromises = [];
-			for (const { txid, mempool: isInMempool } of utxos) {
-				if (seen.has(txid) || !isInMempool) continue;
-				seen.add(txid);
-				pendingPromises.push(this.mapTxToPendingEntry(txid));
-			}
-			return {
-				items: await Promise.all(pendingPromises),
-				cursor: next_cursor ?? ""
-			};
-		} catch (error) {
-			if (isNotFoundError(error)) return {
-				items: [],
-				cursor: ""
-			};
-			throw error;
-		}
-	}
-	/**
-	* Fetches the unspent transaction outputs (UTxOs) associated with a specified address.
-	*
-	* @returns A promise that resolves with a list of UTxOs for the address.
-	*/
-	async getUTxOs(address, parameters) {
-		try {
-			const { data: { data: utxos = [], next_cursor } } = await this.request(`/addresses/${address}/utxos`, { params: { ...parameters } });
-			return {
-				items: utxos.map((out) => ({
-					txId: out.txid,
-					index: out.vout,
-					satoshis: Number.parseInt(out.satoshis, 10),
-					address: out.address,
-					script: out.script_pubkey,
-					height: out.height,
-					confirmations: out.confirmations,
-					inscriptions: out.inscriptions.map((inscription) => ({
-						offset: inscription.offset,
-						inscriptionId: inscription.inscription_id
-					})),
-					runes: out.runes.map((rune) => ({
-						runeId: rune.rune_id,
-						amount: rune.amount
-					}))
-				})),
-				cursor: next_cursor ?? ""
-			};
-		} catch (error) {
-			if (isNotFoundError(error)) return {
-				items: [],
-				cursor: ""
-			};
-			throw error;
-		}
-	}
-	/**
-	* Submits a raw transaction to the blockchain for inclusion in a block.
-	*
-	* @returns A promise that resolves with the transaction hash of the submitted transaction.
-	*/
-	async submitTransaction(rawTransaction) {
-		const { data, status } = await this.request("/rpc/transaction/submit", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(rawTransaction)
-		});
-		if (status !== 201) throw new ProviderError(ProviderFailure.InvalidResponse, `Unexpected response status: ${status} - ${JSON.stringify(data)}`);
-		return data;
-	}
-	/**
-	* Fetches the status of a specified transaction by its hash.
-	*
-	* @returns A promise that resolves with the current status of the transaction.
-	*/
-	async getTransactionStatus(txHash) {
-		try {
-			const { status } = await this.getTransaction(txHash);
-			return status;
-		} catch (error) {
-			if (isNotFoundError(error)) return BitcoinTransactionStatus.Dropped;
-			throw error;
-		}
-	}
-	/**
-	* Estimates the transaction fee in BTC per kilobyte based on the desired confirmation time and fee estimation mode.
-	*
-	* This method queries a blockchain fee estimation service to determine the appropriate fee
-	* rate required for a transaction to be confirmed within the specified number of blocks.
-	*
-	* @param blocks - The target number of blocks within which the transaction should be confirmed.
-	*                          A smaller number indicates a higher priority and typically results in a higher fee.
-	*                          For example, `blocks = 1` requests a fee estimation for the next block confirmation.
-	* @param mode - The fee estimation mode, which determines the trade-off between
-	*                                   reliability and cost:
-	*                                 - `FeeEstimationMode.Conservative`: Prioritizes confirmation reliability.
-	*                                 - `FeeEstimationMode.Economical`: Aims to minimize fees, with potentially slower confirmations.
-	* @returns A promise that resolves to the estimated fee in satoshis per byte.
-	*                            This value can be used to calculate the total transaction fee
-	*                            based on the size of the transaction in bytes.
-	*/
-	async estimateFee(blocks, mode) {
-		const { data: { data }, status } = await this.request(`/rpc/transaction/estimatefee/${blocks}`, { params: { mode } });
-		if (status !== 200) throw new ProviderError(ProviderFailure.InvalidResponse, "Invalid response from fee estimation API.");
-		return {
-			feeRate: data.feerate,
-			targetConfirmationTime: data.blocks
-		};
-	}
-	/**
-	* Transform a Maestro transaction record into the wallet's
-	* `TransactionHistoryEntry` format.
-	*
-	* @param txHash - The transaction hash.
-	* @param data - The data payload returned by `/rpc/transaction/{hash}`.
-	* @param overrides - Partial entry whose properties overwrite the derived base
-	*                   values (e.g. `{ status: Pending, confirmations: -1 }`).
-	*
-	* @returns A fully populated `TransactionHistoryEntry`.
-	*/
-	mapTxEntry(txHash, data, overrides = {}) {
-		return {
-			inputs: data.vin.map((vin) => ({
-				txId: vin.txid ?? "",
-				index: vin.vout ?? 0,
-				address: vin.address ?? "",
-				satoshis: btcStringToSatoshis(vin.value.toString()),
-				isCoinbase: !!vin.coinbase,
-				coinbaseScript: vin.coinbase ?? ""
-			})),
-			outputs: data.vout.map((vout) => ({
-				address: vout.address,
-				satoshis: btcStringToSatoshis(vout.value.toString()),
-				opReturnData: getOpReturnData(vout)
-			})),
-			transactionHash: txHash,
-			confirmations: data.confirmations,
-			status: data.confirmations > 0 ? BitcoinTransactionStatus.Confirmed : BitcoinTransactionStatus.Pending,
-			blockHeight: data.blockheight,
-			timestamp: data.blocktime,
-			...overrides
-		};
-	}
-	/**
-	* Maps a transaction hash to a pending transaction entry.
-	*
-	* @param txHash - The transaction hash to map.
-	*/
-	async mapTxToPendingEntry(txHash) {
-		const { data } = await this.request(`/rpc/transaction/${txHash}`, { params: { verbose: true } });
-		return this.mapTxEntry(txHash, data.data, {
-			confirmations: -1,
-			status: BitcoinTransactionStatus.Pending,
-			blockHeight: 0,
-			timestamp: Math.floor(Date.now() / 1e3)
-		});
-	}
-	/**
-	* Performs a generic HTTP request to the Maestro API.
-	*/
-	async request(endpoint, options) {
-		try {
-			this.logger.debug("request", endpoint);
-			const response = await this.#client.request(endpoint, options);
-			this.logger.debug("response", JSON.stringify(response));
-			return response;
-		} catch (error) {
-			this.logger.debug("error", error);
-			throw toProviderError(error);
-		}
-	}
-};
-//#endregion
-//#region ../../packages/lib/bitcoin-provider-core/src/maestro-config.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib());
-const computeMaestroConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
-const getMaestroClient = memoize(({ clientConfig, rateLimiterConfig }) => {
-	const rateLimiter = new import_lib.default({
-		reservoir: rateLimiterConfig.size,
-		reservoirIncreaseAmount: rateLimiterConfig.increaseAmount,
-		reservoirIncreaseInterval: rateLimiterConfig.increaseInterval,
-		reservoirIncreaseMaximum: rateLimiterConfig.size
-	});
-	return new HttpClient({
-		baseUrl: buildUrl([clientConfig.apiVersion], clientConfig.baseUrl),
-		requestInit: { headers: { "api-key": clientConfig.projectId ?? "" } }
-	}, { rateLimiter });
-}, computeMaestroConfigIdentifier);
-//#endregion
-//#region ../../packages/lib/bitcoin-provider-core/src/create-maestro-bitcoin-provider.ts
-const getMaestroApiProvider = memoize((config, logger) => {
-	return new MaestroBitcoinProvider(getMaestroClient(config), logger);
-}, computeMaestroConfigIdentifier);
-const getMaestroConfig = (context, configs) => configs[context.network];
-const unprovisionedNetworkError = (network) => new ProviderError(ProviderFailure.NotImplemented, void 0, `maestro is unprovisioned for network ${network}: no config entry in this build`);
-const createMaestroBitcoinProvider = (maestroConfig, logger) => ({
-	getLastKnownBlock: (context) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getLastKnownBlock().then(Ok).catch(Err));
-	},
-	getTransaction: (context, txHash) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getTransaction(txHash).then(Ok).catch(Err));
-	},
-	getRawTransaction: (context, txHash) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		const provider = getMaestroApiProvider(config, logger);
-		return defer(async () => provider.getRawTransaction(txHash)).pipe(retryBackoff(PROVIDER_REQUEST_RETRY_CONFIG), map$1(Ok), catchError$1((error) => of(Err(error))));
-	},
-	getTransactions: (context, address, { afterBlockHeight, limit, order, cursor }) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getTransactions(address, {
-			count: limit,
-			order,
-			cursor,
-			from: afterBlockHeight
-		}).then((result) => Ok(result)).catch(Err));
-	},
-	getTransactionsInMempool: (context, address, { afterBlockHeight, limit, order, cursor }) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getTransactionsInMempool(address, {
-			count: limit,
-			order,
-			cursor,
-			from: afterBlockHeight
-		}).then((result) => Ok(result)).catch(Err));
-	},
-	getUTxOs: (context, address, { afterBlockHeight, limit, order, cursor }) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getUTxOs(address, {
-			count: limit,
-			order,
-			cursor,
-			from: afterBlockHeight
-		}).then((result) => Ok(result)).catch(Err));
-	},
-	submitTransaction: (context, rawTransaction) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).submitTransaction(rawTransaction).then(Ok).catch(Err));
-	},
-	getTransactionStatus: (context, txHash) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).getTransactionStatus(txHash).then(Ok).catch(Err));
-	},
-	estimateFee: (context, blocks, mode) => {
-		const config = getMaestroConfig(context, maestroConfig);
-		if (!config) return of(Err(unprovisionedNetworkError(context.network)));
-		return from(getMaestroApiProvider(config, logger).estimateFee(blocks, mode).then(Ok).catch(Err));
-	}
-});
-//#endregion
-//#region ../../packages/module/bitcoin-provider-maestro/src/store/dependencies.ts
-const initializeDependencies = async ({ runtime: { config: { bitcoinProvider: { maestroConfig } } } }, { logger }) => ({ bitcoinProvider: createMaestroBitcoinProvider(maestroConfig, logger) });
-//#endregion
-//#region ../../packages/module/bitcoin-provider-maestro/src/store/init.ts
-const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
-//#endregion
-export { redux as default };