amogus-sdk-internal-utils 0.35.2

package/dist/utils/tokenUtils.d.ts

@@ -0,0 +1,88 @@
+import { BaseTokenInfo, TokenValue, UnifiedTokenInfo } from "../types/base.js";
+import { AssertErrorType } from "./assert.js";
+
+//#region src/utils/tokenUtils.d.ts
+type BalanceMapping = Record<string, bigint>;
+declare function computeTotalBalance(token: BaseTokenInfo["defuseAssetId"][] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping): bigint | undefined;
+declare class DuplicateTokenError extends Error {
+  constructor(tokenId: string, decimals1: number, decimals2: number);
+}
+declare function adjustDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint;
+declare function deduplicateTokens(tokens: BaseTokenInfo[]): BaseTokenInfo[];
+/**
+ * @param token - The token or array of tokens to compute the balance for.
+ * @param balances - The mapping of token balances.
+ * @param config - Configuration options.
+ * @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+ */
+declare function computeTotalBalanceDifferentDecimals(token: BaseTokenInfo[] | BaseTokenInfo | UnifiedTokenInfo, balances: BalanceMapping, config?: {
+  strict: boolean;
+}): TokenValue | undefined;
+declare function computeTotalDeltaDifferentDecimals(tokens: BaseTokenInfo[], tokenDeltas: [string, bigint][]): TokenValue;
+/**
+ * Convert a unified token to a base token, by getting the first token in the group.
+ * It should be used when you need to get *ANY* single token from a unified token.
+ */
+declare function getAnyBaseTokenInfo(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo;
+declare function getUnderlyingBaseTokenInfos(token: BaseTokenInfo | UnifiedTokenInfo | BaseTokenInfo[]): BaseTokenInfo[];
+declare function getDerivedToken(tokenIn: BaseTokenInfo | UnifiedTokenInfo, chainName: string | null): BaseTokenInfo | null;
+declare function getTokenMaxDecimals(token: BaseTokenInfo | UnifiedTokenInfo): number;
+declare function compareAmounts(value1: TokenValue, value2: TokenValue): -1 | 0 | 1;
+declare function minAmounts(value1: TokenValue, value2: TokenValue): TokenValue;
+declare function addAmounts(...values: [TokenValue, TokenValue, ...TokenValue[]]): TokenValue;
+declare function subtractAmounts(value1: TokenValue, token2: TokenValue): TokenValue;
+declare function adjustDecimalsTokenValue(value: TokenValue, toDecimals: number): TokenValue;
+declare function truncateTokenValue(value: TokenValue, decimals: number): TokenValue;
+declare function negateTokenValue(value: TokenValue): TokenValue;
+/**
+ * 1 bip = 0.0001% = 0.000001
+ * 3000 bips = 0.3% = 0.003
+ * 1000000 bips = 100% = 1
+ */
+declare const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+ * Calculates net amount by deducting fee from gross amount.
+ * @example
+ * // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+ * netDownAmount(100000n, 3000) == 99700n
+ */
+declare function netDownAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Calculates gross amount needed to achieve desired net amount after fee.
+ * @example
+ * // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+ * grossUpAmount(100000n, 3000) == 100300n
+ */
+declare function grossUpAmount(amount: bigint, feeBip: number): bigint;
+/**
+ * Slippage can affect only positive numbers, because positive delta mean
+ * that much will receive, and user can receive a bit less than that
+ * depending on market conditions.
+ */
+declare function accountSlippageExactIn(delta: [string, bigint][], slippageBasisPoints: number): [string, bigint][];
+declare function filterOutPoaBridgeTokens(token: BaseTokenInfo | UnifiedTokenInfo): BaseTokenInfo[];
+declare function getTokenAccountIds(tokens: BaseTokenInfo[]): string[];
+/**
+ * Converts Defuse asset ID to token contract ID.
+ * nep141:wrap.near → wrap.near
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+ */
+declare function getTokenAccountId(assetId: string): string;
+type ParseDefuseAssetIdReturnType = {
+  standard: "nep141";
+  contractId: string;
+} | {
+  standard: "nep245";
+  contractId: string;
+  tokenId: string;
+};
+type ParseDefuseAssetIdErrorType = AssertErrorType;
+/**
+ * Parses Defuse asset ID into its components based on the token standard.
+ * nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+ * nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+ */
+declare function parseDefuseAssetId(assetId: string): ParseDefuseAssetIdReturnType;
+declare function tokenAccountIdToDefuseAssetId(address: string): string;
+//#endregion
+export { BASIS_POINTS_DENOMINATOR, DuplicateTokenError, ParseDefuseAssetIdErrorType, ParseDefuseAssetIdReturnType, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, minAmounts, negateTokenValue, netDownAmount, parseDefuseAssetId, subtractAmounts, tokenAccountIdToDefuseAssetId, truncateTokenValue };

package/dist/utils/tokenUtils.js

@@ -0,0 +1,238 @@
+import { assert } from "./assert.js";
+import { validateNearAddress } from "./near.js";
+import { isBaseToken } from "./token.js";
+
+//#region src/utils/tokenUtils.ts
+function computeTotalBalance(token, balances) {
+	if (Array.isArray(token)) {
+		const uniqueTokens = new Set(token);
+		let total = 0n;
+		for (const tokenId of uniqueTokens) {
+			const balance = balances[tokenId];
+			if (balance == null) return;
+			total += balance;
+		}
+		return total;
+	}
+	if (isBaseToken(token)) return balances[token.defuseAssetId];
+	return computeTotalBalance(token.groupedTokens.map((t) => t.defuseAssetId), balances);
+}
+var DuplicateTokenError = class extends Error {
+	constructor(tokenId, decimals1, decimals2) {
+		super(`Duplicate token ${tokenId} found with different decimals: ${decimals1} and ${decimals2}`);
+		this.name = "DuplicateTokenError";
+	}
+};
+function adjustDecimals(amount, fromDecimals, toDecimals) {
+	if (fromDecimals === toDecimals) return amount;
+	if (fromDecimals > toDecimals) return amount / BigInt(10 ** (fromDecimals - toDecimals));
+	return amount * BigInt(10 ** (toDecimals - fromDecimals));
+}
+function deduplicateTokens(tokens) {
+	const tokenMap = /* @__PURE__ */ new Map();
+	for (const token of tokens) {
+		const existing = tokenMap.get(token.defuseAssetId);
+		if (existing) {
+			if (existing.decimals !== token.decimals) throw new DuplicateTokenError(token.defuseAssetId, existing.decimals, token.decimals);
+			continue;
+		}
+		tokenMap.set(token.defuseAssetId, token);
+	}
+	return Array.from(tokenMap.values());
+}
+/**
+* @param token - The token or array of tokens to compute the balance for.
+* @param balances - The mapping of token balances.
+* @param config - Configuration options.
+* @param config.strict - Ensures all tokens have a balance if `true`, otherwise returns `undefined`.
+*/
+function computeTotalBalanceDifferentDecimals(token, balances, config = { strict: true }) {
+	if (!Array.isArray(token) && isBaseToken(token)) token = [token];
+	const uniqueTokens = deduplicateTokens(Array.isArray(token) ? token : token.groupedTokens);
+	if (uniqueTokens.length === 0) return {
+		amount: 0n,
+		decimals: 0
+	};
+	const maxDecimals = Math.max(...uniqueTokens.map((t) => t.decimals));
+	let total = null;
+	for (const t of uniqueTokens) {
+		const balance = balances[t.defuseAssetId];
+		if (balance == null) {
+			if (config.strict) return;
+			continue;
+		}
+		total ??= 0n;
+		total += adjustDecimals(balance, t.decimals, maxDecimals);
+	}
+	if (total == null) return;
+	return {
+		amount: total,
+		decimals: maxDecimals
+	};
+}
+function computeTotalDeltaDifferentDecimals(tokens, tokenDeltas) {
+	const mapping = {};
+	for (const [token, amount] of tokenDeltas) {
+		mapping[token] ??= 0n;
+		mapping[token] += amount;
+	}
+	return computeTotalBalanceDifferentDecimals(tokens, mapping, { strict: false }) ?? {
+		amount: 0n,
+		decimals: 0
+	};
+}
+/**
+* Convert a unified token to a base token, by getting the first token in the group.
+* It should be used when you need to get *ANY* single token from a unified token.
+*/
+function getAnyBaseTokenInfo(token) {
+	const t = getUnderlyingBaseTokenInfos(token)[0];
+	assert(t != null, "Token is undefined");
+	return t;
+}
+function getUnderlyingBaseTokenInfos(token) {
+	let tokens;
+	if (Array.isArray(token)) tokens = token;
+	else tokens = isBaseToken(token) ? [token] : token.groupedTokens;
+	return deduplicateTokens(tokens);
+}
+function getDerivedToken(tokenIn, chainName) {
+	if (isBaseToken(tokenIn)) return chainName === tokenIn.chainName ? tokenIn : null;
+	if (chainName != null) {
+		const tokenOut = tokenIn.groupedTokens.find((token) => token.chainName === chainName);
+		if (tokenOut != null) return tokenOut;
+	}
+	return null;
+}
+function getTokenMaxDecimals(token) {
+	const tokens = getUnderlyingBaseTokenInfos(token);
+	return Math.max(...tokens.map((t) => t.decimals));
+}
+function compareAmounts(value1, value2) {
+	const maxDecimals = Math.max(value1.decimals, value2.decimals);
+	const normalizedAmount1 = adjustDecimals(value1.amount, value1.decimals, maxDecimals);
+	const normalizedAmount2 = adjustDecimals(value2.amount, value2.decimals, maxDecimals);
+	if (normalizedAmount1 < normalizedAmount2) return -1;
+	if (normalizedAmount1 > normalizedAmount2) return 1;
+	return 0;
+}
+function minAmounts(value1, value2) {
+	return compareAmounts(value1, value2) <= 0 ? value1 : value2;
+}
+function addAmounts(...values) {
+	const maxDecimals = Math.max(...values.map((v) => v.decimals));
+	let sum = 0n;
+	for (const v of values) sum += adjustDecimals(v.amount, v.decimals, maxDecimals);
+	return {
+		amount: sum,
+		decimals: maxDecimals
+	};
+}
+function subtractAmounts(value1, token2) {
+	return addAmounts(value1, {
+		amount: -token2.amount,
+		decimals: token2.decimals
+	});
+}
+function adjustDecimalsTokenValue(value, toDecimals) {
+	return {
+		amount: adjustDecimals(value.amount, value.decimals, toDecimals),
+		decimals: toDecimals
+	};
+}
+function truncateTokenValue(value, decimals) {
+	return adjustDecimalsTokenValue(adjustDecimalsTokenValue(value, decimals), value.decimals);
+}
+function negateTokenValue(value) {
+	return {
+		amount: -value.amount,
+		decimals: value.decimals
+	};
+}
+/**
+* 1 bip = 0.0001% = 0.000001
+* 3000 bips = 0.3% = 0.003
+* 1000000 bips = 100% = 1
+*/
+const BASIS_POINTS_DENOMINATOR = 1000000n;
+/**
+* Calculates net amount by deducting fee from gross amount.
+* @example
+* // If gross amount is 100000n with 0.3% fee, net amount is 99700n
+* netDownAmount(100000n, 3000) == 99700n
+*/
+function netDownAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	return amount - (amount * BigInt(feeBip) + (BASIS_POINTS_DENOMINATOR - 1n)) / BASIS_POINTS_DENOMINATOR;
+}
+/**
+* Calculates gross amount needed to achieve desired net amount after fee.
+* @example
+* // To receive net 100000n after 0.3% fee, gross amount needed is 100300n
+* grossUpAmount(100000n, 3000) == 100300n
+*/
+function grossUpAmount(amount, feeBip) {
+	if (feeBip < 0 || feeBip > Number(BASIS_POINTS_DENOMINATOR)) throw new Error(`Invalid feeBip value. It must be between 0 and ${BASIS_POINTS_DENOMINATOR}.`);
+	if (amount < 0n) throw new Error("Amount must be non-negative.");
+	if (amount === 0n || feeBip === 0) return amount;
+	const feeMultiplier = BASIS_POINTS_DENOMINATOR - BigInt(feeBip);
+	return (amount * BASIS_POINTS_DENOMINATOR + (feeMultiplier - 1n)) / feeMultiplier;
+}
+/**
+* Slippage can affect only positive numbers, because positive delta mean
+* that much will receive, and user can receive a bit less than that
+* depending on market conditions.
+*/
+function accountSlippageExactIn(delta, slippageBasisPoints) {
+	return delta.map(([token, amount]) => {
+		if (amount > 0n) return [token, netDownAmount(amount, slippageBasisPoints)];
+		return [token, amount];
+	});
+}
+function filterOutPoaBridgeTokens(token) {
+	if (isBaseToken(token)) return token.bridge === "poa" ? [token] : [];
+	return token.groupedTokens.filter((t) => t.bridge === "poa");
+}
+function getTokenAccountIds(tokens) {
+	return tokens.map((t) => getTokenAccountId(t.defuseAssetId));
+}
+/**
+* Converts Defuse asset ID to token contract ID.
+* nep141:wrap.near → wrap.near
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 → v2_1.omni.hot.tg
+*/
+function getTokenAccountId(assetId) {
+	const { contractId } = parseDefuseAssetId(assetId);
+	return contractId;
+}
+/**
+* Parses Defuse asset ID into its components based on the token standard.
+* nep141:wrap.near → { standard: nep141, contractId: wrap.near }
+* nep245:v2_1.omni.hot.tg:56_11111111111111111111 -> { standard: nep245, contractId: v2_1.omni.hot.tg, tokenId: 56_11111111111111111111 }
+*/
+function parseDefuseAssetId(assetId) {
+	const [tokenStandard, tokenContractId, multiTokenId] = assetId.split(":");
+	assert(tokenContractId != null && validateNearAddress(tokenContractId), "Incorrect format of assetId");
+	switch (tokenStandard) {
+		case "nep141": return {
+			standard: "nep141",
+			contractId: tokenContractId
+		};
+		case "nep245":
+			assert(multiTokenId != null, "Incorrect NEP-245 token format");
+			return {
+				standard: "nep245",
+				contractId: tokenContractId,
+				tokenId: multiTokenId
+			};
+		default: assert(false, `Unsupported token standard: ${tokenStandard}`);
+	}
+}
+function tokenAccountIdToDefuseAssetId(address) {
+	return `nep141:${address}`;
+}
+
+//#endregion
+export { BASIS_POINTS_DENOMINATOR, DuplicateTokenError, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, minAmounts, negateTokenValue, netDownAmount, parseDefuseAssetId, subtractAmounts, tokenAccountIdToDefuseAssetId, truncateTokenValue };

package/dist/utils/tronAddressToHex.cjs

@@ -0,0 +1,18 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/utils/tronAddressToHex.ts
+const tronAddressToHex = (credential) => {
+	try {
+		const payload = _scure_base.base58.decode(credential);
+		if (payload.length < 21) throw new Error("Invalid Tron address: too short");
+		const addressBytes = payload.slice(0, 21);
+		if (addressBytes[0] !== 65) throw new Error("Invalid Tron address: wrong prefix");
+		return _scure_base.hex.encode(addressBytes);
+	} catch (_error) {
+		throw new Error("Invalid Tron address");
+	}
+};
+
+//#endregion
+exports.tronAddressToHex = tronAddressToHex;

package/dist/utils/tronAddressToHex.js

@@ -0,0 +1,17 @@
+import { base58, hex } from "@scure/base";
+
+//#region src/utils/tronAddressToHex.ts
+const tronAddressToHex = (credential) => {
+	try {
+		const payload = base58.decode(credential);
+		if (payload.length < 21) throw new Error("Invalid Tron address: too short");
+		const addressBytes = payload.slice(0, 21);
+		if (addressBytes[0] !== 65) throw new Error("Invalid Tron address: wrong prefix");
+		return hex.encode(addressBytes);
+	} catch (_error) {
+		throw new Error("Invalid Tron address");
+	}
+};
+
+//#endregion
+export { tronAddressToHex };

package/dist/utils/uint8Array.cjs

@@ -0,0 +1,15 @@
+
+//#region src/utils/uint8Array.ts
+function concatUint8Arrays(arrays) {
+	let pointer = 0;
+	const totalLength = arrays.reduce((prev, curr) => prev + curr.length, 0);
+	const toReturn = new Uint8Array(totalLength);
+	for (const arr of arrays) {
+		toReturn.set(arr, pointer);
+		pointer += arr.length;
+	}
+	return toReturn;
+}
+
+//#endregion
+exports.concatUint8Arrays = concatUint8Arrays;

package/dist/utils/uint8Array.d.cts

@@ -0,0 +1,4 @@
+//#region src/utils/uint8Array.d.ts
+declare function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
+//#endregion
+export { concatUint8Arrays };

package/dist/utils/uint8Array.d.ts

@@ -0,0 +1,4 @@
+//#region src/utils/uint8Array.d.ts
+declare function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
+//#endregion
+export { concatUint8Arrays };

package/dist/utils/uint8Array.js

@@ -0,0 +1,14 @@
+//#region src/utils/uint8Array.ts
+function concatUint8Arrays(arrays) {
+	let pointer = 0;
+	const totalLength = arrays.reduce((prev, curr) => prev + curr.length, 0);
+	const toReturn = new Uint8Array(totalLength);
+	for (const arr of arrays) {
+		toReturn.set(arr, pointer);
+		pointer += arr.length;
+	}
+	return toReturn;
+}
+
+//#endregion
+export { concatUint8Arrays };

package/dist/utils/webAuthn.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _scure_base = require("@scure/base");
+let _noble_curves_p256 = require("@noble/curves/p256");
+require("tweetnacl");
+
+//#region src/utils/webAuthn.ts
+function parsePublicKey(formattedPublicKey) {
+	const curveType = getCurveType(formattedPublicKey);
+	switch (curveType) {
+		case "p256": {
+			let publicKey;
+			try {
+				publicKey = _scure_base.base58.decode(formattedPublicKey.slice(5));
+			} catch (err) {
+				throw new Error("Public key is not base58 encoded", { cause: err });
+			}
+			if (publicKey.length !== 64) throw new Error(`Invalid public key size for P-256 curve, it must be 64 bytes, but got ${publicKey.length} bytes`);
+			return {
+				curveType,
+				publicKey
+			};
+		}
+		case "ed25519": {
+			let publicKey;
+			try {
+				publicKey = _scure_base.base58.decode(formattedPublicKey.slice(8));
+			} catch (err) {
+				throw new Error("Public key is not base58 encoded", { cause: err });
+			}
+			if (publicKey.length !== 32) throw new Error(`Invalid public key size for Ed25519 curve, it must be 32 bytes, but got ${publicKey.length} bytes`);
+			return {
+				curveType,
+				publicKey
+			};
+		}
+		default: throw new Error(`Unsupported curve type ${curveType}`);
+	}
+}
+function getCurveType(formattedPublicKey) {
+	const delim = formattedPublicKey.indexOf(":");
+	if (delim === -1) throw new Error("Invalid public key format");
+	return formattedPublicKey.slice(0, delim);
+}
+/**
+* Gets the actual signature from AuthenticatorAssertionResponse#signature bytes
+*/
+function extractRawSignature(attestationSignature_, curveType) {
+	const attestationSignature = new Uint8Array(attestationSignature_);
+	switch (curveType) {
+		case "ed25519": return attestationSignature;
+		case "p256": return _noble_curves_p256.p256.Signature.fromDER(attestationSignature).normalizeS().toCompactRawBytes();
+		default: throw new Error(`Unsupported curve type ${curveType}`);
+	}
+}
+
+//#endregion
+exports.extractRawSignature = extractRawSignature;
+exports.parsePublicKey = parsePublicKey;

package/dist/utils/webAuthn.js

@@ -0,0 +1,56 @@
+import { base58, base64urlnopad } from "@scure/base";
+import { p256 } from "@noble/curves/p256";
+import "tweetnacl";
+
+//#region src/utils/webAuthn.ts
+function parsePublicKey(formattedPublicKey) {
+	const curveType = getCurveType(formattedPublicKey);
+	switch (curveType) {
+		case "p256": {
+			let publicKey;
+			try {
+				publicKey = base58.decode(formattedPublicKey.slice(5));
+			} catch (err) {
+				throw new Error("Public key is not base58 encoded", { cause: err });
+			}
+			if (publicKey.length !== 64) throw new Error(`Invalid public key size for P-256 curve, it must be 64 bytes, but got ${publicKey.length} bytes`);
+			return {
+				curveType,
+				publicKey
+			};
+		}
+		case "ed25519": {
+			let publicKey;
+			try {
+				publicKey = base58.decode(formattedPublicKey.slice(8));
+			} catch (err) {
+				throw new Error("Public key is not base58 encoded", { cause: err });
+			}
+			if (publicKey.length !== 32) throw new Error(`Invalid public key size for Ed25519 curve, it must be 32 bytes, but got ${publicKey.length} bytes`);
+			return {
+				curveType,
+				publicKey
+			};
+		}
+		default: throw new Error(`Unsupported curve type ${curveType}`);
+	}
+}
+function getCurveType(formattedPublicKey) {
+	const delim = formattedPublicKey.indexOf(":");
+	if (delim === -1) throw new Error("Invalid public key format");
+	return formattedPublicKey.slice(0, delim);
+}
+/**
+* Gets the actual signature from AuthenticatorAssertionResponse#signature bytes
+*/
+function extractRawSignature(attestationSignature_, curveType) {
+	const attestationSignature = new Uint8Array(attestationSignature_);
+	switch (curveType) {
+		case "ed25519": return attestationSignature;
+		case "p256": return p256.Signature.fromDER(attestationSignature).normalizeS().toCompactRawBytes();
+		default: throw new Error(`Unsupported curve type ${curveType}`);
+	}
+}
+
+//#endregion
+export { extractRawSignature, parsePublicKey };

package/dist/xrpl/index.cjs

@@ -0,0 +1,13 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('./xrplHttpClient/index.cjs');
+
+//#region src/xrpl/index.ts
+var xrpl_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({ httpClient: () => require_index.xrplHttpClient_exports });
+
+//#endregion
+Object.defineProperty(exports, 'xrpl_exports', {
+  enumerable: true,
+  get: function () {
+    return xrpl_exports;
+  }
+});

package/dist/xrpl/index.d.cts

@@ -0,0 +1,8 @@
+import { index_d_exports as index_d_exports$1 } from "./xrplHttpClient/index.cjs";
+
+//#region src/xrpl/index.d.ts
+declare namespace index_d_exports {
+  export { index_d_exports$1 as httpClient };
+}
+//#endregion
+export { index_d_exports };

package/dist/xrpl/index.d.ts

@@ -0,0 +1,8 @@
+import { index_d_exports as index_d_exports$1 } from "./xrplHttpClient/index.js";
+
+//#region src/xrpl/index.d.ts
+declare namespace index_d_exports {
+  export { index_d_exports$1 as httpClient };
+}
+//#endregion
+export { index_d_exports };

package/dist/xrpl/index.js

@@ -0,0 +1,8 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { xrplHttpClient_exports } from "./xrplHttpClient/index.js";
+
+//#region src/xrpl/index.ts
+var xrpl_exports = /* @__PURE__ */ __exportAll({ httpClient: () => xrplHttpClient_exports });
+
+//#endregion
+export { xrpl_exports };

package/dist/xrpl/xrplHttpClient/apis.cjs

@@ -0,0 +1,28 @@
+const require_types = require('./types.cjs');
+const require_runtime = require('./runtime.cjs');
+
+//#region src/xrpl/xrplHttpClient/apis.ts
+async function getAccountInfo(account, config) {
+	return (await require_runtime.xrplRequest("account_info", {
+		account,
+		ledger_index: "validated"
+	}, config, require_types.AccountInfoResponseSchema)).result;
+}
+async function getAccountLines(account, config) {
+	const lines = [];
+	let marker;
+	do {
+		const response = await require_runtime.xrplRequest("account_lines", {
+			account,
+			ledger_index: "validated",
+			marker
+		}, config, require_types.AccountLinesResponseSchema);
+		lines.push(...response.result.lines);
+		marker = response.result.marker;
+	} while (marker !== void 0);
+	return { lines };
+}
+
+//#endregion
+exports.getAccountInfo = getAccountInfo;
+exports.getAccountLines = getAccountLines;

package/dist/xrpl/xrplHttpClient/apis.d.cts

@@ -0,0 +1,7 @@
+import { AccountInfoResponse, AccountLinesResponse, RequestConfig } from "./types.cjs";
+
+//#region src/xrpl/xrplHttpClient/apis.d.ts
+declare function getAccountInfo(account: string, config: RequestConfig): Promise<AccountInfoResponse["result"]>;
+declare function getAccountLines(account: string, config: RequestConfig): Promise<AccountLinesResponse["result"]>;
+//#endregion
+export { getAccountInfo, getAccountLines };

package/dist/xrpl/xrplHttpClient/apis.d.ts

@@ -0,0 +1,7 @@
+import { AccountInfoResponse, AccountLinesResponse, RequestConfig } from "./types.js";
+
+//#region src/xrpl/xrplHttpClient/apis.d.ts
+declare function getAccountInfo(account: string, config: RequestConfig): Promise<AccountInfoResponse["result"]>;
+declare function getAccountLines(account: string, config: RequestConfig): Promise<AccountLinesResponse["result"]>;
+//#endregion
+export { getAccountInfo, getAccountLines };

package/dist/xrpl/xrplHttpClient/apis.js

@@ -0,0 +1,27 @@
+import { AccountInfoResponseSchema, AccountLinesResponseSchema } from "./types.js";
+import { xrplRequest } from "./runtime.js";
+
+//#region src/xrpl/xrplHttpClient/apis.ts
+async function getAccountInfo(account, config) {
+	return (await xrplRequest("account_info", {
+		account,
+		ledger_index: "validated"
+	}, config, AccountInfoResponseSchema)).result;
+}
+async function getAccountLines(account, config) {
+	const lines = [];
+	let marker;
+	do {
+		const response = await xrplRequest("account_lines", {
+			account,
+			ledger_index: "validated",
+			marker
+		}, config, AccountLinesResponseSchema);
+		lines.push(...response.result.lines);
+		marker = response.result.marker;
+	} while (marker !== void 0);
+	return { lines };
+}
+
+//#endregion
+export { getAccountInfo, getAccountLines };

package/dist/xrpl/xrplHttpClient/errors.cjs

@@ -0,0 +1,27 @@
+const require_base = require('../../errors/base.cjs');
+
+//#region src/xrpl/xrplHttpClient/errors.ts
+var XrplApiError = class extends require_base.BaseError {
+	constructor(output) {
+		super("XRPL API request failed.", {
+			metaMessages: [`Error: ${output.error}`, `Error code: ${output.error_code}`],
+			name: "XrplApiError",
+			details: output.error_message
+		});
+		this.output = output;
+	}
+};
+var XrplAccountNotFundedError = class extends require_base.BaseError {
+	constructor(account) {
+		super("XRPL account is not funded.", {
+			metaMessages: account ? [`Account: ${account}`] : void 0,
+			name: "XrplAccountNotFundedError",
+			details: account ? `Account ${account} was not found on the XRPL ledger. The account must be funded with the minimum reserve before it can receive tokens.` : "Account was not found on the XRPL ledger. The account must be funded with the minimum reserve before it can receive tokens."
+		});
+		this.account = account;
+	}
+};
+
+//#endregion
+exports.XrplAccountNotFundedError = XrplAccountNotFundedError;
+exports.XrplApiError = XrplApiError;