@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/init-D4WM3-Mn.cjs

@@ -0,0 +1,18 @@
+require("./chunk-9hOWP6kD.cjs");
+require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+require("./dist-MJof_Ky1.cjs");
+require("./pbkdf2-B1veireP.cjs");
+require("./safe-buffer-DbXbwhUQ.cjs");
+require("./address-lECYBd9-.cjs");
+require("./asyncoption-CYcZNBRM.cjs");
+const require_side_effects = require("./side-effects-DG0R-KFc.cjs");
+require("./bn-BFq5a4dk.cjs");
+//#region ../../packages/module/blockchain-bitcoin/src/store/init.ts
+const store = (props) => ({
+	sideEffects: require_side_effects.createBitcoinProviderSideEffects(props.runtime.config),
+	reducers: require_side_effects.bitcoinContextReducers,
+	selectors: require_side_effects.bitcoinContextSelectors,
+	sideEffectDependencies: { bitcoinAccountWallets$: require_side_effects.bitcoinAccountWallets$ }
+});
+//#endregion
+exports.default = store;

package/dist/init-DMi2FGpf.cjs

@@ -0,0 +1,424 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require_errors = require("./errors-lg3enbYs.cjs");
+const require_logging = require("./logging-CbxgIX9V.cjs");
+const require_asyncoption = require("./asyncoption-CYcZNBRM.cjs");
+const require_retry_config = require("./retry-config-BGv5q5QM.cjs");
+const require_error = require("./error-B6wj9nPv.cjs");
+const require_http_client = require("./http-client-DYQ_7Rdf.cjs");
+const require_lib$1 = require("./lib-BC-62Byh.cjs");
+const require_bitcoin_data_provider = require("./bitcoin-data-provider-D0OT_Uiu.cjs");
+let rxjs = require("rxjs");
+let lodash_memoize = require("lodash/memoize.js");
+lodash_memoize = require_chunk.__toESM(lodash_memoize);
+let rxjs_operators = require("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 = require_logging.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 (require_error.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 (require_error.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 (require_error.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 require_errors.ProviderError(require_errors.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 (require_error.isNotFoundError(error)) return require_bitcoin_data_provider.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 require_errors.ProviderError(require_errors.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 ? require_bitcoin_data_provider.BitcoinTransactionStatus.Confirmed : require_bitcoin_data_provider.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: require_bitcoin_data_provider.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 require_error.toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/lib/bitcoin-provider-core/src/maestro-config.ts
+var import_lib = /* @__PURE__ */ require_chunk.__toESM(require_lib$1.require_lib());
+const computeMaestroConfigIdentifier = ({ clientConfig: { baseUrl, projectId } }) => `${baseUrl}-${projectId}`;
+const getMaestroClient = (0, lodash_memoize.default)(({ clientConfig, rateLimiterConfig }) => {
+	const rateLimiter = new import_lib.default({
+		reservoir: rateLimiterConfig.size,
+		reservoirIncreaseAmount: rateLimiterConfig.increaseAmount,
+		reservoirIncreaseInterval: rateLimiterConfig.increaseInterval,
+		reservoirIncreaseMaximum: rateLimiterConfig.size
+	});
+	return new require_http_client.HttpClient({
+		baseUrl: require_http_client.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
+var import_dist = require_retry_config.require_dist();
+const getMaestroApiProvider = (0, lodash_memoize.default)((config, logger) => {
+	return new MaestroBitcoinProvider(getMaestroClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMaestroConfig = (context, configs) => configs[context.network];
+const unprovisionedNetworkError = (network) => new require_errors.ProviderError(require_errors.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 (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getLastKnownBlock().then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransaction(txHash).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getRawTransaction: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		const provider = getMaestroApiProvider(config, logger);
+		return (0, rxjs.defer)(async () => provider.getRawTransaction(txHash)).pipe((0, import_dist.retryBackoff)(require_retry_config.PROVIDER_REQUEST_RETRY_CONFIG), (0, rxjs_operators.map)(require_asyncoption.Ok), (0, rxjs_operators.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err(error))));
+	},
+	getTransactions: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactions(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	getTransactionsInMempool: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactionsInMempool(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	getUTxOs: (context, address, { afterBlockHeight, limit, order, cursor }) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getUTxOs(address, {
+			count: limit,
+			order,
+			cursor,
+			from: afterBlockHeight
+		}).then((result) => require_asyncoption.Ok(result)).catch(require_asyncoption.Err));
+	},
+	submitTransaction: (context, rawTransaction) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).submitTransaction(rawTransaction).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	getTransactionStatus: (context, txHash) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).getTransactionStatus(txHash).then(require_asyncoption.Ok).catch(require_asyncoption.Err));
+	},
+	estimateFee: (context, blocks, mode) => {
+		const config = getMaestroConfig(context, maestroConfig);
+		if (!config) return (0, rxjs.of)(require_asyncoption.Err(unprovisionedNetworkError(context.network)));
+		return (0, rxjs.from)(getMaestroApiProvider(config, logger).estimateFee(blocks, mode).then(require_asyncoption.Ok).catch(require_asyncoption.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
+exports.default = redux;

package/dist/{init-lcaUSOOG.js → init-DPTJohPd.js}

@@ -1,4 +1,4 @@
-import { n as viewsReducers } from "./slice-Caf98m0d2.js";
+import { n as viewsReducers } from "./slice-Cwt8jShq.js";
 import { map } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/views/src/store/side-effects.ts