fix all interfaces and params

Author: kiok46

lib/errors.ts

@@ -209,3 +209,16 @@ export class ThreadWithTokenUTXONotFoundError extends Error
 		super(message);
 	}
 }
+
+/**
+ * Error thrown when a previous bidder address is invalid.
+ */
+export class InvalidPrevBidderAddressError extends Error
+{
+	constructor()
+	{
+		const message = 'The previous bidder address is invalid';
+
+		super(message);
+	}
+}

lib/functions/accumulation.ts

@@ -2,7 +2,7 @@ import { TransactionBuilder } from 'cashscript';
 import { adjustLastOutputForFee, getAuthorizedContractUtxo, getRegistrationUtxo, getThreadUtxo } from '../util/index.js';
 import { UserUTXONotFoundError } from '../errors.js';
 import { createPlaceholderUnlocker, getThreadWithTokenUtxo } from '../util/utxo.js';
-import { FetchAccumulationUtxosResponse, FetchAccumulationUtxosParams, AccumulateParams } from '../interfaces/index.js';
+import { FetchAccumulationUtxosResponse, FetchAccumulationUtxosParams, AccumulateCoreParams } from '../interfaces/index.js';
 
 
 /**
@@ -77,7 +77,7 @@ export const accumulate = async ({
 	accumulatorContract,
 	utxos,
 	address,
-}: AccumulateParams): Promise<TransactionBuilder> =>
+}: AccumulateCoreParams): Promise<TransactionBuilder> =>
 {
 	const { threadNFTUTXO, registrationCounterUTXO, authorizedContractUTXO, threadWithTokenUTXO, userUTXO } = utxos;
 

lib/functions/claim-domain.ts

@@ -13,7 +13,9 @@ import {
 	getThreadUtxo,
 	validateName,
 } from '../util/index.js';
-import type { FetchClaimDomainUtxosParams, CreateClaimDomainTransactionParams } from '../interfaces/index.js';
+import type { FetchClaimDomainUtxosParams, CreateClaimDomainParams, FetchClaimDomainUtxosResponse } from '../interfaces/index.js';
+import { InvalidPrevBidderAddressError } from '../errors.js';
+
 
 /**
  * Fetches UTXOs required for claiming a domain.
@@ -24,15 +26,15 @@ import type { FetchClaimDomainUtxosParams, CreateClaimDomainTransactionParams }
  * @param {Contract} params.domainFactoryContract - The domain factory contract instance.
  * @param {string} params.name - The name of the domain.
  * @param {NetworkProvider} params.networkProvider - The network provider for blockchain interactions.
- * @returns {Promise<Object>} A promise that resolves to an object containing the necessary UTXOs.
+ * @returns {Promise<FetchClaimDomainUtxosResponse>} A promise that resolves to an object containing the necessary UTXOs.
  */
 export const fetchClaimDomainUtxos = async ({
 	category,
 	registryContract,
 	domainFactoryContract,
 	name,
 	networkProvider,
-}: FetchClaimDomainUtxosParams): Promise<any> =>
+}: FetchClaimDomainUtxosParams): Promise<FetchClaimDomainUtxosResponse> =>
 {
 	const [ registryUtxos, domainFactoryUtxos ] = await Promise.all([
 		networkProvider.getUtxos(registryContract.address),
@@ -75,58 +77,50 @@ export const fetchClaimDomainUtxos = async ({
  * and contracts. It ensures the domain name is valid, fetches necessary UTXOs if not provided,
  * and builds a transaction with multiple inputs and outputs to facilitate the domain claim process.
  *
- * @param {CreateClaimDomainTransactionParams} params - The parameters required to create the claim domain transaction.
+ * @param {CreateClaimDomainParams} params - The parameters required to create the claim domain transaction.
  * @param {string} params.category - The category of the domain.
  * @param {Contract} params.registryContract - The registry contract instance.
  * @param {Contract} params.domainFactoryContract - The domain factory contract instance.
  * @param {number} params.inactivityExpiryTime - The inactivity expiry time for the domain.
  * @param {number} params.maxPlatformFeePercentage - The maximum platform fee percentage.
  * @param {number} params.minWaitTime - The minimum wait time for the transaction.
  * @param {string} params.name - The name of the domain.
- * @param {NetworkProvider} params.networkProvider - The network provider for blockchain interactions.
- * @param {any} params.options - Additional options for the domain contract.
+ * @param {object} params.options - Additional options for the domain contract.
  * @param {string} [params.platformFeeAddress] - The address to receive the platform fee, if specified.
- * @param {any} [params.utxos] - The UTXOs to be used in the transaction, if already available.
+ * @param {FetchClaimDomainUtxosResponse} [params.utxos] - The UTXOs to be used in the transaction, if already available.
  * @returns {Promise<TransactionBuilder>} A promise that resolves to the transaction builder.
  * @throws {InvalidNameError} If the domain name is invalid.
- * @throws {Error} If the previous bidder address is invalid.
+ * @throws {InvalidPrevBidderAddressError} If the previous bidder address is invalid.
  */
-export const createClaimDomainTransaction = async ({
+export const createClaimDomainTransactionCore = async ({
 	category,
 	registryContract,
 	domainFactoryContract,
 	inactivityExpiryTime,
 	maxPlatformFeePercentage,
 	minWaitTime,
 	name,
-	networkProvider,
 	options,
 	platformFeeAddress,
 	utxos,
-}: CreateClaimDomainTransactionParams): Promise<TransactionBuilder> =>
+}: CreateClaimDomainParams): Promise<TransactionBuilder> =>
 {
 	validateName(name);
 	const { nameBin } = convertNameToBinaryAndHex(name);
 
-	if(!utxos)
-	{
-		utxos = await fetchClaimDomainUtxos({
-			category,
-			registryContract,
-			domainFactoryContract,
-			name,
-			networkProvider,
-		});
-	}
 	const { threadNFTUTXO, authorizedContractUTXO, domainMintingUTXO, runningAuctionUTXO } = utxos;
 
 	const bidderPKH = runningAuctionUTXO.token?.nft?.commitment.slice(0, 40);
+	if(!bidderPKH)
+	{
+		throw new InvalidPrevBidderAddressError();
+	}
 	const bidderLockingBytecode = convertPkhToLockingBytecode(bidderPKH);
 	const bidderAddressResult = lockingBytecodeToCashAddress({ bytecode: bidderLockingBytecode });
 
 	if(typeof bidderAddressResult !== 'object' || !bidderAddressResult.address)
 	{
-		throw new Error('Invalid prev bidder address');
+		throw new InvalidPrevBidderAddressError();
 	}
 
 	const bidderAddress = bidderAddressResult.address;
@@ -140,7 +134,7 @@ export const createClaimDomainTransaction = async ({
 
 	const registrationId = createRegistrationId(runningAuctionUTXO);
 
-	const transaction = await new TransactionBuilder({ provider: networkProvider })
+	const transaction = await new TransactionBuilder({ provider: options.provider })
 		.addInput(threadNFTUTXO, registryContract.unlock.call())
 		.addInput(authorizedContractUTXO, domainFactoryContract.unlock.call())
 		.addInput(domainMintingUTXO, registryContract.unlock.call())
@@ -149,11 +143,11 @@ export const createClaimDomainTransaction = async ({
 			to: registryContract.tokenAddress,
 			amount: threadNFTUTXO.satoshis,
 			token: {
-				category: threadNFTUTXO.token.category,
-				amount: threadNFTUTXO.token.amount + runningAuctionUTXO.token.amount,
+				category: threadNFTUTXO.token!.category,
+				amount: threadNFTUTXO.token!.amount + runningAuctionUTXO.token!.amount,
 				nft: {
-					capability: threadNFTUTXO.token.nft.capability,
-					commitment: threadNFTUTXO.token.nft.commitment,
+					capability: threadNFTUTXO.token!.nft!.capability,
+					commitment: threadNFTUTXO.token!.nft!.commitment,
 				},
 			},
 		})
@@ -165,19 +159,19 @@ export const createClaimDomainTransaction = async ({
 			to: registryContract.tokenAddress,
 			amount: domainMintingUTXO.satoshis,
 			token: {
-				category: domainMintingUTXO.token.category,
-				amount: domainMintingUTXO.token.amount,
+				category: domainMintingUTXO.token!.category,
+				amount: domainMintingUTXO.token!.amount,
 				nft: {
-					capability: domainMintingUTXO.token.nft.capability,
-					commitment: domainMintingUTXO.token.nft.commitment,
+					capability: domainMintingUTXO.token!.nft!.capability,
+					commitment: domainMintingUTXO.token!.nft!.commitment,
 				},
 			},
 		})
 		.addOutput({
 			to: domainContract.tokenAddress,
 			amount: BigInt(1000),
 			token: {
-				category: domainMintingUTXO.token.category,
+				category: domainMintingUTXO.token!.category,
 				amount: BigInt(0),
 				nft: {
 					capability: 'none',
@@ -189,7 +183,7 @@ export const createClaimDomainTransaction = async ({
 			to: domainContract.tokenAddress,
 			amount: BigInt(1000),
 			token: {
-				category: domainMintingUTXO.token.category,
+				category: domainMintingUTXO.token!.category,
 				amount: BigInt(0),
 				nft: {
 					capability: 'none',
@@ -201,7 +195,7 @@ export const createClaimDomainTransaction = async ({
 			to: convertCashAddressToTokenAddress(bidderAddress),
 			amount: BigInt(1000),
 			token: {
-				category: domainMintingUTXO.token.category,
+				category: domainMintingUTXO.token!.category,
 				amount: BigInt(0),
 				nft: {
 					capability: 'none',

lib/functions/create-records.ts

@@ -8,14 +8,24 @@ import {
 	findInternalAuthNFTUTXO,
 	findOwnershipNFTUTXO,
 } from '../util/index.js';
-import { CreateRecordsParams, FetchRecordsUtxosParams, FetchRecordsUtxosReturnType } from '../interfaces/index.js';
+import { CreateRecordsCoreParams, FetchRecordsUtxosParams, FetchRecordsUtxosResponse } from '../interfaces/index.js';
 
-
-export const fetchRecordsUtxos = async ({ name,
+/**
+ * Fetches the UTXOs required for creating records.
+ *
+ * @param {FetchRecordsUtxosParams} params - The parameters for fetching UTXOs.
+ * @returns {Promise<FetchRecordsUtxosResponse>} A promise that resolves to the fetched UTXOs.
+ * @throws {InternalAuthNFTUTXONotFoundError} If the internal authorization NFT UTXO is not found.
+ * @throws {UserOwnershipNFTUTXONotFoundError} If the user ownership NFT UTXO is not found.
+ * @throws {UserFundingUTXONotFoundError} If the user funding UTXO is not found.
+ */
+export const fetchRecordsUtxos = async ({
+	name,
 	category,
 	domainContract,
 	address,
-	networkProvider }: FetchRecordsUtxosParams): Promise<FetchRecordsUtxosReturnType> =>
+	networkProvider,
+}: FetchRecordsUtxosParams): Promise<FetchRecordsUtxosResponse> =>
 {
 	const [ domainUTXOs, userUtxos ] = await Promise.all([
 		networkProvider.getUtxos(domainContract.address),
@@ -50,7 +60,7 @@ export const fetchRecordsUtxos = async ({ name,
 /**
  * Creates a transaction for adding a record to a domain.
  *
- * @param {CreateRecordsParams} params - The parameters for creating the record transaction.
+ * @param {CreateRecordsCoreParams} params - The parameters for creating the record transaction.
  * @returns {Promise<TransactionBuilder>} A promise that resolves to the transaction builder.
  */
 export const createRecordsTransaction = async ({
@@ -59,7 +69,7 @@ export const createRecordsTransaction = async ({
 	networkProvider,
 	records,
 	utxos,
-}: CreateRecordsParams): Promise<TransactionBuilder> =>
+}: CreateRecordsCoreParams): Promise<TransactionBuilder> =>
 {
 	const { internalAuthNFTUTXO, ownershipNFTUTXO, fundingUTXO } = utxos;
 

lib/functions/fetch-records.ts

@@ -3,18 +3,25 @@ import { constructDomainContract, extractRecordsFromTransaction, getValidCandida
 import type { FetchRecordsParams } from '../interfaces/index.js';
 
 /**
- * Retrieves the records for a given domain.
+ * Fetches domain records based on the provided parameters.
  *
- * @param {string} name - The domain name to retrieve records for.
- * @returns {Promise<string[]>} A promise that resolves to the domain records.
+ * @param {FetchRecordsParams} params - The parameters for fetching domain records.
+ * @param {string} params.name - The domain name to retrieve records for.
+ * @param {boolean} [params.keepDuplicates=true] - Whether to keep duplicate records.
+ * @param {string} params.category - The category of the domain.
+ * @param {number} params.inactivityExpiryTime - The expiry time for domain inactivity.
+ * @param {object} params.options - Additional options for domain contract construction.
+ * @param {object} params.electrumClient - The Electrum client for blockchain interactions.
+ * @returns {Promise<string[]>} A promise that resolves to an array of domain records.
  */
-export const fetchRecords = async (
-	{ name,
-		keepDuplicates = true,
-		category,
-		inactivityExpiryTime,
-		options,
-		electrumClient }: FetchRecordsParams): Promise<string[]> =>
+export const fetchRecords = async ({
+	name,
+	keepDuplicates = true,
+	category,
+	inactivityExpiryTime,
+	options,
+	electrumClient,
+}: FetchRecordsParams): Promise<string[]> =>
 {
 	const domainContract = constructDomainContract({
 		name,

lib/functions/get-domain.ts

@@ -1,26 +1,24 @@
 import { constructDomainContract, getDomainPartialBytecode } from '../util/contract.js';
 import { hexToBin, binToHex } from '@bitauth/libauth';
-import { DomainInfo } from '../interfaces/index.js';
+import { DomainInfo, GetDomainParams } from '../interfaces/index.js';
 import { buildLockScriptP2SH32, lockScriptToAddress, pushDataHex, validateName } from '../util/index.js';
 
 
-export interface GetDomainParams
-{
-	name: string;
-	category: string;
-	inactivityExpiryTime: number;
-	options: any;
-}
-
 /**
-	 * Retrieves the domain information for a given full domain name.
-	 *
-	 * @param {string} name - The domain name to retrieve information for.
-	 * @returns {Promise<DomainInfo>} A promise that resolves to an object containing the domain address, contract, and UTXOs.
-	 */
+ * Retrieves the domain information for a specified domain name.
+ *
+ * @param {GetDomainParams} params - The parameters required to get domain details.
+ * @param {string} params.name - The domain name to retrieve information for.
+ * @param {string} params.category - The category of the domain.
+ * @param {number} params.inactivityExpiryTime - The inactivity expiry time for the domain.
+ * @param {object} params.options - Additional options for the domain contract.
+ * @param {AddressType} params.options.addressType - The type of address used.
+ * @param {NetworkProvider} params.options.provider - The network provider for blockchain interactions.
+ * @returns {Promise<DomainInfo>} A promise that resolves to an object containing the domain address and contract.
+ */
 export const getDomain = async ({ name, category, inactivityExpiryTime, options }: GetDomainParams): Promise<DomainInfo> =>
 {
-	// Extract the domain name from the full domain name.
+	// Validate the domain name.
 	validateName(name);
 
 	// Reverse the category bytes for use in contract parameters.

lib/functions/get-past-auctions.ts

@@ -1,18 +1,18 @@
 import { binToHex, hexToBin, decodeTransaction } from '@bitauth/libauth';
 import { fetchHistory, fetchTransaction } from '@electrum-cash/protocol';
-import type { GetPastAuctionsParams, PastAuctionResult } from '../interfaces/index.js';
+import type { GetPastAuctionsParams, PastAuctionResponse } from '../interfaces/index.js';
 
 /**
-	 * Retrieves the transaction history of auctions.
-	 *
-	 * @returns {Promise<PastAuctionResult[]>} A promise that resolves to an array of transaction history objects,
-   * each containing a transaction hex and an auction name.
-	 */
+ * Retrieves the transaction history of auctions.
+ *
+ * @returns {Promise<PastAuctionResponse[]>} A promise that resolves to an array of transaction history objects,
+ * each containing a transaction hex and an auction name.
+ */
 export const getPastAuctions = async ({
 	category,
 	electrumClient,
 	domainContract,
-}: GetPastAuctionsParams): Promise<PastAuctionResult[]> =>
+}: GetPastAuctionsParams): Promise<PastAuctionResponse[]> =>
 {
 	// @ts-ignore
 	const history = await fetchHistory(electrumClient, domainContract.address);
@@ -75,5 +75,5 @@ export const getPastAuctions = async ({
 		};
 	}));
 
-	return validTransactions.filter(tx => tx !== null) as PastAuctionResult[];
+	return validTransactions.filter(tx => tx !== null) as PastAuctionResponse[];
 };

lib/functions/index.ts

@@ -1,4 +1,4 @@
-export { fetchClaimDomainUtxos, createClaimDomainTransaction } from './claim-domain.js';
+export { fetchClaimDomainUtxos, createClaimDomainTransactionCore } from './claim-domain.js';
 export { fetchAuctionUtxos, createAuctionTransactionCore } from './create-auction.js';
 export { fetchBidUtxos, createBidTransactionCore } from './create-bid.js';
 export { fetchDuplicateAuctionGuardUtxos, penalizeDuplicateAuction } from './penalise-duplicate-auction.js';