lampamazaza-new-internal-utils 0.24.3

package/dist/utils/appFee.d.ts

@@ -0,0 +1,9 @@
+import { BaseTokenInfo, UnifiedTokenInfo } from "../types/base.js";
+
+//#region src/utils/appFee.d.ts
+declare namespace appFee_d_exports {
+  export { computeAppFeeBps };
+}
+declare function computeAppFeeBps(defaultAppFeeBps: number, token1: BaseTokenInfo | UnifiedTokenInfo, token2: BaseTokenInfo | UnifiedTokenInfo): number;
+//#endregion
+export { appFee_d_exports };

package/dist/utils/appFee.js

@@ -0,0 +1,15 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+
+//#region src/utils/appFee.ts
+var appFee_exports = /* @__PURE__ */ __exportAll({ computeAppFeeBps: () => computeAppFeeBps });
+function computeAppFeeBps(defaultAppFeeBps, token1, token2) {
+	if (hasTags(token1) && hasTags(token2) && token1.tags.includes("type:stablecoin") && token2.tags.includes("type:stablecoin")) return 0;
+	return defaultAppFeeBps;
+}
+function hasTags(a) {
+	if ("tags" in a) return true;
+	return false;
+}
+
+//#endregion
+export { appFee_exports };

package/dist/utils/assert.cjs

@@ -0,0 +1,9 @@
+const require_assert = require('../errors/assert.cjs');
+
+//#region src/utils/assert.ts
+function assert(condition, msg) {
+	if (!condition) throw new require_assert.AssertionError(msg);
+}
+
+//#endregion
+exports.assert = assert;

package/dist/utils/assert.d.cts

@@ -0,0 +1,7 @@
+import { AssertionError } from "../errors/assert.cjs";
+
+//#region src/utils/assert.d.ts
+type AssertErrorType = AssertionError;
+declare function assert(condition: unknown, msg?: string): asserts condition;
+//#endregion
+export { AssertErrorType, assert };

package/dist/utils/assert.d.ts

@@ -0,0 +1,7 @@
+import { AssertionError } from "../errors/assert.js";
+
+//#region src/utils/assert.d.ts
+type AssertErrorType = AssertionError;
+declare function assert(condition: unknown, msg?: string): asserts condition;
+//#endregion
+export { AssertErrorType, assert };

package/dist/utils/assert.js

@@ -0,0 +1,9 @@
+import { AssertionError } from "../errors/assert.js";
+
+//#region src/utils/assert.ts
+function assert(condition, msg) {
+	if (!condition) throw new AssertionError(msg);
+}
+
+//#endregion
+export { assert };

package/dist/utils/authIdentity.cjs

@@ -0,0 +1,56 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_assert = require('./assert.cjs');
+const require_stellarAddressToBytes = require('./stellarAddressToBytes.cjs');
+const require_tronAddressToHex = require('./tronAddressToHex.cjs');
+const require_webAuthn = require('./webAuthn.cjs');
+let _noble_hashes_sha3 = require("@noble/hashes/sha3");
+let _scure_base = require("@scure/base");
+
+//#region src/utils/authIdentity.ts
+var authIdentity_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({ authHandleToIntentsUserId: () => authHandleToIntentsUserId });
+function authHandleToIntentsUserId(authIdentifier, authMethod) {
+	let authHandle;
+	if (typeof authIdentifier === "object") authHandle = authIdentifier;
+	else if (authMethod != null) authHandle = {
+		identifier: authIdentifier,
+		method: authMethod
+	};
+	else throw new Error("Invalid arguments");
+	switch (authHandle.method) {
+		case "evm":
+		case "near": return authHandle.identifier.toLowerCase();
+		case "solana": return _scure_base.hex.encode(_scure_base.base58.decode(authHandle.identifier));
+		case "webauthn": return webAuthnIdentifierToIntentsUserId(authHandle.identifier);
+		case "ton":
+			require_assert.assert(authHandle.identifier.length === 64);
+			_scure_base.hex.decode(authHandle.identifier);
+			return authHandle.identifier.toLowerCase();
+		case "stellar": {
+			const decoded = require_stellarAddressToBytes.stellarAddressToBytes(authHandle.identifier);
+			return _scure_base.hex.encode(decoded);
+		}
+		case "tron": return `0x${require_tronAddressToHex.tronAddressToHex(authHandle.identifier).substring(2)}`;
+		default: throw new Error("Unsupported auth method");
+	}
+}
+function webAuthnIdentifierToIntentsUserId(credential) {
+	const { curveType, publicKey } = require_webAuthn.parsePublicKey(credential);
+	switch (curveType) {
+		case "p256": {
+			const p256 = new TextEncoder().encode("p256");
+			const addressBytes = (0, _noble_hashes_sha3.keccak_256)(new Uint8Array([...p256, ...publicKey])).slice(-20);
+			return "0x" + _scure_base.hex.encode(addressBytes);
+		}
+		case "ed25519": return _scure_base.hex.encode(publicKey);
+		default: throw new Error("Unsupported curve type");
+	}
+}
+
+//#endregion
+exports.authHandleToIntentsUserId = authHandleToIntentsUserId;
+Object.defineProperty(exports, 'authIdentity_exports', {
+  enumerable: true,
+  get: function () {
+    return authIdentity_exports;
+  }
+});

package/dist/utils/authIdentity.d.cts

@@ -0,0 +1,34 @@
+import { IntentsUserId } from "../types/intentsUserId.cjs";
+import { AuthHandle, AuthIdentifier, AuthMethod } from "../types/authHandle.cjs";
+
+//#region src/utils/authIdentity.d.ts
+declare namespace authIdentity_d_exports {
+  export { authHandleToIntentsUserId };
+}
+/**
+ * Converts a blockchain address to a standardized Defuse user ID.
+ *
+ * The conversion follows these rules:
+ * 1. NEAR addresses: Used as-is (lowercased)
+ *   - Explicit: "bob.near"
+ *   - Implicit: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1"
+ *
+ * 2. EVM addresses: Used as-is (lowercased)
+ *   - Format: "0xc0ffee254729296a45a3885639ac7e10f9d54979"
+ *
+ * 3. Solana addresses: Converted from base58 to hex
+ *   - Input: base58 public key
+ *   - Output: hex-encoded string
+ *
+ * 4. WebAuthn credentials: Converted based on curve type
+ *   - P-256: Keccak256(prefix + pubkey) -> last 20 bytes -> hex with 0x prefix
+ *   - Ed25519: Raw public key -> hex encoding
+ *
+ * @param authIdentifier - The user's identifier (blockchain address or WebAuthn public key)
+ * @param authMethod - The type of credential ("evm", "near", "solana", "webauthn")
+ * @returns A standardized Defuse user ID
+ */
+declare function authHandleToIntentsUserId(authIdentifier: AuthIdentifier, authMethod: AuthMethod): IntentsUserId;
+declare function authHandleToIntentsUserId(authHandle: AuthHandle): IntentsUserId;
+//#endregion
+export { authHandleToIntentsUserId, authIdentity_d_exports };

package/dist/utils/authIdentity.d.ts

@@ -0,0 +1,34 @@
+import { IntentsUserId } from "../types/intentsUserId.js";
+import { AuthHandle, AuthIdentifier, AuthMethod } from "../types/authHandle.js";
+
+//#region src/utils/authIdentity.d.ts
+declare namespace authIdentity_d_exports {
+  export { authHandleToIntentsUserId };
+}
+/**
+ * Converts a blockchain address to a standardized Defuse user ID.
+ *
+ * The conversion follows these rules:
+ * 1. NEAR addresses: Used as-is (lowercased)
+ *   - Explicit: "bob.near"
+ *   - Implicit: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1"
+ *
+ * 2. EVM addresses: Used as-is (lowercased)
+ *   - Format: "0xc0ffee254729296a45a3885639ac7e10f9d54979"
+ *
+ * 3. Solana addresses: Converted from base58 to hex
+ *   - Input: base58 public key
+ *   - Output: hex-encoded string
+ *
+ * 4. WebAuthn credentials: Converted based on curve type
+ *   - P-256: Keccak256(prefix + pubkey) -> last 20 bytes -> hex with 0x prefix
+ *   - Ed25519: Raw public key -> hex encoding
+ *
+ * @param authIdentifier - The user's identifier (blockchain address or WebAuthn public key)
+ * @param authMethod - The type of credential ("evm", "near", "solana", "webauthn")
+ * @returns A standardized Defuse user ID
+ */
+declare function authHandleToIntentsUserId(authIdentifier: AuthIdentifier, authMethod: AuthMethod): IntentsUserId;
+declare function authHandleToIntentsUserId(authHandle: AuthHandle): IntentsUserId;
+//#endregion
+export { authHandleToIntentsUserId, authIdentity_d_exports };

package/dist/utils/authIdentity.js

@@ -0,0 +1,50 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { assert } from "./assert.js";
+import { stellarAddressToBytes } from "./stellarAddressToBytes.js";
+import { tronAddressToHex } from "./tronAddressToHex.js";
+import { parsePublicKey } from "./webAuthn.js";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { base58, hex } from "@scure/base";
+
+//#region src/utils/authIdentity.ts
+var authIdentity_exports = /* @__PURE__ */ __exportAll({ authHandleToIntentsUserId: () => authHandleToIntentsUserId });
+function authHandleToIntentsUserId(authIdentifier, authMethod) {
+	let authHandle;
+	if (typeof authIdentifier === "object") authHandle = authIdentifier;
+	else if (authMethod != null) authHandle = {
+		identifier: authIdentifier,
+		method: authMethod
+	};
+	else throw new Error("Invalid arguments");
+	switch (authHandle.method) {
+		case "evm":
+		case "near": return authHandle.identifier.toLowerCase();
+		case "solana": return hex.encode(base58.decode(authHandle.identifier));
+		case "webauthn": return webAuthnIdentifierToIntentsUserId(authHandle.identifier);
+		case "ton":
+			assert(authHandle.identifier.length === 64);
+			hex.decode(authHandle.identifier);
+			return authHandle.identifier.toLowerCase();
+		case "stellar": {
+			const decoded = stellarAddressToBytes(authHandle.identifier);
+			return hex.encode(decoded);
+		}
+		case "tron": return `0x${tronAddressToHex(authHandle.identifier).substring(2)}`;
+		default: throw new Error("Unsupported auth method");
+	}
+}
+function webAuthnIdentifierToIntentsUserId(credential) {
+	const { curveType, publicKey } = parsePublicKey(credential);
+	switch (curveType) {
+		case "p256": {
+			const p256 = new TextEncoder().encode("p256");
+			const addressBytes = keccak_256(new Uint8Array([...p256, ...publicKey])).slice(-20);
+			return "0x" + hex.encode(addressBytes);
+		}
+		case "ed25519": return hex.encode(publicKey);
+		default: throw new Error("Unsupported curve type");
+	}
+}
+
+//#endregion
+export { authHandleToIntentsUserId, authIdentity_exports };

package/dist/utils/failover.cjs

@@ -0,0 +1,22 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let near_api_js = require("near-api-js");
+
+//#region src/utils/failover.ts
+/**
+* @note This function is specifically designed for NEAR RPC providers and should not be used with other blockchain networks.
+* It creates a failover provider that will automatically switch between the provided RPC endpoints if one fails.
+*/
+function nearFailoverRpcProvider({ urls }) {
+	return createNearFailoverRpcProvider({ providers: urls.map((url) => new near_api_js.providers.JsonRpcProvider({ url })) });
+}
+function createNearFailoverRpcProvider({ providers: list }) {
+	return new near_api_js.providers.FailoverRpcProvider(list);
+}
+function unwrapNearFailoverRpcProvider(provider) {
+	if (provider instanceof near_api_js.providers.FailoverRpcProvider && provider.providers.length > 0 && provider.providers[0]) return provider.providers[0];
+	return provider;
+}
+
+//#endregion
+exports.nearFailoverRpcProvider = nearFailoverRpcProvider;
+exports.unwrapNearFailoverRpcProvider = unwrapNearFailoverRpcProvider;

package/dist/utils/failover.d.cts

@@ -0,0 +1,16 @@
+import { providers } from "near-api-js";
+
+//#region src/utils/failover.d.ts
+
+/**
+ * @note This function is specifically designed for NEAR RPC providers and should not be used with other blockchain networks.
+ * It creates a failover provider that will automatically switch between the provided RPC endpoints if one fails.
+ */
+declare function nearFailoverRpcProvider({
+  urls
+}: {
+  urls: string[];
+}): providers.FailoverRpcProvider;
+declare function unwrapNearFailoverRpcProvider(provider: providers.Provider): providers.Provider;
+//#endregion
+export { nearFailoverRpcProvider, unwrapNearFailoverRpcProvider };

package/dist/utils/failover.d.ts

@@ -0,0 +1,16 @@
+import { providers } from "near-api-js";
+
+//#region src/utils/failover.d.ts
+
+/**
+ * @note This function is specifically designed for NEAR RPC providers and should not be used with other blockchain networks.
+ * It creates a failover provider that will automatically switch between the provided RPC endpoints if one fails.
+ */
+declare function nearFailoverRpcProvider({
+  urls
+}: {
+  urls: string[];
+}): providers.FailoverRpcProvider;
+declare function unwrapNearFailoverRpcProvider(provider: providers.Provider): providers.Provider;
+//#endregion
+export { nearFailoverRpcProvider, unwrapNearFailoverRpcProvider };

package/dist/utils/failover.js

@@ -0,0 +1,20 @@
+import { providers } from "near-api-js";
+
+//#region src/utils/failover.ts
+/**
+* @note This function is specifically designed for NEAR RPC providers and should not be used with other blockchain networks.
+* It creates a failover provider that will automatically switch between the provided RPC endpoints if one fails.
+*/
+function nearFailoverRpcProvider({ urls }) {
+	return createNearFailoverRpcProvider({ providers: urls.map((url) => new providers.JsonRpcProvider({ url })) });
+}
+function createNearFailoverRpcProvider({ providers: list }) {
+	return new providers.FailoverRpcProvider(list);
+}
+function unwrapNearFailoverRpcProvider(provider) {
+	if (provider instanceof providers.FailoverRpcProvider && provider.providers.length > 0 && provider.providers[0]) return provider.providers[0];
+	return provider;
+}
+
+//#endregion
+export { nearFailoverRpcProvider, unwrapNearFailoverRpcProvider };

package/dist/utils/handleRPCResponse.cjs

@@ -0,0 +1,30 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_request = require('../errors/request.cjs');
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+
+//#region src/utils/handleRPCResponse.ts
+async function handleRPCResponse(response, body, schema) {
+	const json = await response.json();
+	const parsed = valibot.safeParse(schema, json);
+	if (parsed.success) {
+		if (parsed.output.error !== void 0) throw new require_request.RpcRequestError({
+			body,
+			error: parsed.output.error,
+			url: response.url
+		});
+		return parsed.output.result;
+	}
+	throw new require_request.RpcRequestError({
+		body,
+		error: {
+			code: -1,
+			data: json,
+			message: "Invalid response"
+		},
+		url: response.url
+	});
+}
+
+//#endregion
+exports.handleRPCResponse = handleRPCResponse;

package/dist/utils/handleRPCResponse.js

@@ -0,0 +1,28 @@
+import { RpcRequestError } from "../errors/request.js";
+import * as v from "valibot";
+
+//#region src/utils/handleRPCResponse.ts
+async function handleRPCResponse(response, body, schema) {
+	const json = await response.json();
+	const parsed = v.safeParse(schema, json);
+	if (parsed.success) {
+		if (parsed.output.error !== void 0) throw new RpcRequestError({
+			body,
+			error: parsed.output.error,
+			url: response.url
+		});
+		return parsed.output.result;
+	}
+	throw new RpcRequestError({
+		body,
+		error: {
+			code: -1,
+			data: json,
+			message: "Invalid response"
+		},
+		url: response.url
+	});
+}
+
+//#endregion
+export { handleRPCResponse };

package/dist/utils/index.cjs

@@ -0,0 +1,55 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_assert = require('./assert.cjs');
+const require_uint8Array = require('./uint8Array.cjs');
+const require_authIdentity = require('./authIdentity.cjs');
+const require_prepareBroadcastRequest = require('./prepareBroadcastRequest.cjs');
+const require_near = require('./near.cjs');
+const require_tokenUtils = require('./tokenUtils.cjs');
+
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	BASIS_POINTS_DENOMINATOR: () => require_tokenUtils.BASIS_POINTS_DENOMINATOR,
+	DuplicateTokenError: () => require_tokenUtils.DuplicateTokenError,
+	accountSlippageExactIn: () => require_tokenUtils.accountSlippageExactIn,
+	addAmounts: () => require_tokenUtils.addAmounts,
+	adjustDecimals: () => require_tokenUtils.adjustDecimals,
+	adjustDecimalsTokenValue: () => require_tokenUtils.adjustDecimalsTokenValue,
+	assert: () => require_assert.assert,
+	authHandleToIntentsUserId: () => require_authIdentity.authHandleToIntentsUserId,
+	compareAmounts: () => require_tokenUtils.compareAmounts,
+	computeTotalBalance: () => require_tokenUtils.computeTotalBalance,
+	computeTotalBalanceDifferentDecimals: () => require_tokenUtils.computeTotalBalanceDifferentDecimals,
+	computeTotalDeltaDifferentDecimals: () => require_tokenUtils.computeTotalDeltaDifferentDecimals,
+	concatUint8Arrays: () => require_uint8Array.concatUint8Arrays,
+	decodeQueryResult: () => require_near.decodeQueryResult,
+	deduplicateTokens: () => require_tokenUtils.deduplicateTokens,
+	filterOutPoaBridgeTokens: () => require_tokenUtils.filterOutPoaBridgeTokens,
+	getAnyBaseTokenInfo: () => require_tokenUtils.getAnyBaseTokenInfo,
+	getDerivedToken: () => require_tokenUtils.getDerivedToken,
+	getTokenAccountId: () => require_tokenUtils.getTokenAccountId,
+	getTokenAccountIds: () => require_tokenUtils.getTokenAccountIds,
+	getTokenMaxDecimals: () => require_tokenUtils.getTokenMaxDecimals,
+	getUnderlyingBaseTokenInfos: () => require_tokenUtils.getUnderlyingBaseTokenInfos,
+	grossUpAmount: () => require_tokenUtils.grossUpAmount,
+	isImplicitAccount: () => require_near.isImplicitAccount,
+	minAmounts: () => require_tokenUtils.minAmounts,
+	negateTokenValue: () => require_tokenUtils.negateTokenValue,
+	netDownAmount: () => require_tokenUtils.netDownAmount,
+	normalizeERC191Signature: () => require_prepareBroadcastRequest.normalizeERC191Signature,
+	parseDefuseAssetId: () => require_tokenUtils.parseDefuseAssetId,
+	prepareSwapSignedData: () => require_prepareBroadcastRequest.prepareSwapSignedData,
+	queryContract: () => require_near.queryContract,
+	subtractAmounts: () => require_tokenUtils.subtractAmounts,
+	tokenAccountIdToDefuseAssetId: () => require_tokenUtils.tokenAccountIdToDefuseAssetId,
+	transformERC191Signature: () => require_prepareBroadcastRequest.transformERC191Signature,
+	truncateTokenValue: () => require_tokenUtils.truncateTokenValue,
+	validateNearAddress: () => require_near.validateNearAddress
+});
+
+//#endregion
+Object.defineProperty(exports, 'utils_exports', {
+  enumerable: true,
+  get: function () {
+    return utils_exports;
+  }
+});

package/dist/utils/index.d.cts

@@ -0,0 +1,13 @@
+import { AssertErrorType, assert } from "./assert.cjs";
+import { authHandleToIntentsUserId } from "./authIdentity.cjs";
+import { normalizeERC191Signature, prepareSwapSignedData, transformERC191Signature } from "./prepareBroadcastRequest.cjs";
+import { 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 } from "./tokenUtils.cjs";
+import { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress } from "./near.cjs";
+import { concatUint8Arrays } from "./uint8Array.cjs";
+
+//#region src/utils/index.d.ts
+declare namespace index_d_exports {
+  export { AssertErrorType, BASIS_POINTS_DENOMINATOR, DuplicateTokenError, OptionalBlockReference, ParseDefuseAssetIdErrorType, ParseDefuseAssetIdReturnType, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, assert, authHandleToIntentsUserId, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, concatUint8Arrays, decodeQueryResult, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, isImplicitAccount, minAmounts, negateTokenValue, netDownAmount, normalizeERC191Signature, parseDefuseAssetId, prepareSwapSignedData, queryContract, subtractAmounts, tokenAccountIdToDefuseAssetId, transformERC191Signature, truncateTokenValue, validateNearAddress };
+}
+//#endregion
+export { index_d_exports };

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+import { AssertErrorType, assert } from "./assert.js";
+import { authHandleToIntentsUserId } from "./authIdentity.js";
+import { normalizeERC191Signature, prepareSwapSignedData, transformERC191Signature } from "./prepareBroadcastRequest.js";
+import { 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 } from "./tokenUtils.js";
+import { OptionalBlockReference, decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress } from "./near.js";
+import { concatUint8Arrays } from "./uint8Array.js";
+
+//#region src/utils/index.d.ts
+declare namespace index_d_exports {
+  export { AssertErrorType, BASIS_POINTS_DENOMINATOR, DuplicateTokenError, OptionalBlockReference, ParseDefuseAssetIdErrorType, ParseDefuseAssetIdReturnType, accountSlippageExactIn, addAmounts, adjustDecimals, adjustDecimalsTokenValue, assert, authHandleToIntentsUserId, compareAmounts, computeTotalBalance, computeTotalBalanceDifferentDecimals, computeTotalDeltaDifferentDecimals, concatUint8Arrays, decodeQueryResult, deduplicateTokens, filterOutPoaBridgeTokens, getAnyBaseTokenInfo, getDerivedToken, getTokenAccountId, getTokenAccountIds, getTokenMaxDecimals, getUnderlyingBaseTokenInfos, grossUpAmount, isImplicitAccount, minAmounts, negateTokenValue, netDownAmount, normalizeERC191Signature, parseDefuseAssetId, prepareSwapSignedData, queryContract, subtractAmounts, tokenAccountIdToDefuseAssetId, transformERC191Signature, truncateTokenValue, validateNearAddress };
+}
+//#endregion
+export { index_d_exports };

package/dist/utils/index.js

@@ -0,0 +1,50 @@
+import { __exportAll } from "../_virtual/rolldown_runtime.js";
+import { assert } from "./assert.js";
+import { concatUint8Arrays } from "./uint8Array.js";
+import { authHandleToIntentsUserId } from "./authIdentity.js";
+import { normalizeERC191Signature, prepareSwapSignedData, transformERC191Signature } from "./prepareBroadcastRequest.js";
+import { decodeQueryResult, isImplicitAccount, queryContract, validateNearAddress } from "./near.js";
+import { 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 } from "./tokenUtils.js";
+
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	BASIS_POINTS_DENOMINATOR: () => BASIS_POINTS_DENOMINATOR,
+	DuplicateTokenError: () => DuplicateTokenError,
+	accountSlippageExactIn: () => accountSlippageExactIn,
+	addAmounts: () => addAmounts,
+	adjustDecimals: () => adjustDecimals,
+	adjustDecimalsTokenValue: () => adjustDecimalsTokenValue,
+	assert: () => assert,
+	authHandleToIntentsUserId: () => authHandleToIntentsUserId,
+	compareAmounts: () => compareAmounts,
+	computeTotalBalance: () => computeTotalBalance,
+	computeTotalBalanceDifferentDecimals: () => computeTotalBalanceDifferentDecimals,
+	computeTotalDeltaDifferentDecimals: () => computeTotalDeltaDifferentDecimals,
+	concatUint8Arrays: () => concatUint8Arrays,
+	decodeQueryResult: () => decodeQueryResult,
+	deduplicateTokens: () => deduplicateTokens,
+	filterOutPoaBridgeTokens: () => filterOutPoaBridgeTokens,
+	getAnyBaseTokenInfo: () => getAnyBaseTokenInfo,
+	getDerivedToken: () => getDerivedToken,
+	getTokenAccountId: () => getTokenAccountId,
+	getTokenAccountIds: () => getTokenAccountIds,
+	getTokenMaxDecimals: () => getTokenMaxDecimals,
+	getUnderlyingBaseTokenInfos: () => getUnderlyingBaseTokenInfos,
+	grossUpAmount: () => grossUpAmount,
+	isImplicitAccount: () => isImplicitAccount,
+	minAmounts: () => minAmounts,
+	negateTokenValue: () => negateTokenValue,
+	netDownAmount: () => netDownAmount,
+	normalizeERC191Signature: () => normalizeERC191Signature,
+	parseDefuseAssetId: () => parseDefuseAssetId,
+	prepareSwapSignedData: () => prepareSwapSignedData,
+	queryContract: () => queryContract,
+	subtractAmounts: () => subtractAmounts,
+	tokenAccountIdToDefuseAssetId: () => tokenAccountIdToDefuseAssetId,
+	transformERC191Signature: () => transformERC191Signature,
+	truncateTokenValue: () => truncateTokenValue,
+	validateNearAddress: () => validateNearAddress
+});
+
+//#endregion
+export { utils_exports };

package/dist/utils/messageFactory.cjs

@@ -0,0 +1,137 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_config = require('../config.cjs');
+const require_assert = require('./assert.cjs');
+let _scure_base = require("@scure/base");
+let _noble_hashes_sha256 = require("@noble/hashes/sha256");
+
+//#region src/utils/messageFactory.ts
+var messageFactory_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	makeChallenge: () => makeChallenge,
+	makeEmptyMessage: () => makeEmptyMessage,
+	makeInnerSwapMessage: () => makeInnerSwapMessage,
+	makeInnerTransferMessage: () => makeInnerTransferMessage,
+	makeSwapMessage: () => makeSwapMessage,
+	randomDefuseNonce: () => randomDefuseNonce
+});
+/**
+* @param tokenDeltas
+* @param signerId
+* @param deadlineTimestamp Unix timestamp in milliseconds
+* @param referral
+* @param memo
+* @param appFee
+* @param appFeeRecipient
+*/
+function makeInnerSwapMessage({ tokenDeltas, signerId, deadlineTimestamp, referral, memo, appFee, appFeeRecipient }) {
+	const tokenDiff = {};
+	const tokenDiffNum = {};
+	const intents = [{
+		intent: "token_diff",
+		diff: tokenDiff,
+		referral,
+		memo
+	}];
+	if (appFee.length) intents.push({
+		intent: "transfer",
+		tokens: Object.fromEntries(appFee.map(([token, amount]) => [token, amount.toString()])),
+		receiver_id: appFeeRecipient,
+		memo: "APP_FEE"
+	});
+	for (const [token, amount] of tokenDeltas) {
+		tokenDiffNum[token] ??= 0n;
+		tokenDiffNum[token] += amount;
+		tokenDiff[token] = tokenDiffNum[token].toString();
+	}
+	if (Object.keys(tokenDiff).length === 0) return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [],
+		signer_id: signerId
+	};
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents,
+		signer_id: signerId
+	};
+}
+function makeSwapMessage({ innerMessage, nonce = randomDefuseNonce() }) {
+	const payload = {
+		signer_id: innerMessage.signer_id,
+		verifying_contract: require_config.config.env.contractID,
+		deadline: innerMessage.deadline,
+		nonce: _scure_base.base64.encode(nonce),
+		intents: innerMessage.intents
+	};
+	const payloadSerialized = JSON.stringify(payload);
+	const payloadBytes = new TextEncoder().encode(payloadSerialized);
+	return {
+		NEP413: {
+			message: JSON.stringify(innerMessage),
+			recipient: require_config.config.env.contractID,
+			nonce
+		},
+		ERC191: { message: JSON.stringify(payload, null, 2) },
+		SOLANA: { message: payloadBytes },
+		STELLAR: { message: JSON.stringify(payload, null, 2) },
+		WEBAUTHN: {
+			challenge: makeChallenge(payloadBytes),
+			payload: payloadSerialized,
+			parsedPayload: payload
+		},
+		TON_CONNECT: { message: {
+			type: "text",
+			text: JSON.stringify(payload, null, 2)
+		} },
+		TRON: { message: JSON.stringify(payload, null, 2) }
+	};
+}
+function makeEmptyMessage({ signerId, deadlineTimestamp, nonce = randomDefuseNonce() }) {
+	return makeSwapMessage({
+		innerMessage: {
+			deadline: new Date(deadlineTimestamp).toISOString(),
+			intents: [],
+			signer_id: signerId
+		},
+		nonce
+	});
+}
+function randomDefuseNonce() {
+	return randomBytes(32);
+}
+function randomBytes(length) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Converts UTF-8 string to bytes for WebAuthn challenge
+*/
+function makeChallenge(payload) {
+	const hash = (0, _noble_hashes_sha256.sha256)(payload);
+	return new Uint8Array(hash);
+}
+function makeInnerTransferMessage({ tokenDeltas, signerId, deadlineTimestamp, receiverId, memo }) {
+	const tokens = {};
+	const seenTokens = /* @__PURE__ */ new Set();
+	for (const [token, amount] of tokenDeltas) {
+		require_assert.assert(!seenTokens.has(token), `Duplicate token found: ${token}`);
+		seenTokens.add(token);
+		require_assert.assert(amount > 0n, `Transfer amount must be positive, got: ${amount} for token ${token}`);
+		tokens[token] = amount.toString();
+	}
+	return {
+		deadline: new Date(deadlineTimestamp).toISOString(),
+		intents: [{
+			intent: "transfer",
+			tokens,
+			receiver_id: receiverId,
+			...memo ? { memo } : {}
+		}],
+		signer_id: signerId
+	};
+}
+
+//#endregion
+Object.defineProperty(exports, 'messageFactory_exports', {
+  enumerable: true,
+  get: function () {
+    return messageFactory_exports;
+  }
+});