@txnlab/deflex 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,994 @@
+import { AlgorandClient } from "@algorandfoundation/algokit-utils";
+import { LogicSigAccount, Transaction, assignGroupID, decodeUnsignedTransaction, isValidAddress, makeApplicationOptInTxnFromObject, msgpackRawDecode, signLogicSigTransactionObject, signTransaction, waitForConfirmation } from "algosdk";
+
+//#region src/constants.ts
+/**
+* Supported DEX protocols for swap routing
+*/
+let Protocol = /* @__PURE__ */ function(Protocol$1) {
+	Protocol$1["TinymanV2"] = "TinymanV2";
+	Protocol$1["Algofi"] = "Algofi";
+	Protocol$1["Algomint"] = "Algomint";
+	Protocol$1["Pact"] = "Pact";
+	Protocol$1["Folks"] = "Folks";
+	Protocol$1["TAlgo"] = "TAlgo";
+	return Protocol$1;
+}({});
+/**
+* Deprecated protocols that are automatically excluded from routing
+*
+* @internal
+*/
+const DEPRECATED_PROTOCOLS = ["Humble", "Tinyman"];
+/** Default Algod node URI for mainnet */
+const DEFAULT_ALGOD_URI = "https://mainnet-api.4160.nodely.dev/";
+/** Default Algod node token (empty for public nodes) */
+const DEFAULT_ALGOD_TOKEN = "";
+/** Default Algod node port */
+const DEFAULT_ALGOD_PORT = 443;
+/** Default Deflex API base URL */
+const DEFAULT_API_BASE_URL = "https://deflex.txnlab.dev/api";
+/** Default fee in basis points (0.15%) */
+const DEFAULT_FEE_BPS = 15;
+/** Maximum allowed fee in basis points (3.00%) */
+const MAX_FEE_BPS = 300;
+/** Default maximum transaction group size */
+const DEFAULT_MAX_GROUP_SIZE = 16;
+/** Default maximum routing depth (number of hops) */
+const DEFAULT_MAX_DEPTH = 4;
+/** Default auto opt-in setting (automatic asset/app opt-in detection) */
+const DEFAULT_AUTO_OPT_IN = false;
+/** Default number of rounds to wait for transaction confirmation */
+const DEFAULT_CONFIRMATION_ROUNDS = 4;
+
+//#endregion
+//#region src/composer.ts
+/**
+* Status of the SwapComposer transaction group lifecycle
+*/
+let SwapComposerStatus = /* @__PURE__ */ function(SwapComposerStatus$1) {
+	/** The atomic group is still under construction. */
+	SwapComposerStatus$1[SwapComposerStatus$1["BUILDING"] = 0] = "BUILDING";
+	/** The atomic group has been finalized, but not yet signed. */
+	SwapComposerStatus$1[SwapComposerStatus$1["BUILT"] = 1] = "BUILT";
+	/** The atomic group has been finalized and signed, but not yet submitted to the network. */
+	SwapComposerStatus$1[SwapComposerStatus$1["SIGNED"] = 2] = "SIGNED";
+	/** The atomic group has been finalized, signed, and submitted to the network. */
+	SwapComposerStatus$1[SwapComposerStatus$1["SUBMITTED"] = 3] = "SUBMITTED";
+	/** The atomic group has been finalized, signed, submitted, and successfully committed to a block. */
+	SwapComposerStatus$1[SwapComposerStatus$1["COMMITTED"] = 4] = "COMMITTED";
+	return SwapComposerStatus$1;
+}({});
+/**
+* Composer for building and executing atomic swap transaction groups
+*
+* The SwapComposer allows you to build complex transaction groups by adding custom
+* transactions before and after swap transactions. It handles pre-signed transactions,
+* automatic app opt-ins, and provides a fluent API for transaction group construction.
+*
+* @example
+* ```typescript
+* const quote = await deflex.fetchQuote({ ... })
+* const composer = await deflex.newSwap({ quote, address, slippage })
+*
+* await composer
+*   .addTransaction(customTxn)
+*   .addSwapTransactions()
+*   .execute(signer)
+* ```
+*/
+var SwapComposer = class SwapComposer {
+	/** The maximum size of an atomic transaction group. */
+	static MAX_GROUP_SIZE = 16;
+	status = SwapComposerStatus.BUILDING;
+	transactions = [];
+	swapTransactionsAdded = false;
+	signedTxns = [];
+	txIds = [];
+	quote;
+	deflexTxns;
+	algorand;
+	address;
+	signer;
+	/**
+	* Create a new SwapComposer instance
+	*
+	* Note: Most developers should use DeflexClient.newSwap() instead of constructing
+	* this directly, as the factory method handles fetching swap transactions automatically.
+	*
+	* @param config - Configuration for the composer
+	* @param config.quote - The quote response from fetchQuote()
+	* @param config.deflexTxns - The swap transactions from fetchSwapTransactions()
+	* @param config.algorand - AlgorandClient instance for blockchain operations
+	* @param config.address - The address of the account that will sign transactions
+	* @param config.signer - Transaction signer function
+	*/
+	constructor(config) {
+		if (!config.quote) throw new Error("Quote is required");
+		if (!config.deflexTxns) throw new Error("Swap transactions are required");
+		if (config.deflexTxns.length === 0) throw new Error("Swap transactions array cannot be empty");
+		if (!config.algorand) throw new Error("AlgorandClient instance is required");
+		if (!config.signer) throw new Error("Signer is required");
+		this.quote = config.quote;
+		this.deflexTxns = config.deflexTxns;
+		this.algorand = config.algorand;
+		this.address = this.validateAddress(config.address);
+		this.signer = config.signer;
+	}
+	/**
+	* Get the status of this composer's transaction group
+	*
+	* @returns The current status of the transaction group
+	*/
+	getStatus() {
+		return this.status;
+	}
+	/**
+	* Get the number of transactions currently in this atomic group
+	*
+	* @returns The number of transactions in the group
+	*/
+	count() {
+		return this.transactions.length;
+	}
+	/**
+	* Add a transaction to the atomic group
+	*
+	* Transactions are added in the order methods are called. For example:
+	* ```typescript
+	* composer
+	*   .addTransaction(txn1)      // Added first
+	*   .addSwapTransactions()     // Added second
+	*   .addTransaction(txn2)      // Added third
+	* ```
+	*
+	* @param transaction - The transaction to add
+	* @returns This composer instance for chaining
+	* @throws Error if the composer is not in the BUILDING status
+	* @throws Error if the maximum group size is exceeded
+	*/
+	addTransaction(transaction) {
+		if (this.status !== SwapComposerStatus.BUILDING) throw new Error("Cannot add transactions when composer status is not BUILDING");
+		if (this.transactions.length === SwapComposer.MAX_GROUP_SIZE) throw new Error(`Adding an additional transaction exceeds the maximum atomic group size of ${SwapComposer.MAX_GROUP_SIZE}`);
+		this.transactions.push({ txn: transaction });
+		return this;
+	}
+	/**
+	* Add swap transactions to the atomic group
+	*
+	* This method automatically processes required app opt-ins and adds all swap
+	* transactions from the quote. Can only be called once per composer instance.
+	*
+	* @returns This composer instance for chaining
+	* @throws Error if the swap transactions have already been added
+	* @throws Error if the composer is not in the BUILDING status
+	* @throws Error if the maximum group size is exceeded
+	*/
+	async addSwapTransactions() {
+		if (this.swapTransactionsAdded) throw new Error("Swap transactions have already been added");
+		if (this.status !== SwapComposerStatus.BUILDING) throw new Error("Cannot add swap transactions when composer status is not BUILDING");
+		const processedTxns = await this.processSwapTransactions();
+		if (this.transactions.length + processedTxns.length > SwapComposer.MAX_GROUP_SIZE) throw new Error(`Adding swap transactions exceeds the maximum atomic group size of ${SwapComposer.MAX_GROUP_SIZE}`);
+		this.transactions.push(...processedTxns);
+		this.swapTransactionsAdded = true;
+		return this;
+	}
+	/**
+	* Sign the transaction group
+	*
+	* Automatically adds swap transactions if not already added, builds the atomic group,
+	* and signs all transactions using the configured signer.
+	*
+	* @returns A promise that resolves to an array of signed transaction blobs
+	*
+	* @example
+	* ```typescript
+	* const signedTxns = await composer.sign()
+	* ```
+	*/
+	async sign() {
+		if (this.status >= SwapComposerStatus.SIGNED) return this.signedTxns;
+		if (!this.swapTransactionsAdded) await this.addSwapTransactions();
+		const transactions = this.buildGroup();
+		const userTransactions = [];
+		const userTransactionIndexes = [];
+		const deflexSignedTxns = [];
+		for (let i = 0; i < transactions.length; i++) {
+			const item = transactions[i];
+			if (!item) continue;
+			if (!item.deflexSignature) {
+				userTransactions.push(item.txn);
+				userTransactionIndexes.push(userTransactions.length - 1);
+			} else {
+				const signedTxnBlob = this.signDeflexTransaction(item.txn, item.deflexSignature);
+				deflexSignedTxns.push(signedTxnBlob);
+			}
+		}
+		let userSignedTxns = [];
+		if (userTransactions.length > 0) userSignedTxns = await this.signer(userTransactions, userTransactionIndexes);
+		const signedTxns = [];
+		let userSignedIndex = 0;
+		let deflexSignedIndex = 0;
+		for (const item of transactions) if (!item.deflexSignature) {
+			const signedTxn = userSignedTxns[userSignedIndex];
+			if (signedTxn) signedTxns.push(signedTxn);
+			userSignedIndex++;
+		} else {
+			const deflexSignedTxn = deflexSignedTxns[deflexSignedIndex];
+			if (deflexSignedTxn) signedTxns.push(deflexSignedTxn);
+			deflexSignedIndex++;
+		}
+		const txIds = this.transactions.map((t) => t.txn.txID());
+		this.signedTxns = signedTxns;
+		this.txIds = txIds;
+		this.status = SwapComposerStatus.SIGNED;
+		return signedTxns;
+	}
+	/**
+	* Submit the signed transactions to the network
+	*
+	* This method signs the transaction group (if not already signed) and submits
+	* it to the Algorand network. Does not wait for confirmation.
+	*
+	* @returns The transaction IDs
+	* @throws Error if the transaction group has already been submitted
+	*
+	* @example
+	* ```typescript
+	* const txIds = await composer.submit()
+	* console.log('Submitted transactions:', txIds)
+	* ```
+	*/
+	async submit() {
+		if (this.status > SwapComposerStatus.SUBMITTED) throw new Error("Transaction group cannot be resubmitted");
+		const stxns = await this.sign();
+		await this.algorand.client.algod.sendRawTransaction(stxns).do();
+		this.status = SwapComposerStatus.SUBMITTED;
+		return this.txIds;
+	}
+	/**
+	* Execute the swap
+	*
+	* Signs the transaction group, submits it to the network, and waits for confirmation.
+	* This is the primary method for executing swaps and combines sign(), submit(), and
+	* waitForConfirmation() into a single call.
+	*
+	* @param waitRounds - The number of rounds to wait for confirmation (default: 4)
+	* @returns Object containing the confirmed round and transaction IDs
+	* @throws Error if the transaction group has already been committed
+	*
+	* @example
+	* ```typescript
+	* const result = await composer.execute()
+	* console.log(`Confirmed in round ${result.confirmedRound}`)
+	* console.log('Transaction IDs:', result.txIds)
+	* ```
+	*/
+	async execute(waitRounds = DEFAULT_CONFIRMATION_ROUNDS) {
+		if (this.status === SwapComposerStatus.COMMITTED) throw new Error("Transaction group has already been executed successfully");
+		const txIds = await this.submit();
+		const confirmedTxnInfo = await waitForConfirmation(this.algorand.client.algod, txIds[0], waitRounds);
+		this.status = SwapComposerStatus.COMMITTED;
+		return {
+			confirmedRound: confirmedTxnInfo.confirmedRound,
+			txIds
+		};
+	}
+	/**
+	* Validates an Algorand address
+	*/
+	validateAddress(address) {
+		if (!isValidAddress(address)) throw new Error(`Invalid Algorand address: ${address}`);
+		return address;
+	}
+	/**
+	* Processes app opt-ins and decodes swap transactions from API response
+	*/
+	async processSwapTransactions() {
+		const appOptIns = await this.processRequiredAppOptIns();
+		const swapTxns = [];
+		for (let i = 0; i < this.deflexTxns.length; i++) {
+			const deflexTxn = this.deflexTxns[i];
+			if (!deflexTxn) continue;
+			try {
+				const txn = decodeUnsignedTransaction(Buffer.from(deflexTxn.data, "base64"));
+				delete txn.group;
+				if (deflexTxn.signature !== false) swapTxns.push({
+					txn,
+					deflexSignature: deflexTxn.signature
+				});
+				else swapTxns.push({ txn });
+			} catch (error) {
+				throw new Error(`Failed to process swap transaction at index ${i}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		return [...appOptIns, ...swapTxns];
+	}
+	/**
+	* Creates opt-in transactions for apps the user hasn't opted into yet
+	*/
+	async processRequiredAppOptIns() {
+		const userApps = (await this.algorand.account.getInformation(this.address))?.appsLocalState?.map((app) => Number(app.id)) || [];
+		const appsToOptIn = this.quote.requiredAppOptIns.filter((appId) => !userApps.includes(appId));
+		const appOptInTxns = [];
+		if (appsToOptIn.length > 0) {
+			const suggestedParams = await this.algorand.client.algod.getTransactionParams().do();
+			for (const appId of appsToOptIn) {
+				const optInTxn = makeApplicationOptInTxnFromObject({
+					sender: this.address,
+					appIndex: appId,
+					suggestedParams
+				});
+				appOptInTxns.push(optInTxn);
+			}
+		}
+		return appOptInTxns.map((txn) => ({ txn }));
+	}
+	/**
+	* Finalizes the transaction group by assigning group IDs
+	*
+	* The composer's status will be at least BUILT after executing this method.
+	*/
+	buildGroup() {
+		if (this.status === SwapComposerStatus.BUILDING) {
+			if (this.transactions.length === 0) throw new Error("Cannot build a group with 0 transactions");
+			if (this.transactions.length > 1) assignGroupID(this.transactions.map((t) => t.txn));
+			this.status = SwapComposerStatus.BUILT;
+		}
+		return this.transactions;
+	}
+	/**
+	* Re-signs a Deflex transaction using the provided logic signature or secret key
+	*/
+	signDeflexTransaction(transaction, signature) {
+		try {
+			if (signature.type === "logic_signature") {
+				const valueArray = signature.value;
+				const decoded = msgpackRawDecode(new Uint8Array(Object.values(valueArray)));
+				if (!decoded.lsig) throw new Error("Logic signature structure missing lsig field");
+				const lsig = decoded.lsig;
+				return signLogicSigTransactionObject(transaction, new LogicSigAccount(lsig.l, lsig.arg)).blob;
+			} else if (signature.type === "secret_key") {
+				const valueArray = signature.value;
+				return signTransaction(transaction, new Uint8Array(Object.values(valueArray))).blob;
+			} else throw new Error(`Unsupported signature type: ${signature.type}`);
+		} catch (error) {
+			throw new Error(`Failed to re-sign transaction: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/quote.ts
+/**
+* Wrapper class for Deflex quote responses with convenience methods
+*
+* The DeflexQuote class provides a developer-friendly interface for working with
+* swap quotes from the Deflex API. It exposes all quote properties via getters
+* and provides additional convenience methods for derived data.
+*
+* @example
+* ```typescript
+* const quote = await deflex.newQuote({
+*   address: 'ABC...',
+*   fromAssetId: 0,
+*   toAssetId: 31566704,
+*   amount: 1_000_000,
+* })
+*
+* // Access quote properties directly
+* console.log(quote.quote)              // bigint (quoted amount)
+* console.log(quote.fromAssetId)        // number
+* console.log(quote.toAssetId)          // number
+*
+* // Access metadata
+* console.log(quote.amount)             // bigint (original request amount)
+* console.log(quote.address)            // string | undefined
+* console.log(quote.createdAt)          // number
+*
+* // Use convenience methods for derived data
+* const minReceivedAmount = quote.getSlippageAmount(slippage) // fixed-input swap
+* const maxSentAmount = quote.getSlippageAmount(slippage) // fixed-output swap
+* ```
+*/
+var DeflexQuote = class {
+	_response;
+	_amount;
+	_address;
+	_createdAt;
+	/**
+	* Create a new DeflexQuote instance
+	*
+	* Note: Most developers should use DeflexClient.newQuote() instead of constructing
+	* this directly, as the factory method handles fetching the quote automatically.
+	*
+	* @param config - Configuration for the quote instance
+	* @param config.response - The raw quote response from the Deflex API
+	* @param config.amount - The original amount from the quote request
+	* @param config.address - Optional address parameter from the quote request
+	*/
+	constructor(config) {
+		if (!config?.response) throw new Error("Quote response is required");
+		if (config.amount === void 0 || config.amount === null) throw new Error("Amount is required");
+		this._response = config.response;
+		this._amount = BigInt(config.amount);
+		this._address = config.address;
+		this._createdAt = Date.now();
+	}
+	/**
+	* Get the raw quote response from the Deflex API
+	*
+	* @returns The raw quote response from the Deflex API
+	*/
+	get response() {
+		return this._response;
+	}
+	/**
+	* The original amount from the quote request (in base units)
+	*
+	* This is the amount that was provided when fetching the quote.
+	* For fixed-input swaps, this is the input amount.
+	* For fixed-output swaps, this is the desired output amount.
+	*
+	* @example
+	* ```typescript
+	* const quote = await deflex.newQuote({
+	*   fromAssetId: 0,
+	*   toAssetId: 31566704,
+	*   amount: 1_000_000, // 1 ALGO
+	*   type: 'fixed-input'
+	* })
+	* console.log(quote.amount) // 1000000n (input amount)
+	* console.log(quote.quote)  // 5000000n (output amount quoted)
+	* ```
+	*/
+	get amount() {
+		return this._amount;
+	}
+	/**
+	* The address parameter from the quote request
+	*
+	* This is the address that was provided when fetching the quote (if any).
+	* Useful for tracking which account the quote was fetched for, especially
+	* when using autoOptIn functionality.
+	*/
+	get address() {
+		return this._address;
+	}
+	/**
+	* Timestamp when the quote was created (in milliseconds)
+	*
+	* Can be used to determine quote freshness. Quotes may become stale
+	* over time as market conditions change.
+	*
+	* @example
+	* ```typescript
+	* const ageInSeconds = (Date.now() - quote.createdAt) / 1000
+	* if (ageInSeconds > 30) {
+	*   console.log('Quote may be stale, consider refreshing')
+	* }
+	* ```
+	*/
+	get createdAt() {
+		return this._createdAt;
+	}
+	/**
+	* The quoted output amount or input amount (depending on quote type)
+	*
+	* For fixed-input swaps: This is the output amount you'll receive
+	* For fixed-output swaps: This is the input amount you'll need to provide
+	*
+	* @returns The quote amount as a bigint in base units
+	*/
+	get quote() {
+		const rawQuote = this._response.quote;
+		return rawQuote === "" ? 0n : BigInt(rawQuote);
+	}
+	/**
+	* Profit information for the swap
+	*/
+	get profit() {
+		return this._response.profit;
+	}
+	/**
+	* Baseline price without fees
+	*/
+	get priceBaseline() {
+		return this._response.priceBaseline;
+	}
+	/**
+	* Price impact for the user
+	*/
+	get userPriceImpact() {
+		return this._response.userPriceImpact;
+	}
+	/**
+	* Overall market price impact
+	*/
+	get marketPriceImpact() {
+		return this._response.marketPriceImpact;
+	}
+	/**
+	* USD value of input amount
+	*/
+	get usdIn() {
+		return this._response.usdIn;
+	}
+	/**
+	* USD value of output amount
+	*/
+	get usdOut() {
+		return this._response.usdOut;
+	}
+	/**
+	* The routing path(s) for the swap
+	*/
+	get route() {
+		return this._response.route;
+	}
+	/**
+	* Flattened view of routing percentages by protocol
+	*/
+	get flattenedRoute() {
+		return this._response.flattenedRoute;
+	}
+	/**
+	* Individual quotes from each DEX
+	*/
+	get quotes() {
+		return this._response.quotes;
+	}
+	/**
+	* App IDs that require opt-in for this swap
+	*/
+	get requiredAppOptIns() {
+		return this._response.requiredAppOptIns;
+	}
+	/**
+	* Encrypted transaction payload for generating swap transactions
+	*/
+	get txnPayload() {
+		return this._response.txnPayload;
+	}
+	/**
+	* Fees charged by each protocol
+	*/
+	get protocolFees() {
+		return this._response.protocolFees;
+	}
+	/**
+	* Input asset ID
+	*/
+	get fromAssetId() {
+		return this._response.fromASAID;
+	}
+	/**
+	* Output asset ID
+	*/
+	get toAssetId() {
+		return this._response.toASAID;
+	}
+	/**
+	* Quote type
+	*/
+	get type() {
+		return this._response.type;
+	}
+	/**
+	* Performance timing data
+	*/
+	get timing() {
+		return this._response.timing;
+	}
+	/**
+	* Calculate the slippage-adjusted amount
+	*
+	* For fixed-input swaps: Returns the minimum amount you'll receive after slippage
+	* For fixed-output swaps: Returns the maximum amount you'll need to send after slippage
+	*
+	* @param slippage - Slippage tolerance as a percentage (e.g., 1 for 1%)
+	* @returns The slippage-adjusted amount as a bigint
+	*
+	* @example
+	* ```typescript
+	* // Fixed-input swap: 1 ALGO -> USDC
+	* const quote = await deflex.newQuote({
+	*   fromAssetId: 0,
+	*   toAssetId: 31566704,
+	*   amount: 1_000_000,
+	*   type: 'fixed-input'
+	* })
+	*
+	* // Get minimum output with 1% slippage
+	* const minOutput = quote.getSlippageAmount(1)
+	* console.log(`Minimum you'll receive: ${minOutput}`)
+	* ```
+	*
+	* @example
+	* ```typescript
+	* // Fixed-output swap: ALGO -> 10 USDC
+	* const quote = await deflex.newQuote({
+	*   fromAssetId: 0,
+	*   toAssetId: 31566704,
+	*   amount: 10_000_000,
+	*   type: 'fixed-output'
+	* })
+	*
+	* // Get maximum input with 1% slippage
+	* const maxInput = quote.getSlippageAmount(1)
+	* console.log(`Maximum you'll need to send: ${maxInput}`)
+	* ```
+	*/
+	getSlippageAmount(slippage) {
+		const quoteAmount = this.quote;
+		const slippageBps = BigInt(Math.floor(slippage * 100));
+		if (this._response.type === "fixed-input") return quoteAmount * (10000n - slippageBps) / 10000n;
+		else return quoteAmount * (10000n + slippageBps) / 10000n;
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/**
+* HTTP error with status code and response data
+*/
+var HTTPError = class extends Error {
+	constructor(status, statusText, data) {
+		super(`HTTP ${status} ${statusText}`);
+		this.status = status;
+		this.statusText = statusText;
+		this.data = data;
+		this.name = "HTTPError";
+	}
+};
+/**
+* Make an HTTP request and parse JSON response
+*
+* Simple wrapper around native fetch for API calls. Throws HTTPError for
+* non-2xx responses.
+*
+* @param url - The URL to request
+* @param options - Fetch options
+* @returns Parsed JSON response
+* @throws HTTPError if the response status is not ok
+*/
+async function request(url, options) {
+	const response = await fetch(url, options);
+	if (!response.ok) {
+		let errorData;
+		try {
+			errorData = await response.json();
+		} catch {
+			try {
+				errorData = await response.text();
+			} catch {
+				errorData = "Failed to parse error response";
+			}
+		}
+		throw new HTTPError(response.status, response.statusText, JSON.stringify(errorData));
+	}
+	return response.json();
+}
+
+//#endregion
+//#region src/client.ts
+/**
+* Client for interacting with the Deflex order router API
+*
+* The DeflexClient provides methods to fetch swap quotes and create transaction composers
+* for executing swaps on the Algorand blockchain. It handles API communication, transaction
+* validation, and automatic asset/app opt-in detection.
+*
+* @example
+* ```typescript
+* const deflex = new DeflexClient({
+*   apiKey: 'your-api-key',
+* })
+* ```
+*
+* @example
+* ```typescript
+* const deflex = new DeflexClient({
+*   apiKey: 'your-api-key',
+*   algodUri: 'https://mainnet-api.4160.nodely.dev/',
+*   algodToken: '',
+*   algodPort: 443,
+*   referrerAddress: 'REFERRER_ADDRESS...',
+*   feeBps: 15,
+*   autoOptIn: false,
+* })
+* ```
+*/
+var DeflexClient = class {
+	baseUrl = DEFAULT_API_BASE_URL;
+	config;
+	algorand;
+	/**
+	* Create a new DeflexClient instance
+	*
+	* @param config - Configuration parameters
+	* @param config.apiKey - API key for Deflex API (required)
+	* @param config.algodUri - Algod node URI (default: https://mainnet-api.4160.nodely.dev/)
+	* @param config.algodToken - Algod node token (default: '')
+	* @param config.algodPort - Algod node port (default: 443)
+	* @param config.referrerAddress - Referrer address for fee sharing (receives 25% of swap fees)
+	* @param config.feeBps - Fee in basis points (default: 15 = 0.15%, max: 300 = 3.00%)
+	* @param config.autoOptIn - Automatically detect and add required opt-in transactions (default: false)
+	*/
+	constructor(config) {
+		this.config = {
+			apiKey: this.validateApiKey(config.apiKey),
+			algodUri: config.algodUri ?? DEFAULT_ALGOD_URI,
+			algodToken: config.algodToken ?? DEFAULT_ALGOD_TOKEN,
+			algodPort: config.algodPort ?? DEFAULT_ALGOD_PORT,
+			referrerAddress: config.referrerAddress ? this.validateAddress(config.referrerAddress) : void 0,
+			feeBps: this.validateFeeBps(config.feeBps ?? DEFAULT_FEE_BPS),
+			autoOptIn: config.autoOptIn ?? DEFAULT_AUTO_OPT_IN
+		};
+		this.algorand = AlgorandClient.fromConfig({ algodConfig: {
+			server: this.config.algodUri,
+			port: this.config.algodPort,
+			token: this.config.algodToken
+		} });
+	}
+	/**
+	* Fetch a swap quote from the Deflex API
+	*
+	* Requests optimal swap routing from the Deflex API. The quote includes routing
+	* information, price impact, required opt-ins, and an encrypted transaction payload.
+	*
+	* @param params - Parameters for the quote request
+	* @param params.fromASAID - The ID of the asset to swap from
+	* @param params.toASAID - The ID of the asset to swap to
+	* @param params.amount - The amount of the asset to swap in base units
+	* @param params.type - The type of the quote (default: 'fixed-input')
+	* @param params.disabledProtocols - List of protocols to disable (default: [])
+	* @param params.maxGroupSize - The maximum group size (default: 16)
+	* @param params.maxDepth - The maximum depth (default: 4)
+	* @param params.address - The address of the account that will perform the swap (recommended when using `config.autoOptIn` or `params.optIn`)
+	* @param params.optIn - Whether to include asset opt-in transaction
+	*   - If true: API reduces maxGroupSize by 1 and includes opt-in (always included, even if not needed)
+	*   - If false: No opt-in transaction included
+	*   - If undefined: Falls back to `config.autoOptIn` behavior with account check (if `params.address` is provided)
+	* @returns A FetchQuoteResponse object with routing information
+	*
+	* @example
+	* ```typescript
+	* const quote = await deflex.fetchQuote({
+	*   address: 'ABC...',
+	*   fromASAID: 0,           // ALGO
+	*   toASAID: 31566704,      // USDC
+	*   amount: 1_000_000,      // 1 ALGO
+	* })
+	* ```
+	*/
+	async fetchQuote(params) {
+		const { fromASAID, toASAID, amount, type = "fixed-input", disabledProtocols = [], maxGroupSize = DEFAULT_MAX_GROUP_SIZE, maxDepth = DEFAULT_MAX_DEPTH, optIn, address } = params;
+		const allDisabledProtocols = [...new Set([...DEPRECATED_PROTOCOLS, ...disabledProtocols])];
+		let includeOptIn = optIn;
+		if (includeOptIn === void 0 && this.config.autoOptIn) if (address) includeOptIn = await this.needsAssetOptIn(this.validateAddress(address), toASAID);
+		else console.warn("autoOptIn is enabled but no address provided to fetchQuote(). Asset opt-in check skipped.");
+		const url = new URL(`${this.baseUrl}/fetchQuote`);
+		url.searchParams.append("apiKey", this.config.apiKey);
+		url.searchParams.append("algodUri", this.config.algodUri);
+		url.searchParams.append("algodToken", this.config.algodToken);
+		url.searchParams.append("algodPort", String(this.config.algodPort));
+		url.searchParams.append("feeBps", this.config.feeBps.toString());
+		url.searchParams.append("fromASAID", BigInt(fromASAID).toString());
+		url.searchParams.append("toASAID", BigInt(toASAID).toString());
+		url.searchParams.append("amount", BigInt(amount).toString());
+		url.searchParams.append("type", type);
+		url.searchParams.append("disabledProtocols", allDisabledProtocols.join(","));
+		url.searchParams.append("maxGroupSize", maxGroupSize.toString());
+		url.searchParams.append("maxDepth", maxDepth.toString());
+		url.searchParams.append("optIn", String(includeOptIn));
+		if (this.config.referrerAddress) url.searchParams.append("referrerAddress", this.config.referrerAddress);
+		return request(url.toString());
+	}
+	/**
+	* Check if asset opt-in is required for the output asset
+	*
+	* Convenience method to determine if an address needs to opt into the output asset
+	* of a swap. This is useful when you want to get a quote without requiring wallet
+	* connection upfront, but need to know whether to set `optIn: true` in fetchQuote()
+	* to ensure proper routing (as opt-ins reduce maxGroupSize by 1).
+	*
+	* Note: If you enable `config.autoOptIn`, this check is handled automatically when
+	* an address is provided to fetchQuote().
+	*
+	* @param address - The address to check
+	* @param assetId - The output asset ID to check
+	* @returns True if asset opt-in is required, false otherwise (always false for ALGO)
+	*
+	* @example
+	* ```typescript
+	* // Check if opt-in needed for output asset before fetching quote
+	* const needsOptIn = await deflex.needsAssetOptIn(userAddress, toAssetId)
+	* const quote = await deflex.fetchQuote({
+	*   fromAssetId,
+	*   toAssetId,
+	*   amount,
+	*   optIn: needsOptIn,
+	* })
+	* ```
+	*/
+	async needsAssetOptIn(address, assetId) {
+		const accountInfo = await this.algorand.account.getInformation(address);
+		return BigInt(assetId) !== 0n && accountInfo?.assets?.find((asset) => asset.assetId === BigInt(assetId)) === void 0;
+	}
+	/**
+	* Fetch swap transactions from the Deflex API
+	*
+	* Decrypts the quote payload and generates executable swap transactions for the
+	* specified signer address with the given slippage tolerance.
+	*
+	* @param params - Parameters for the swap transaction request
+	* @param params.quote - The quote response from fetchQuote()
+	* @param params.address - The address of the signer
+	* @param params.slippage - The slippage tolerance as a percentage (e.g., 1 for 1%)
+	* @returns A FetchSwapTxnsResponse object with transaction data
+	*/
+	async fetchSwapTransactions(params) {
+		const { quote, address, slippage } = params;
+		this.validateAddress(address);
+		const url = new URL(`${this.baseUrl}/fetchExecuteSwapTxns`);
+		const body = {
+			apiKey: this.config.apiKey,
+			address,
+			txnPayloadJSON: quote.txnPayload,
+			slippage
+		};
+		return request(url.toString(), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	/**
+	* Fetch a quote and return a DeflexQuote wrapper instance
+	*
+	* This is the recommended way to fetch quotes. It wraps the raw API response
+	* in a DeflexQuote class that provides convenient methods for accessing quote data.
+	*
+	* @param params - Parameters for the quote request
+	* @param params.fromAssetId - The ID of the asset to swap from
+	* @param params.toAssetId - The ID of the asset to swap to
+	* @param params.amount - The amount of the asset to swap in base units
+	* @param params.type - The type of the quote (default: 'fixed-input')
+	* @param params.disabledProtocols - List of protocols to disable (default: [])
+	* @param params.maxGroupSize - The maximum group size (default: 16)
+	* @param params.maxDepth - The maximum depth (default: 4)
+	* @param params.address - The address of the account that will perform the swap (recommended when using `config.autoOptIn` or `params.optIn`)
+	* @param params.optIn - Whether to include asset opt-in transaction
+	* @returns A DeflexQuote instance with convenience methods
+	*
+	* @example
+	* ```typescript
+	* const quote = await deflex.newQuote({
+	*   address: 'ABC...',
+	*   fromAssetId: 0,
+	*   toAssetId: 31566704,
+	*   amount: 1_000_000,
+	* })
+	*
+	* // Access quote data
+	* console.log(quote.quote)                 // bigint (quoted amount)
+	* console.log(quote.fromAssetId)           // number
+	* console.log(quote.toAssetId)             // number
+	*
+	* // Access metadata
+	* console.log(quote.amount)                // bigint (original request amount)
+	* console.log(quote.address)               // string | undefined
+	* console.log(quote.createdAt)             // number
+	*
+	* // Use convenience methods
+	* const minReceivedAmount = quote.getSlippageAmount(slippage) // fixed-input swap
+	* const maxSentAmount = quote.getSlippageAmount(slippage) // fixed-output swap
+	* ```
+	*/
+	async newQuote(params) {
+		return new DeflexQuote({
+			response: await this.fetchQuote({
+				fromASAID: params.fromAssetId,
+				toASAID: params.toAssetId,
+				amount: params.amount,
+				type: params.type,
+				disabledProtocols: params.disabledProtocols,
+				maxGroupSize: params.maxGroupSize,
+				maxDepth: params.maxDepth,
+				optIn: params.optIn,
+				address: params.address
+			}),
+			amount: params.amount,
+			address: params.address
+		});
+	}
+	/**
+	* Create a SwapComposer instance
+	*
+	* This factory method creates a composer that allows you to add custom transactions
+	* before and after the swap transactions, with automatic handling of pre-signed transactions
+	* and opt-ins.
+	*
+	* @param config.quote - The quote response from fetchQuote() or a DeflexQuote instance
+	* @param config.address - The address of the signer
+	* @param config.slippage - The slippage tolerance
+	* @param config.signer - Transaction signer function
+	* @returns A SwapComposer instance ready for building transaction groups
+	*
+	* @example
+	* ```typescript
+	* // Basic swap
+	* const quote = await deflex.newQuote({ ... })
+	* await deflex.newSwap({ quote, address, slippage, signer })
+	*   .execute()
+	* ```
+	*
+	* @example
+	* ```typescript
+	* // Advanced swap with custom transactions
+	* const quote = await deflex.newQuote({ ... })
+	* const swap = await deflex.newSwap({
+	*   quote,
+	*   address,
+	*   slippage,
+	*   signer,
+	* })
+	*
+	* console.log(swap.getStatus()) // BUILDING
+	*
+	* const signedTxns = await swap
+	*   .addTransaction(beforeTxn)
+	*   .addSwapTransactions() // Adds swap transactions to the group
+	*   .addTransaction(afterTxn)
+	*   .sign()
+	*
+	* console.log(swap.getStatus()) // SIGNED
+	*
+	* const result = await swap.execute(waitRounds)
+	* console.log(result.confirmedRound, result.txIds)
+	*
+	* console.log(swap.getStatus()) // COMMITTED
+	* ```
+	*/
+	async newSwap(config) {
+		const { quote, address, slippage, signer } = config;
+		const quoteResponse = quote instanceof DeflexQuote ? quote.response : quote;
+		return new SwapComposer({
+			quote: quoteResponse,
+			deflexTxns: (await this.fetchSwapTransactions({
+				quote: quoteResponse,
+				address,
+				slippage
+			})).txns,
+			algorand: this.algorand,
+			address,
+			signer
+		});
+	}
+	/**
+	* Validates the API key
+	*/
+	validateApiKey(apiKey) {
+		if (!apiKey) throw new Error("API key is required");
+		return apiKey;
+	}
+	/**
+	* Validates an Algorand address
+	*/
+	validateAddress(address) {
+		if (!isValidAddress(address)) throw new Error(`Invalid Algorand address: ${address}`);
+		return address;
+	}
+	/**
+	* Validates the fee in basis points (max 300 = 3.00%)
+	*/
+	validateFeeBps(feeBps) {
+		if (feeBps < 0 || feeBps > MAX_FEE_BPS) throw new Error(`Invalid fee: ${feeBps} basis points (must be between 0 and ${MAX_FEE_BPS})`);
+		return feeBps;
+	}
+};
+
+//#endregion
+export { DEFAULT_ALGOD_PORT, DEFAULT_ALGOD_TOKEN, DEFAULT_ALGOD_URI, DEFAULT_API_BASE_URL, DEFAULT_AUTO_OPT_IN, DEFAULT_CONFIRMATION_ROUNDS, DEFAULT_FEE_BPS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_GROUP_SIZE, DEPRECATED_PROTOCOLS, DeflexClient, DeflexQuote, HTTPError, MAX_FEE_BPS, Protocol, SwapComposer, SwapComposerStatus, request };
+//# sourceMappingURL=index.js.map