lampamazaza-new-intents-sdk 0.47.1

package/dist/src/intents/intent-hashes/erc191.cjs

@@ -0,0 +1,38 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _noble_hashes_sha3 = require("@noble/hashes/sha3");
+
+//#region src/intents/intent-hashes/erc191.ts
+/**
+* Compute the prehash for ERC-191 payload
+* Format: "\x19Ethereum Signed Message:\n" + length + message
+*/
+function computeErc191Prehash(payload) {
+	const data = new TextEncoder().encode(payload);
+	const prefix = new TextEncoder().encode(`\x19Ethereum Signed Message:\n${data.length}`);
+	const result = new Uint8Array(prefix.length + data.length);
+	result.set(prefix, 0);
+	result.set(data, prefix.length);
+	return result;
+}
+/**
+* Compute the Keccak256 hash of an ERC-191 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeErc191Hash(payload) {
+	return (0, _noble_hashes_sha3.keccak_256)(computeErc191Prehash(payload));
+}
+/**
+* Compute hash from a signed ERC-191 payload
+*
+* @param signedPayload - The signed ERC-191 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedErc191Hash(signedPayload) {
+	return computeErc191Hash(signedPayload.payload);
+}
+
+//#endregion
+exports.computeSignedErc191Hash = computeSignedErc191Hash;

package/dist/src/intents/intent-hashes/erc191.js

@@ -0,0 +1,37 @@
+import { keccak_256 } from "@noble/hashes/sha3";
+
+//#region src/intents/intent-hashes/erc191.ts
+/**
+* Compute the prehash for ERC-191 payload
+* Format: "\x19Ethereum Signed Message:\n" + length + message
+*/
+function computeErc191Prehash(payload) {
+	const data = new TextEncoder().encode(payload);
+	const prefix = new TextEncoder().encode(`\x19Ethereum Signed Message:\n${data.length}`);
+	const result = new Uint8Array(prefix.length + data.length);
+	result.set(prefix, 0);
+	result.set(data, prefix.length);
+	return result;
+}
+/**
+* Compute the Keccak256 hash of an ERC-191 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeErc191Hash(payload) {
+	return keccak_256(computeErc191Prehash(payload));
+}
+/**
+* Compute hash from a signed ERC-191 payload
+*
+* @param signedPayload - The signed ERC-191 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedErc191Hash(signedPayload) {
+	return computeErc191Hash(signedPayload.payload);
+}
+
+//#endregion
+export { computeSignedErc191Hash };

package/dist/src/intents/intent-hashes/nep413.cjs

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_nep413 = require('../../lib/nep413.cjs');
+let _scure_base = require("@scure/base");
+
+//#region src/intents/intent-hashes/nep413.ts
+/**
+* Compute hash from a signed NEP-413 payload
+*
+* @param signed - The signed NEP-413 payload
+* @returns 32-byte hash as Uint8Array
+*/
+async function computeSignedNep413Hash(signed) {
+	const payload = signed.payload;
+	return require_nep413.hashNEP413Message({
+		message: payload.message,
+		recipient: payload.recipient,
+		nonce: Array.from(_scure_base.base64.decode(payload.nonce)),
+		callback_url: payload.callbackUrl
+	});
+}
+
+//#endregion
+exports.computeSignedNep413Hash = computeSignedNep413Hash;

package/dist/src/intents/intent-hashes/nep413.js

@@ -0,0 +1,22 @@
+import { hashNEP413Message } from "../../lib/nep413.js";
+import { base64 } from "@scure/base";
+
+//#region src/intents/intent-hashes/nep413.ts
+/**
+* Compute hash from a signed NEP-413 payload
+*
+* @param signed - The signed NEP-413 payload
+* @returns 32-byte hash as Uint8Array
+*/
+async function computeSignedNep413Hash(signed) {
+	const payload = signed.payload;
+	return hashNEP413Message({
+		message: payload.message,
+		recipient: payload.recipient,
+		nonce: Array.from(base64.decode(payload.nonce)),
+		callback_url: payload.callbackUrl
+	});
+}
+
+//#endregion
+export { computeSignedNep413Hash };

package/dist/src/intents/intent-hashes/raw-ed25519.cjs

@@ -0,0 +1,26 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+
+//#region src/intents/intent-hashes/raw-ed25519.ts
+/**
+* Compute the SHA-256 hash of a Raw Ed25519 payload
+* This simply hashes the UTF-8 encoded payload string
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeRawEd25519Hash(payload) {
+	return (0, _noble_hashes_sha2.sha256)(new TextEncoder().encode(payload));
+}
+/**
+* Compute hash from a signed Raw Ed25519 payload
+*
+* @param signedPayload - The signed Raw Ed25519 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedRawEd25519Hash(signedPayload) {
+	return computeRawEd25519Hash(signedPayload.payload);
+}
+
+//#endregion
+exports.computeSignedRawEd25519Hash = computeSignedRawEd25519Hash;

package/dist/src/intents/intent-hashes/raw-ed25519.js

@@ -0,0 +1,25 @@
+import { sha256 } from "@noble/hashes/sha2";
+
+//#region src/intents/intent-hashes/raw-ed25519.ts
+/**
+* Compute the SHA-256 hash of a Raw Ed25519 payload
+* This simply hashes the UTF-8 encoded payload string
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeRawEd25519Hash(payload) {
+	return sha256(new TextEncoder().encode(payload));
+}
+/**
+* Compute hash from a signed Raw Ed25519 payload
+*
+* @param signedPayload - The signed Raw Ed25519 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedRawEd25519Hash(signedPayload) {
+	return computeRawEd25519Hash(signedPayload.payload);
+}
+
+//#endregion
+export { computeSignedRawEd25519Hash };

package/dist/src/intents/intent-hashes/sep53.cjs

@@ -0,0 +1,36 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let lampamazaza_internal_utils = require("lampamazaza-internal-utils");
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+
+//#region src/intents/intent-hashes/sep53.ts
+/**
+* Compute the prehash for SEP-53 payload
+* Format: "Stellar Signed Message:\n" + message
+*/
+function computeSep53Prehash(payload) {
+	const prefix = new TextEncoder().encode("Stellar Signed Message:\n");
+	const data = new TextEncoder().encode(payload);
+	return lampamazaza_internal_utils.utils.concatUint8Arrays([prefix, data]);
+}
+/**
+* Compute the SHA-256 hash of a SEP-53 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSep53Hash(payload) {
+	return (0, _noble_hashes_sha2.sha256)(computeSep53Prehash(payload));
+}
+/**
+* Compute hash from a signed SEP-53 payload
+*
+* @param signedPayload - The signed SEP-53 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedSep53Hash(signedPayload) {
+	return computeSep53Hash(signedPayload.payload);
+}
+
+//#endregion
+exports.computeSignedSep53Hash = computeSignedSep53Hash;

package/dist/src/intents/intent-hashes/sep53.js

@@ -0,0 +1,35 @@
+import { utils } from "lampamazaza-internal-utils";
+import { sha256 } from "@noble/hashes/sha2";
+
+//#region src/intents/intent-hashes/sep53.ts
+/**
+* Compute the prehash for SEP-53 payload
+* Format: "Stellar Signed Message:\n" + message
+*/
+function computeSep53Prehash(payload) {
+	const prefix = new TextEncoder().encode("Stellar Signed Message:\n");
+	const data = new TextEncoder().encode(payload);
+	return utils.concatUint8Arrays([prefix, data]);
+}
+/**
+* Compute the SHA-256 hash of a SEP-53 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSep53Hash(payload) {
+	return sha256(computeSep53Prehash(payload));
+}
+/**
+* Compute hash from a signed SEP-53 payload
+*
+* @param signedPayload - The signed SEP-53 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedSep53Hash(signedPayload) {
+	return computeSep53Hash(signedPayload.payload);
+}
+
+//#endregion
+export { computeSignedSep53Hash };

package/dist/src/intents/intent-hashes/tip191.cjs

@@ -0,0 +1,39 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _noble_hashes_sha3 = require("@noble/hashes/sha3");
+
+//#region src/intents/intent-hashes/tip191.ts
+/**
+* Compute the prehash for TIP-191 payload
+* Format: "\x19TRON Signed Message:\n" + length + message
+* Note: Prefix from https://tronweb.network/docu/docs/Sign%20and%20Verify%20Message/
+*/
+function computeTip191Prehash(payload) {
+	const data = new TextEncoder().encode(payload);
+	const prefix = new TextEncoder().encode(`\x19TRON Signed Message:\n${data.length}`);
+	const result = new Uint8Array(prefix.length + data.length);
+	result.set(prefix, 0);
+	result.set(data, prefix.length);
+	return result;
+}
+/**
+* Compute the Keccak256 hash of a TIP-191 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeTip191Hash(payload) {
+	return (0, _noble_hashes_sha3.keccak_256)(computeTip191Prehash(payload));
+}
+/**
+* Compute hash from a signed TIP-191 payload
+*
+* @param signedPayload - The signed TIP-191 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedTip191Hash(signedPayload) {
+	return computeTip191Hash(signedPayload.payload);
+}
+
+//#endregion
+exports.computeSignedTip191Hash = computeSignedTip191Hash;

package/dist/src/intents/intent-hashes/tip191.js

@@ -0,0 +1,38 @@
+import { keccak_256 } from "@noble/hashes/sha3";
+
+//#region src/intents/intent-hashes/tip191.ts
+/**
+* Compute the prehash for TIP-191 payload
+* Format: "\x19TRON Signed Message:\n" + length + message
+* Note: Prefix from https://tronweb.network/docu/docs/Sign%20and%20Verify%20Message/
+*/
+function computeTip191Prehash(payload) {
+	const data = new TextEncoder().encode(payload);
+	const prefix = new TextEncoder().encode(`\x19TRON Signed Message:\n${data.length}`);
+	const result = new Uint8Array(prefix.length + data.length);
+	result.set(prefix, 0);
+	result.set(data, prefix.length);
+	return result;
+}
+/**
+* Compute the Keccak256 hash of a TIP-191 payload
+* This is the hash that should be signed
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeTip191Hash(payload) {
+	return keccak_256(computeTip191Prehash(payload));
+}
+/**
+* Compute hash from a signed TIP-191 payload
+*
+* @param signedPayload - The signed TIP-191 payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedTip191Hash(signedPayload) {
+	return computeTip191Hash(signedPayload.payload);
+}
+
+//#endregion
+export { computeSignedTip191Hash };

package/dist/src/intents/intent-hashes/ton-connect.cjs

@@ -0,0 +1,105 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+
+//#region src/intents/intent-hashes/ton-connect.ts
+/**
+* Convert number to big-endian byte array
+*/
+function numberToBigEndian(num, bytes) {
+	const result = new Uint8Array(bytes);
+	for (let i = bytes - 1; i >= 0; i--) {
+		result[i] = num & 255;
+		num >>= 8;
+	}
+	return result;
+}
+/**
+* Parse TON address string to TonAddress object
+* Supports raw format: "workchain:address_hex"
+* Example: "0:f4809e5ffac9dc42a6b1d94c5e74ad5fd86378de675c805f2274d0055cbc9378"
+*
+* @param addressString - TON address string in raw format
+* @returns Parsed TonAddress object
+*/
+function parseTonAddress(addressString) {
+	const parts = addressString.split(":");
+	if (parts.length !== 2) throw new Error(`Invalid TON address format: ${addressString}. Expected "workchain:address_hex"`);
+	const workchainId = parseInt(parts[0], 10);
+	if (Number.isNaN(workchainId)) throw new Error(`Invalid workchain ID: ${parts[0]}`);
+	const addressHex = parts[1].startsWith("0x") ? parts[1].slice(2) : parts[1];
+	if (addressHex.length !== 64) throw new Error(`Invalid address length: expected 64 hex characters, got ${addressHex.length}`);
+	const address = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) address[i] = parseInt(addressHex.slice(i * 2, i * 2 + 2), 16);
+	return {
+		workchainId,
+		address
+	};
+}
+/**
+* Compute the SHA-256 hash of a TON Connect payload
+*
+* For text and binary payloads:
+* Hash = SHA256(
+*   0xffff +
+*   "ton-connect/sign-data/" +
+*   workchain_id (4 bytes BE) +
+*   address (32 bytes) +
+*   domain_len (4 bytes BE) +
+*   domain +
+*   timestamp (8 bytes BE) +
+*   payload_type ("txt" or "bin") +
+*   payload_len (4 bytes BE) +
+*   payload
+* )
+*
+* For cell payloads: Uses TON TLB message serialization (not fully implemented here)
+*
+* @param payload - The TON Connect payload to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeTonConnectHash(payload) {
+	const { address, domain, timestamp, payload: payloadSchema } = payload;
+	const parsedAddress = parseTonAddress(address);
+	const schemaType = payloadSchema.type;
+	switch (schemaType) {
+		case "text": {
+			const payloadPrefix = "txt";
+			const payloadData = new TextEncoder().encode(payloadSchema.text);
+			const parts = [
+				new Uint8Array([255, 255]),
+				new TextEncoder().encode("ton-connect/sign-data/"),
+				numberToBigEndian(parsedAddress.workchainId, 4),
+				parsedAddress.address,
+				numberToBigEndian(domain.length, 4),
+				new TextEncoder().encode(domain),
+				numberToBigEndian(Number(timestamp), 8),
+				new TextEncoder().encode(payloadPrefix),
+				numberToBigEndian(payloadData.length, 4),
+				payloadData
+			];
+			const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+			const message = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const part of parts) {
+				message.set(part, offset);
+				offset += part.length;
+			}
+			return (0, _noble_hashes_sha2.sha256)(message);
+		}
+		case "binary": throw new Error("Binary payload hashing is not yet supported");
+		case "cell": throw new Error("Cell payload hashing is not yet supported.");
+		default: throw new Error(`Unknown TON Connect payload type: ${schemaType}`);
+	}
+}
+/**
+* Compute hash from a signed TON Connect payload
+*
+* @param signedPayload - The signed TON Connect payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedTonConnectHash(signedPayload) {
+	return computeTonConnectHash(signedPayload);
+}
+
+//#endregion
+exports.computeSignedTonConnectHash = computeSignedTonConnectHash;

package/dist/src/intents/intent-hashes/ton-connect.js

@@ -0,0 +1,104 @@
+import { sha256 } from "@noble/hashes/sha2";
+
+//#region src/intents/intent-hashes/ton-connect.ts
+/**
+* Convert number to big-endian byte array
+*/
+function numberToBigEndian(num, bytes) {
+	const result = new Uint8Array(bytes);
+	for (let i = bytes - 1; i >= 0; i--) {
+		result[i] = num & 255;
+		num >>= 8;
+	}
+	return result;
+}
+/**
+* Parse TON address string to TonAddress object
+* Supports raw format: "workchain:address_hex"
+* Example: "0:f4809e5ffac9dc42a6b1d94c5e74ad5fd86378de675c805f2274d0055cbc9378"
+*
+* @param addressString - TON address string in raw format
+* @returns Parsed TonAddress object
+*/
+function parseTonAddress(addressString) {
+	const parts = addressString.split(":");
+	if (parts.length !== 2) throw new Error(`Invalid TON address format: ${addressString}. Expected "workchain:address_hex"`);
+	const workchainId = parseInt(parts[0], 10);
+	if (Number.isNaN(workchainId)) throw new Error(`Invalid workchain ID: ${parts[0]}`);
+	const addressHex = parts[1].startsWith("0x") ? parts[1].slice(2) : parts[1];
+	if (addressHex.length !== 64) throw new Error(`Invalid address length: expected 64 hex characters, got ${addressHex.length}`);
+	const address = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) address[i] = parseInt(addressHex.slice(i * 2, i * 2 + 2), 16);
+	return {
+		workchainId,
+		address
+	};
+}
+/**
+* Compute the SHA-256 hash of a TON Connect payload
+*
+* For text and binary payloads:
+* Hash = SHA256(
+*   0xffff +
+*   "ton-connect/sign-data/" +
+*   workchain_id (4 bytes BE) +
+*   address (32 bytes) +
+*   domain_len (4 bytes BE) +
+*   domain +
+*   timestamp (8 bytes BE) +
+*   payload_type ("txt" or "bin") +
+*   payload_len (4 bytes BE) +
+*   payload
+* )
+*
+* For cell payloads: Uses TON TLB message serialization (not fully implemented here)
+*
+* @param payload - The TON Connect payload to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeTonConnectHash(payload) {
+	const { address, domain, timestamp, payload: payloadSchema } = payload;
+	const parsedAddress = parseTonAddress(address);
+	const schemaType = payloadSchema.type;
+	switch (schemaType) {
+		case "text": {
+			const payloadPrefix = "txt";
+			const payloadData = new TextEncoder().encode(payloadSchema.text);
+			const parts = [
+				new Uint8Array([255, 255]),
+				new TextEncoder().encode("ton-connect/sign-data/"),
+				numberToBigEndian(parsedAddress.workchainId, 4),
+				parsedAddress.address,
+				numberToBigEndian(domain.length, 4),
+				new TextEncoder().encode(domain),
+				numberToBigEndian(Number(timestamp), 8),
+				new TextEncoder().encode(payloadPrefix),
+				numberToBigEndian(payloadData.length, 4),
+				payloadData
+			];
+			const totalLength = parts.reduce((sum, part) => sum + part.length, 0);
+			const message = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const part of parts) {
+				message.set(part, offset);
+				offset += part.length;
+			}
+			return sha256(message);
+		}
+		case "binary": throw new Error("Binary payload hashing is not yet supported");
+		case "cell": throw new Error("Cell payload hashing is not yet supported.");
+		default: throw new Error(`Unknown TON Connect payload type: ${schemaType}`);
+	}
+}
+/**
+* Compute hash from a signed TON Connect payload
+*
+* @param signedPayload - The signed TON Connect payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedTonConnectHash(signedPayload) {
+	return computeTonConnectHash(signedPayload);
+}
+
+//#endregion
+export { computeSignedTonConnectHash };

package/dist/src/intents/intent-hashes/webauthn.cjs

@@ -0,0 +1,26 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let _noble_hashes_sha2 = require("@noble/hashes/sha2");
+
+//#region src/intents/intent-hashes/webauthn.ts
+/**
+* Compute the SHA-256 hash of a WebAuthn payload
+* This simply hashes the UTF-8 encoded payload string
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeWebAuthnHash(payload) {
+	return (0, _noble_hashes_sha2.sha256)(new TextEncoder().encode(payload));
+}
+/**
+* Compute hash from a signed WebAuthn payload
+*
+* @param signedPayload - The signed WebAuthn payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedWebAuthnHash(signedPayload) {
+	return computeWebAuthnHash(signedPayload.payload);
+}
+
+//#endregion
+exports.computeSignedWebAuthnHash = computeSignedWebAuthnHash;

package/dist/src/intents/intent-hashes/webauthn.js

@@ -0,0 +1,25 @@
+import { sha256 } from "@noble/hashes/sha2";
+
+//#region src/intents/intent-hashes/webauthn.ts
+/**
+* Compute the SHA-256 hash of a WebAuthn payload
+* This simply hashes the UTF-8 encoded payload string
+*
+* @param payload - The message string to hash
+* @returns 32-byte hash as Uint8Array
+*/
+function computeWebAuthnHash(payload) {
+	return sha256(new TextEncoder().encode(payload));
+}
+/**
+* Compute hash from a signed WebAuthn payload
+*
+* @param signedPayload - The signed WebAuthn payload
+* @returns 32-byte hash as Uint8Array
+*/
+function computeSignedWebAuthnHash(signedPayload) {
+	return computeWebAuthnHash(signedPayload.payload);
+}
+
+//#endregion
+export { computeSignedWebAuthnHash };