lampamazaza-new-intents-sdk 0.47.1

package/dist/src/core/withdrawal-watcher.js

@@ -0,0 +1,82 @@
+import { getWithdrawalStatsForChain } from "../constants/withdrawal-timing.js";
+import { BaseError, POLL_PENDING, PollTimeoutError, poll } from "lampamazaza-internal-utils";
+
+//#region src/core/withdrawal-watcher.ts
+const MAX_CONSECUTIVE_ERRORS = 3;
+async function watchWithdrawal(args) {
+	const stats = getWithdrawalStatsForChain({
+		chain: args.wid.landingChain,
+		bridgeRoute: args.bridge.route
+	});
+	let consecutiveErrors = 0;
+	try {
+		return await poll(async () => {
+			try {
+				const status = await args.bridge.describeWithdrawal({
+					...args.wid,
+					logger: args.logger
+				});
+				consecutiveErrors = 0;
+				if (status.status === "completed") return status.txHash != null ? { hash: status.txHash } : { hash: null };
+				if (status.status === "failed") throw new WithdrawalFailedError(status.reason);
+				return POLL_PENDING;
+			} catch (err) {
+				if (err instanceof WithdrawalFailedError) throw err;
+				consecutiveErrors++;
+				if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) throw new WithdrawalWatchError(err);
+				args.logger?.warn(`Transient error (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${err}`);
+				return POLL_PENDING;
+			}
+		}, {
+			stats,
+			signal: args.signal
+		});
+	} catch (err) {
+		if (err instanceof PollTimeoutError) throw new WithdrawalWatchError(err);
+		throw err;
+	}
+}
+async function createWithdrawalIdentifiers(args) {
+	const indexes = /* @__PURE__ */ new Map();
+	const results = [];
+	for (const w of args.withdrawalParams) {
+		const bridge = await findBridgeForWithdrawal(args.bridges, w);
+		if (bridge == null) throw new BridgeNotFoundError();
+		const currentIndex = indexes.get(bridge.route) ?? 0;
+		indexes.set(bridge.route, currentIndex + 1);
+		const wid = bridge.createWithdrawalIdentifier({
+			withdrawalParams: w,
+			index: currentIndex,
+			tx: args.intentTx
+		});
+		results.push({
+			bridge,
+			wid
+		});
+	}
+	return results;
+}
+async function findBridgeForWithdrawal(bridges, params) {
+	for (const bridge of bridges) if (await bridge.supports(params)) return bridge;
+}
+var BridgeNotFoundError = class extends BaseError {
+	constructor() {
+		super("Bridge adapter not found", { name: "BridgeNotFoundError" });
+	}
+};
+var WithdrawalFailedError = class extends BaseError {
+	constructor(reason) {
+		super(`Withdrawal failed: ${reason}`, { name: "WithdrawalFailedError" });
+	}
+};
+var WithdrawalWatchError = class extends BaseError {
+	constructor(cause) {
+		super("Withdrawal watch failed", {
+			name: "WithdrawalWatchError",
+			cause
+		});
+	}
+};
+
+//#endregion
+export { WithdrawalFailedError, WithdrawalWatchError, createWithdrawalIdentifiers, watchWithdrawal };

package/dist/src/intents/expirable-nonce.cjs

@@ -0,0 +1,90 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let _scure_base = require("@scure/base");
+let valibot = require("valibot");
+valibot = require_rolldown_runtime.__toESM(valibot);
+let near_api_js_lib_utils_serialize = require("near-api-js/lib/utils/serialize");
+
+//#region src/intents/expirable-nonce.ts
+const VERSIONED_MAGIC_PREFIX = new Uint8Array([
+	86,
+	40,
+	246,
+	198
+]);
+const LATEST_VERSION = 0;
+/**
+* Schema for validating decoded salted nonce structure.
+* The decoded value from `VersionedNonceBuilder.decodeNonce()` should match this structure.
+*/
+const saltedNonceSchema = valibot.object({
+	salt: valibot.array(valibot.number()),
+	inner: valibot.object({
+		deadline: valibot.bigint(),
+		nonce: valibot.array(valibot.number())
+	})
+});
+/**
+* VersionedNonce class representing a versioned expirable nonce
+*
+* @property version The version of the nonce
+* @property value The current value of nonce, it is unknown to allow for future version types
+*/
+var VersionedNonce = class VersionedNonce {
+	constructor(version, value) {
+		this.version = version;
+		this.value = value;
+	}
+	static latest(saltedNonce) {
+		return new VersionedNonce(LATEST_VERSION, saltedNonce);
+	}
+};
+const SALTED_NONCE_BORSH_SCHEMA = { struct: {
+	salt: { array: {
+		type: "u8",
+		len: 4
+	} },
+	inner: { struct: {
+		deadline: "u64",
+		nonce: { array: {
+			type: "u8",
+			len: 15
+		} }
+	} }
+} };
+let VersionedNonceBuilder;
+(function(_VersionedNonceBuilder) {
+	function encodeNonce(salt, deadline) {
+		if (salt.length !== 4) throw new Error(`Invalid salt length: ${salt.length}, expected 4`);
+		const deadlineBigInt = BigInt(deadline.getTime()) * 1000000n;
+		const nonceBytes = crypto.getRandomValues(new Uint8Array(15));
+		const borshBytes = new Uint8Array(27);
+		borshBytes.set(salt, 0);
+		new DataView(borshBytes.buffer, borshBytes.byteOffset, borshBytes.byteLength).setBigUint64(4, deadlineBigInt, true);
+		borshBytes.set(nonceBytes, 12);
+		const result = new Uint8Array(5 + borshBytes.length);
+		result.set(VERSIONED_MAGIC_PREFIX, 0);
+		result.set([LATEST_VERSION], 4);
+		result.set(borshBytes, 5);
+		return _scure_base.base64.encode(result);
+	}
+	_VersionedNonceBuilder.encodeNonce = encodeNonce;
+	function decodeNonce(encoded) {
+		const bytes = _scure_base.base64.decode(encoded);
+		if (bytes.length !== 32) throw new Error("Nonce too short");
+		const prefix = bytes.slice(0, 4);
+		const version = bytes[4];
+		const borshData = bytes.slice(5);
+		if (!prefix.every((byte, i) => byte === VERSIONED_MAGIC_PREFIX[i])) throw new Error("Invalid magic prefix");
+		return new VersionedNonce(version, (0, near_api_js_lib_utils_serialize.deserialize)(SALTED_NONCE_BORSH_SCHEMA, borshData));
+	}
+	_VersionedNonceBuilder.decodeNonce = decodeNonce;
+})(VersionedNonceBuilder || (VersionedNonceBuilder = {}));
+
+//#endregion
+Object.defineProperty(exports, 'VersionedNonceBuilder', {
+  enumerable: true,
+  get: function () {
+    return VersionedNonceBuilder;
+  }
+});
+exports.saltedNonceSchema = saltedNonceSchema;

package/dist/src/intents/expirable-nonce.d.cts

@@ -0,0 +1,44 @@
+//#region src/intents/expirable-nonce.d.ts
+
+type Salt = Uint8Array;
+declare class ExpirableNonce {
+  deadline: bigint;
+  nonce: Uint8Array;
+  constructor(deadline: bigint, nonce: Uint8Array);
+}
+declare class SaltedNonce {
+  salt: Salt;
+  inner: ExpirableNonce;
+  constructor(salt: Salt, inner: ExpirableNonce);
+}
+/**
+ * VersionedNonce class representing a versioned expirable nonce
+ *
+ * @property version The version of the nonce
+ * @property value The current value of nonce, it is unknown to allow for future version types
+ */
+declare class VersionedNonce {
+  version: number;
+  value: unknown;
+  constructor(version: number, value: unknown);
+  static latest(saltedNonce: SaltedNonce): VersionedNonce;
+}
+declare namespace VersionedNonceBuilder {
+  /**
+   * Encodes a versioned expirable nonce with the given salt and deadline
+   *
+   * @param salt The salt to use for the nonce
+   * @param deadline The expiration deadline for the nonce
+   * @returns The encoded nonce as a base64 string
+   */
+  function encodeNonce(salt: Salt, deadline: Date): string;
+  /**
+   * Decodes a versioned expirable nonce from a base64-encoded string
+   *
+   * @param encoded The encoded nonce string
+   * @returns The decoded VersionedNonce object
+   */
+  function decodeNonce(encoded: string): VersionedNonce;
+}
+//#endregion
+export { Salt, VersionedNonceBuilder };

package/dist/src/intents/expirable-nonce.d.ts

@@ -0,0 +1,45 @@
+import "valibot";
+
+//#region src/intents/expirable-nonce.d.ts
+type Salt = Uint8Array;
+declare class ExpirableNonce {
+  deadline: bigint;
+  nonce: Uint8Array;
+  constructor(deadline: bigint, nonce: Uint8Array);
+}
+declare class SaltedNonce {
+  salt: Salt;
+  inner: ExpirableNonce;
+  constructor(salt: Salt, inner: ExpirableNonce);
+}
+/**
+ * VersionedNonce class representing a versioned expirable nonce
+ *
+ * @property version The version of the nonce
+ * @property value The current value of nonce, it is unknown to allow for future version types
+ */
+declare class VersionedNonce {
+  version: number;
+  value: unknown;
+  constructor(version: number, value: unknown);
+  static latest(saltedNonce: SaltedNonce): VersionedNonce;
+}
+declare namespace VersionedNonceBuilder {
+  /**
+   * Encodes a versioned expirable nonce with the given salt and deadline
+   *
+   * @param salt The salt to use for the nonce
+   * @param deadline The expiration deadline for the nonce
+   * @returns The encoded nonce as a base64 string
+   */
+  function encodeNonce(salt: Salt, deadline: Date): string;
+  /**
+   * Decodes a versioned expirable nonce from a base64-encoded string
+   *
+   * @param encoded The encoded nonce string
+   * @returns The decoded VersionedNonce object
+   */
+  function decodeNonce(encoded: string): VersionedNonce;
+}
+//#endregion
+export { Salt, VersionedNonceBuilder };

package/dist/src/intents/expirable-nonce.js

@@ -0,0 +1,82 @@
+import { base64 } from "@scure/base";
+import * as v from "valibot";
+import { deserialize } from "near-api-js/lib/utils/serialize";
+
+//#region src/intents/expirable-nonce.ts
+const VERSIONED_MAGIC_PREFIX = new Uint8Array([
+	86,
+	40,
+	246,
+	198
+]);
+const LATEST_VERSION = 0;
+/**
+* Schema for validating decoded salted nonce structure.
+* The decoded value from `VersionedNonceBuilder.decodeNonce()` should match this structure.
+*/
+const saltedNonceSchema = v.object({
+	salt: v.array(v.number()),
+	inner: v.object({
+		deadline: v.bigint(),
+		nonce: v.array(v.number())
+	})
+});
+/**
+* VersionedNonce class representing a versioned expirable nonce
+*
+* @property version The version of the nonce
+* @property value The current value of nonce, it is unknown to allow for future version types
+*/
+var VersionedNonce = class VersionedNonce {
+	constructor(version, value) {
+		this.version = version;
+		this.value = value;
+	}
+	static latest(saltedNonce) {
+		return new VersionedNonce(LATEST_VERSION, saltedNonce);
+	}
+};
+const SALTED_NONCE_BORSH_SCHEMA = { struct: {
+	salt: { array: {
+		type: "u8",
+		len: 4
+	} },
+	inner: { struct: {
+		deadline: "u64",
+		nonce: { array: {
+			type: "u8",
+			len: 15
+		} }
+	} }
+} };
+let VersionedNonceBuilder;
+(function(_VersionedNonceBuilder) {
+	function encodeNonce(salt, deadline) {
+		if (salt.length !== 4) throw new Error(`Invalid salt length: ${salt.length}, expected 4`);
+		const deadlineBigInt = BigInt(deadline.getTime()) * 1000000n;
+		const nonceBytes = crypto.getRandomValues(new Uint8Array(15));
+		const borshBytes = new Uint8Array(27);
+		borshBytes.set(salt, 0);
+		new DataView(borshBytes.buffer, borshBytes.byteOffset, borshBytes.byteLength).setBigUint64(4, deadlineBigInt, true);
+		borshBytes.set(nonceBytes, 12);
+		const result = new Uint8Array(5 + borshBytes.length);
+		result.set(VERSIONED_MAGIC_PREFIX, 0);
+		result.set([LATEST_VERSION], 4);
+		result.set(borshBytes, 5);
+		return base64.encode(result);
+	}
+	_VersionedNonceBuilder.encodeNonce = encodeNonce;
+	function decodeNonce(encoded) {
+		const bytes = base64.decode(encoded);
+		if (bytes.length !== 32) throw new Error("Nonce too short");
+		const prefix = bytes.slice(0, 4);
+		const version = bytes[4];
+		const borshData = bytes.slice(5);
+		if (!prefix.every((byte, i) => byte === VERSIONED_MAGIC_PREFIX[i])) throw new Error("Invalid magic prefix");
+		return new VersionedNonce(version, deserialize(SALTED_NONCE_BORSH_SCHEMA, borshData));
+	}
+	_VersionedNonceBuilder.decodeNonce = decodeNonce;
+})(VersionedNonceBuilder || (VersionedNonceBuilder = {}));
+
+//#endregion
+export { VersionedNonceBuilder, saltedNonceSchema };

package/dist/src/intents/intent-executer-impl/intent-executer.cjs

@@ -0,0 +1,85 @@
+const require_intent_hash = require('../intent-hash.cjs');
+const require_intent_payload_factory = require('../intent-payload-factory.cjs');
+
+//#region src/intents/intent-executer-impl/intent-executer.ts
+var IntentExecuter = class {
+	constructor(args) {
+		this.envConfig = args.envConfig;
+		this.logger = args.logger;
+		this.intentPayloadFactory = args.intentPayloadFactory;
+		this.intentRelayer = args.intentRelayer;
+		this.intentSigner = args.intentSigner;
+		this.onBeforePublishIntent = args.onBeforePublishIntent;
+	}
+	async signAndSendIntent({ relayParams: relayParamsFactory, salt, signedIntents, ...intentParams }) {
+		const verifyingContract = this.envConfig.contractID;
+		let intentPayload = require_intent_payload_factory.defaultIntentPayloadFactory(salt, {
+			verifying_contract: verifyingContract,
+			...intentParams
+		});
+		if (this.intentPayloadFactory) intentPayload = await mergeIntentPayloads(intentPayload, this.intentPayloadFactory, salt);
+		const multiPayload = await this.intentSigner.signIntent(intentPayload);
+		const relayParams = relayParamsFactory ? await relayParamsFactory() : {};
+		if (this.onBeforePublishIntent) {
+			const intentHash = await require_intent_hash.computeIntentHash(multiPayload);
+			await this.onBeforePublishIntent({
+				intentHash,
+				intentPayload,
+				multiPayload,
+				relayParams
+			});
+		}
+		const composedPayloads = composeMultiPayloads(multiPayload, signedIntents);
+		if (composedPayloads.length > 1) {
+			const quoteHashes = relayParams.quoteHashes ?? [];
+			return { ticket: (await this.intentRelayer.publishIntents({
+				multiPayloads: composedPayloads,
+				quoteHashes
+			}, { logger: this.logger }))[signedIntents?.before?.length ?? 0] };
+		}
+		return { ticket: await this.intentRelayer.publishIntent({
+			multiPayload,
+			...relayParams
+		}, { logger: this.logger }) };
+	}
+	async waitForSettlement(ticket, ctx) {
+		return this.intentRelayer.waitForSettlement(ticket, {
+			logger: this.logger,
+			signal: ctx?.signal
+		});
+	}
+	async sendSignedIntents(params) {
+		return { tickets: await this.intentRelayer.publishIntents({
+			multiPayloads: params.multiPayloads,
+			quoteHashes: params.quoteHashes ?? []
+		}, { logger: this.logger }) };
+	}
+};
+async function mergeIntentPayloads(defaultPayload, intentPayloadFactory, salt) {
+	const customPayload = await intentPayloadFactory(defaultPayload);
+	const customPayloadIntents = customPayload.intents ?? [];
+	const { nonce: _nonce, ...basePayload } = defaultPayload;
+	return require_intent_payload_factory.defaultIntentPayloadFactory(salt, {
+		...basePayload,
+		...customPayload,
+		intents: Array.from(new Set([...customPayloadIntents, ...basePayload.intents]))
+	});
+}
+/**
+* Composes a new MultiPayload with pre-signed intents for atomic execution.
+*
+* @param newPayload - The newly signed MultiPayload
+* @param signedIntents - Optional configuration with before/after intents
+* @returns Array of MultiPayloads in execution order: [before...] -> newPayload -> [after...]
+*/
+function composeMultiPayloads(newPayload, signedIntents) {
+	if (!signedIntents) return [newPayload];
+	const result = [];
+	if (signedIntents.before && signedIntents.before.length > 0) result.push(...signedIntents.before);
+	result.push(newPayload);
+	if (signedIntents.after && signedIntents.after.length > 0) result.push(...signedIntents.after);
+	return result;
+}
+
+//#endregion
+exports.IntentExecuter = IntentExecuter;

package/dist/src/intents/intent-executer-impl/intent-executer.d.cts

@@ -0,0 +1,20 @@
+import { IntentHash, IntentPayload, MultiPayload, RelayParamsDefault } from "../shared-types.cjs";
+import { EnvConfig, ILogger } from "lampamazaza-internal-utils";
+
+//#region src/intents/intent-executer-impl/intent-executer.d.ts
+
+/**
+ * Hook function called before publishing an intent.
+ * Can be used for persistence, logging, analytics, etc.
+ *
+ * @param intentData - The intent data about to be published
+ * @returns A promise that resolves when the hook is complete
+ */
+type OnBeforePublishIntentHook<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = (intentData: {
+  intentHash: IntentHash;
+  intentPayload: IntentPayload;
+  multiPayload: MultiPayload;
+  relayParams: RelayParams;
+}) => Promise<void> | void;
+//#endregion
+export { OnBeforePublishIntentHook };

package/dist/src/intents/intent-executer-impl/intent-executer.d.ts

@@ -0,0 +1,24 @@
+import "../expirable-nonce.js";
+import { IntentHash, IntentPayload, MultiPayload, RelayParamsDefault } from "../shared-types.js";
+import "../interfaces/intent-executer.js";
+import "../../shared-types.js";
+import "../interfaces/intent-relayer.js";
+import { EnvConfig, ILogger } from "lampamazaza-internal-utils";
+
+//#region src/intents/intent-executer-impl/intent-executer.d.ts
+
+/**
+ * Hook function called before publishing an intent.
+ * Can be used for persistence, logging, analytics, etc.
+ *
+ * @param intentData - The intent data about to be published
+ * @returns A promise that resolves when the hook is complete
+ */
+type OnBeforePublishIntentHook<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = (intentData: {
+  intentHash: IntentHash;
+  intentPayload: IntentPayload;
+  multiPayload: MultiPayload;
+  relayParams: RelayParams;
+}) => Promise<void> | void;
+//#endregion
+export { OnBeforePublishIntentHook };

package/dist/src/intents/intent-executer-impl/intent-executer.js

@@ -0,0 +1,85 @@
+import { computeIntentHash } from "../intent-hash.js";
+import { defaultIntentPayloadFactory } from "../intent-payload-factory.js";
+
+//#region src/intents/intent-executer-impl/intent-executer.ts
+var IntentExecuter = class {
+	constructor(args) {
+		this.envConfig = args.envConfig;
+		this.logger = args.logger;
+		this.intentPayloadFactory = args.intentPayloadFactory;
+		this.intentRelayer = args.intentRelayer;
+		this.intentSigner = args.intentSigner;
+		this.onBeforePublishIntent = args.onBeforePublishIntent;
+	}
+	async signAndSendIntent({ relayParams: relayParamsFactory, salt, signedIntents, ...intentParams }) {
+		const verifyingContract = this.envConfig.contractID;
+		let intentPayload = defaultIntentPayloadFactory(salt, {
+			verifying_contract: verifyingContract,
+			...intentParams
+		});
+		if (this.intentPayloadFactory) intentPayload = await mergeIntentPayloads(intentPayload, this.intentPayloadFactory, salt);
+		const multiPayload = await this.intentSigner.signIntent(intentPayload);
+		const relayParams = relayParamsFactory ? await relayParamsFactory() : {};
+		if (this.onBeforePublishIntent) {
+			const intentHash = await computeIntentHash(multiPayload);
+			await this.onBeforePublishIntent({
+				intentHash,
+				intentPayload,
+				multiPayload,
+				relayParams
+			});
+		}
+		const composedPayloads = composeMultiPayloads(multiPayload, signedIntents);
+		if (composedPayloads.length > 1) {
+			const quoteHashes = relayParams.quoteHashes ?? [];
+			return { ticket: (await this.intentRelayer.publishIntents({
+				multiPayloads: composedPayloads,
+				quoteHashes
+			}, { logger: this.logger }))[signedIntents?.before?.length ?? 0] };
+		}
+		return { ticket: await this.intentRelayer.publishIntent({
+			multiPayload,
+			...relayParams
+		}, { logger: this.logger }) };
+	}
+	async waitForSettlement(ticket, ctx) {
+		return this.intentRelayer.waitForSettlement(ticket, {
+			logger: this.logger,
+			signal: ctx?.signal
+		});
+	}
+	async sendSignedIntents(params) {
+		return { tickets: await this.intentRelayer.publishIntents({
+			multiPayloads: params.multiPayloads,
+			quoteHashes: params.quoteHashes ?? []
+		}, { logger: this.logger }) };
+	}
+};
+async function mergeIntentPayloads(defaultPayload, intentPayloadFactory, salt) {
+	const customPayload = await intentPayloadFactory(defaultPayload);
+	const customPayloadIntents = customPayload.intents ?? [];
+	const { nonce: _nonce, ...basePayload } = defaultPayload;
+	return defaultIntentPayloadFactory(salt, {
+		...basePayload,
+		...customPayload,
+		intents: Array.from(new Set([...customPayloadIntents, ...basePayload.intents]))
+	});
+}
+/**
+* Composes a new MultiPayload with pre-signed intents for atomic execution.
+*
+* @param newPayload - The newly signed MultiPayload
+* @param signedIntents - Optional configuration with before/after intents
+* @returns Array of MultiPayloads in execution order: [before...] -> newPayload -> [after...]
+*/
+function composeMultiPayloads(newPayload, signedIntents) {
+	if (!signedIntents) return [newPayload];
+	const result = [];
+	if (signedIntents.before && signedIntents.before.length > 0) result.push(...signedIntents.before);
+	result.push(newPayload);
+	if (signedIntents.after && signedIntents.after.length > 0) result.push(...signedIntents.after);
+	return result;
+}
+
+//#endregion
+export { IntentExecuter };

package/dist/src/intents/intent-hash.cjs

@@ -0,0 +1,48 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_nep413 = require('./intent-hashes/nep413.cjs');
+const require_erc191 = require('./intent-hashes/erc191.cjs');
+const require_tip191 = require('./intent-hashes/tip191.cjs');
+const require_raw_ed25519 = require('./intent-hashes/raw-ed25519.cjs');
+const require_webauthn = require('./intent-hashes/webauthn.cjs');
+const require_ton_connect = require('./intent-hashes/ton-connect.cjs');
+const require_sep53 = require('./intent-hashes/sep53.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/intents/intent-hash.ts
+/**
+* Computes the intent hash for a MultiPayload locally, without needing to publish it.
+* This follows the same logic as the NEAR intents repository:
+* https://github.com/near/intents/blob/11fe297dddd50936b297485e147548f5f9a69200/core/src/payload/multi.rs#L56
+*
+* Different standards use different hash functions:
+* - NEP-413: SHA-256 (of Borsh-serialized payload)
+* - ERC-191: Keccak256 (of prefixed message)
+* - TIP-191: Keccak256 (of prefixed message)
+* - Raw Ed25519: SHA-256 (of raw message)
+* - WebAuthn: SHA-256 (of raw message)
+* - TON Connect: SHA-256 (of formatted message)
+* - SEP-53: SHA-256 (of prefixed message)
+*
+* @param signed - The multi-payload to hash
+* @returns 32-byte hash as Uint8Array
+*/
+async function computeIntentHashHashBytes(signed) {
+	const { standard } = signed;
+	switch (standard) {
+		case "nep413": return require_nep413.computeSignedNep413Hash(signed);
+		case "erc191": return require_erc191.computeSignedErc191Hash(signed);
+		case "tip191": return require_tip191.computeSignedTip191Hash(signed);
+		case "raw_ed25519": return require_raw_ed25519.computeSignedRawEd25519Hash(signed);
+		case "webauthn": return require_webauthn.computeSignedWebAuthnHash(signed);
+		case "ton_connect": return require_ton_connect.computeSignedTonConnectHash(signed);
+		case "sep53": return require_sep53.computeSignedSep53Hash(signed);
+		default: throw new Error(`Unknown payload standard: ${standard}`);
+	}
+}
+async function computeIntentHash(multiPayload) {
+	const hashBytes = await computeIntentHashHashBytes(multiPayload);
+	return _scure_base.base58.encode(hashBytes);
+}
+
+//#endregion
+exports.computeIntentHash = computeIntentHash;

package/dist/src/intents/intent-hash.d.cts

@@ -0,0 +1,8 @@
+import { IntentHash } from "./shared-types.cjs";
+import { MultiPayload } from "lampamazaza-contract-types";
+
+//#region src/intents/intent-hash.d.ts
+
+declare function computeIntentHash(multiPayload: MultiPayload): Promise<IntentHash>;
+//#endregion
+export { computeIntentHash };

package/dist/src/intents/intent-hash.d.ts

@@ -0,0 +1,8 @@
+import { IntentHash } from "./shared-types.js";
+import { MultiPayload } from "lampamazaza-contract-types";
+
+//#region src/intents/intent-hash.d.ts
+
+declare function computeIntentHash(multiPayload: MultiPayload): Promise<IntentHash>;
+//#endregion
+export { computeIntentHash };

package/dist/src/intents/intent-hash.js

@@ -0,0 +1,47 @@
+import { computeSignedNep413Hash } from "./intent-hashes/nep413.js";
+import { computeSignedErc191Hash } from "./intent-hashes/erc191.js";
+import { computeSignedTip191Hash } from "./intent-hashes/tip191.js";
+import { computeSignedRawEd25519Hash } from "./intent-hashes/raw-ed25519.js";
+import { computeSignedWebAuthnHash } from "./intent-hashes/webauthn.js";
+import { computeSignedTonConnectHash } from "./intent-hashes/ton-connect.js";
+import { computeSignedSep53Hash } from "./intent-hashes/sep53.js";
+import { base58 } from "@scure/base";
+
+//#region src/intents/intent-hash.ts
+/**
+* Computes the intent hash for a MultiPayload locally, without needing to publish it.
+* This follows the same logic as the NEAR intents repository:
+* https://github.com/near/intents/blob/11fe297dddd50936b297485e147548f5f9a69200/core/src/payload/multi.rs#L56
+*
+* Different standards use different hash functions:
+* - NEP-413: SHA-256 (of Borsh-serialized payload)
+* - ERC-191: Keccak256 (of prefixed message)
+* - TIP-191: Keccak256 (of prefixed message)
+* - Raw Ed25519: SHA-256 (of raw message)
+* - WebAuthn: SHA-256 (of raw message)
+* - TON Connect: SHA-256 (of formatted message)
+* - SEP-53: SHA-256 (of prefixed message)
+*
+* @param signed - The multi-payload to hash
+* @returns 32-byte hash as Uint8Array
+*/
+async function computeIntentHashHashBytes(signed) {
+	const { standard } = signed;
+	switch (standard) {
+		case "nep413": return computeSignedNep413Hash(signed);
+		case "erc191": return computeSignedErc191Hash(signed);
+		case "tip191": return computeSignedTip191Hash(signed);
+		case "raw_ed25519": return computeSignedRawEd25519Hash(signed);
+		case "webauthn": return computeSignedWebAuthnHash(signed);
+		case "ton_connect": return computeSignedTonConnectHash(signed);
+		case "sep53": return computeSignedSep53Hash(signed);
+		default: throw new Error(`Unknown payload standard: ${standard}`);
+	}
+}
+async function computeIntentHash(multiPayload) {
+	const hashBytes = await computeIntentHashHashBytes(multiPayload);
+	return base58.encode(hashBytes);
+}
+
+//#endregion
+export { computeIntentHash };