@hwlt/era-connect 0.3.0 → 0.4.0

package/dist/verify.d.cts

@@ -94,6 +94,24 @@ interface VerifyCardanoSignatureArgs {
  */
 declare function verifyCardanoSignature(args: VerifyCardanoSignatureArgs): VerifyResult;
 //#endregion
+//#region src/verify/cosmos.d.ts
+interface VerifyCosmosSignatureArgs {
+  /** The exact SignDoc bytes the request carried. */
+  readonly signData: Uint8Array;
+  /**
+   * Digest family: vanilla Cosmos zones hash with sha256; Ethermint chains
+   * (Injective, Evmos, Dymension) with keccak256.
+   */
+  readonly digest: 'sha256' | 'keccak256';
+  /** 64-byte compact signature from the reply. */
+  readonly signature: Uint8Array;
+  /** 33-byte compressed public key (from the reply, or derived from your linked xpub). */
+  readonly publicKey: Uint8Array;
+  /** Optional binding: the key you EXPECT (derived from the linked account). */
+  readonly expectedPublicKey?: Uint8Array;
+}
+declare function verifyCosmosSignature(args: VerifyCosmosSignatureArgs): VerifyResult;
+//#endregion
 //#region src/verify/evm.d.ts
 interface VerifyEvmSignatureArgs {
   /** The exact bytes the request carried in `signData`. */
@@ -168,6 +186,21 @@ interface VerifySolanaSignatureArgs {
 }
 declare function verifySolanaSignature(args: VerifySolanaSignatureArgs): VerifyResult;
 //#endregion
+//#region src/verify/sui.d.ts
+interface VerifySuiSignatureArgs {
+  /** The intent message the request carried (or pass `messageHash` for the hash variant). */
+  readonly intentMessage?: Uint8Array;
+  readonly messageHash?: Uint8Array;
+  /** 64-byte Ed25519 signature from the reply. */
+  readonly signature: Uint8Array;
+  /** The signer key the reply carried. */
+  readonly publicKey: Uint8Array;
+  /** The linked account's key (`accounts.sui()[i].publicKey`) — binds the reply to YOUR wallet. */
+  readonly expectedPublicKey?: Uint8Array;
+}
+/** BLAKE2b-256 of the intent message (or the given hash) + Ed25519 verification. */
+declare function verifySuiSignature(args: VerifySuiSignatureArgs): VerifyResult;
+//#endregion
 //#region src/verify/ton.d.ts
 interface VerifyTonSignatureArgs {
   /** The exact bytes the request carried in `signData`. */
@@ -213,5 +246,25 @@ interface VerifyTronSignatureArgs {
  */
 declare function verifyTronSignature(args: VerifyTronSignatureArgs): VerifyResult;
 //#endregion
-export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyCardanoSignatureArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifyTonSignatureArgs, type VerifyTronSignatureArgs, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifyTonSignature, verifyTronSignature };
+//#region src/verify/xrp.d.ts
+interface VerifyXrpSignatureArgs {
+  /** The signed binary transaction from the reply. */
+  readonly signedTx: Uint8Array;
+  /** The `SigningPubKey` hex your request JSON carried (33-byte compressed secp256k1). */
+  readonly expectedSigningPubKey: string;
+}
+/**
+ * XRP has no request id — this check IS the binding. The signed binary is
+ * split into its canonical fields; `TxnSignature` is removed; the remainder
+ * (prefixed with the XRPL signing tag `STX\0`) is hashed with SHA-512-half
+ * and the DER signature is verified against `SigningPubKey`, which must also
+ * equal the key your request carried.
+ *
+ * The field walker covers the types Payment-class transactions use; a
+ * transaction carrying an exotic field type comes back `checked: false`
+ * rather than a false verdict.
+ */
+declare function verifyXrpSignature(args: VerifyXrpSignatureArgs): VerifyResult;
+//#endregion
+export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyCardanoSignatureArgs, type VerifyCosmosSignatureArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifySuiSignatureArgs, type VerifyTonSignatureArgs, type VerifyTronSignatureArgs, type VerifyXrpSignatureArgs, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyCosmosSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifySuiSignature, verifyTonSignature, verifyTronSignature, verifyXrpSignature };
 //# sourceMappingURL=verify.d.cts.map

package/dist/verify.d.ts

@@ -94,6 +94,24 @@ interface VerifyCardanoSignatureArgs {
  */
 declare function verifyCardanoSignature(args: VerifyCardanoSignatureArgs): VerifyResult;
 //#endregion
+//#region src/verify/cosmos.d.ts
+interface VerifyCosmosSignatureArgs {
+  /** The exact SignDoc bytes the request carried. */
+  readonly signData: Uint8Array;
+  /**
+   * Digest family: vanilla Cosmos zones hash with sha256; Ethermint chains
+   * (Injective, Evmos, Dymension) with keccak256.
+   */
+  readonly digest: 'sha256' | 'keccak256';
+  /** 64-byte compact signature from the reply. */
+  readonly signature: Uint8Array;
+  /** 33-byte compressed public key (from the reply, or derived from your linked xpub). */
+  readonly publicKey: Uint8Array;
+  /** Optional binding: the key you EXPECT (derived from the linked account). */
+  readonly expectedPublicKey?: Uint8Array;
+}
+declare function verifyCosmosSignature(args: VerifyCosmosSignatureArgs): VerifyResult;
+//#endregion
 //#region src/verify/evm.d.ts
 interface VerifyEvmSignatureArgs {
   /** The exact bytes the request carried in `signData`. */
@@ -168,6 +186,21 @@ interface VerifySolanaSignatureArgs {
 }
 declare function verifySolanaSignature(args: VerifySolanaSignatureArgs): VerifyResult;
 //#endregion
+//#region src/verify/sui.d.ts
+interface VerifySuiSignatureArgs {
+  /** The intent message the request carried (or pass `messageHash` for the hash variant). */
+  readonly intentMessage?: Uint8Array;
+  readonly messageHash?: Uint8Array;
+  /** 64-byte Ed25519 signature from the reply. */
+  readonly signature: Uint8Array;
+  /** The signer key the reply carried. */
+  readonly publicKey: Uint8Array;
+  /** The linked account's key (`accounts.sui()[i].publicKey`) — binds the reply to YOUR wallet. */
+  readonly expectedPublicKey?: Uint8Array;
+}
+/** BLAKE2b-256 of the intent message (or the given hash) + Ed25519 verification. */
+declare function verifySuiSignature(args: VerifySuiSignatureArgs): VerifyResult;
+//#endregion
 //#region src/verify/ton.d.ts
 interface VerifyTonSignatureArgs {
   /** The exact bytes the request carried in `signData`. */
@@ -213,5 +246,25 @@ interface VerifyTronSignatureArgs {
  */
 declare function verifyTronSignature(args: VerifyTronSignatureArgs): VerifyResult;
 //#endregion
-export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyCardanoSignatureArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifyTonSignatureArgs, type VerifyTronSignatureArgs, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifyTonSignature, verifyTronSignature };
+//#region src/verify/xrp.d.ts
+interface VerifyXrpSignatureArgs {
+  /** The signed binary transaction from the reply. */
+  readonly signedTx: Uint8Array;
+  /** The `SigningPubKey` hex your request JSON carried (33-byte compressed secp256k1). */
+  readonly expectedSigningPubKey: string;
+}
+/**
+ * XRP has no request id — this check IS the binding. The signed binary is
+ * split into its canonical fields; `TxnSignature` is removed; the remainder
+ * (prefixed with the XRPL signing tag `STX\0`) is hashed with SHA-512-half
+ * and the DER signature is verified against `SigningPubKey`, which must also
+ * equal the key your request carried.
+ *
+ * The field walker covers the types Payment-class transactions use; a
+ * transaction carrying an exotic field type comes back `checked: false`
+ * rather than a false verdict.
+ */
+declare function verifyXrpSignature(args: VerifyXrpSignatureArgs): VerifyResult;
+//#endregion
+export { type ParsedPsbt, PsbtInputType, type PsbtKeyValue, type VerifyBtcMessageHeaderArgs, type VerifyCardanoSignatureArgs, type VerifyCosmosSignatureArgs, type VerifyEvmSignatureArgs, type VerifyResult, type VerifySignedPsbtArgs, type VerifySolanaSignatureArgs, type VerifySuiSignatureArgs, type VerifyTonSignatureArgs, type VerifyTronSignatureArgs, type VerifyXrpSignatureArgs, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyCosmosSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifySuiSignature, verifyTonSignature, verifyTronSignature, verifyXrpSignature };
 //# sourceMappingURL=verify.d.ts.map

package/dist/verify.js

@@ -1,15 +1,17 @@
-import { A as utf8Encode, D as hexToBytes, E as equalBytes, P as parsePath, T as concatBytes, Z as EraSdkError, k as utf8Decode, w as bytesToHex } from "./shared-B8Wc7ViU.js";
-import { a as cardanoSoftDerivePath } from "./derive-C4JdycUh.js";
-import { n as parseWitnessSet } from "./cardano-yuOygqwp.js";
-import { n as EvmDataType, r as foldRecoveryId } from "./evm-kJb3-oiR.js";
-import { n as TonDataType } from "./ton-5Uvi5ifg.js";
-import { a as firstVarint, i as firstBytes, o as readFields, r as splitSignedTronTx } from "./messages-17Oup0-Z.js";
+import { A as utf8Encode, D as hexToBytes, E as equalBytes, K as EraSdkError, T as concatBytes, k as utf8Decode, w as bytesToHex } from "./shared-Bbgejrus.js";
+import { i as parsePath } from "./keypath-Bvv_cfHt.js";
+import { a as cardanoSoftDerivePath } from "./derive-CK9Nc9Jc.js";
+import { n as parseWitnessSet } from "./cardano-BCT55gwf.js";
+import { n as EvmDataType, r as foldRecoveryId } from "./evm-CI1cuZsp.js";
+import { n as suiIntentDigest } from "./sui-BtbPG6Xt.js";
+import { n as TonDataType } from "./ton-BSPKU5B9.js";
+import { a as firstVarint, i as firstBytes, o as readFields, r as splitSignedTronTx } from "./messages-DbnXy3dC.js";
 import { secp256k1 } from "@noble/curves/secp256k1";
-import { sha256 } from "@noble/hashes/sha2";
+import { blake2b } from "@noble/hashes/blake2b";
+import { sha256, sha512 } from "@noble/hashes/sha2";
 import { keccak_256 } from "@noble/hashes/sha3";
 import { createBase58check } from "@scure/base";
 import { ed25519 } from "@noble/curves/ed25519";
-import { blake2b } from "@noble/hashes/blake2b";
 //#region src/verify/psbt-reader.ts
 const MAGIC = [
 	112,
@@ -393,6 +395,21 @@ function skipItem(bytes, offset, depth) {
 	}
 }
 //#endregion
+//#region src/verify/cosmos.ts
+function verifyCosmosSignature(args) {
+	if (args.signature.length !== 64) return failed("signature must be 64 bytes (compact r||s)");
+	if (args.publicKey.length !== 33) return failed("publicKey must be 33 bytes (compressed)");
+	if (args.expectedPublicKey !== void 0 && !equalBytes(args.publicKey, args.expectedPublicKey)) return failed("the reply public key is not the linked account key");
+	const digest = args.digest === "keccak256" ? keccak_256(args.signData) : sha256(args.signData);
+	let ok;
+	try {
+		ok = secp256k1.verify(args.signature, digest, args.publicKey);
+	} catch (e) {
+		return failed(`Cosmos signature could not be checked: ${e.message}`);
+	}
+	return ok ? verified : failed("the signature does not belong to this account");
+}
+//#endregion
 //#region src/verify/evm.ts
 /** EIP-191: 0x19 || "Ethereum Signed Message:\n" || len(message). */
 function personalSignDigest(message) {
@@ -448,6 +465,25 @@ function verifySolanaSignature(args) {
 	return ok ? verified : failed("the signature does not belong to this account");
 }
 //#endregion
+//#region src/verify/sui.ts
+/** BLAKE2b-256 of the intent message (or the given hash) + Ed25519 verification. */
+function verifySuiSignature(args) {
+	let digest;
+	if (args.messageHash !== void 0) {
+		if (args.messageHash.length !== 32) return failed("messageHash must be 32 bytes");
+		digest = args.messageHash;
+	} else if (args.intentMessage !== void 0) digest = suiIntentDigest(args.intentMessage);
+	else return failed("provide intentMessage or messageHash");
+	if (args.expectedPublicKey !== void 0 && !equalBytes(args.publicKey, args.expectedPublicKey)) return failed("the reply public key is not the linked account key");
+	let ok;
+	try {
+		ok = ed25519.verify(args.signature, digest, args.publicKey);
+	} catch (e) {
+		return failed(`Sui signature could not be checked: ${e.message}`);
+	}
+	return ok ? verified : failed("the signature does not belong to this account");
+}
+//#endregion
 //#region src/verify/ton-boc.ts
 /**
 * Minimal TON Bag-of-Cells reader + cell representation hash — exactly the
@@ -719,6 +755,150 @@ function compareWindow(repliedBytes, latestBlock) {
 	return verified;
 }
 //#endregion
-export { PsbtInputType, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifyTonSignature, verifyTronSignature };
+//#region src/verify/xrp.ts
+/**
+* XRP has no request id — this check IS the binding. The signed binary is
+* split into its canonical fields; `TxnSignature` is removed; the remainder
+* (prefixed with the XRPL signing tag `STX\0`) is hashed with SHA-512-half
+* and the DER signature is verified against `SigningPubKey`, which must also
+* equal the key your request carried.
+*
+* The field walker covers the types Payment-class transactions use; a
+* transaction carrying an exotic field type comes back `checked: false`
+* rather than a false verdict.
+*/
+function verifyXrpSignature(args) {
+	let fields;
+	try {
+		fields = splitFields(args.signedTx);
+	} catch (e) {
+		const message = e.message;
+		if (message === "unsupported-field") return unverifiable("the transaction carries a field type this checker does not walk");
+		return failed(`the signed transaction is not readable: ${message}`);
+	}
+	const signingPubKey = fields.find((f) => f.header === 115);
+	const txnSignature = fields.find((f) => f.header === 116);
+	if (!signingPubKey || !txnSignature) return failed("the signed transaction is missing SigningPubKey or TxnSignature");
+	const expected = hexToBytes(args.expectedSigningPubKey);
+	if (!equalBytes(signingPubKey.value, expected)) return failed(`the transaction was signed with a different key (${bytesToHex(signingPubKey.value)})`);
+	const payload = concatBytes(new Uint8Array([
+		83,
+		84,
+		88,
+		0
+	]), ...fields.filter((f) => f.header !== 116).map((f) => f.raw));
+	const digest = sha512(payload).slice(0, 32);
+	let ok;
+	try {
+		ok = secp256k1.verify(secp256k1.Signature.fromDER(txnSignature.value).toCompactRawBytes(), digest, expected);
+	} catch (e) {
+		return failed(`XRP signature could not be checked: ${e.message}`);
+	}
+	return ok ? verified : failed("the signature does not verify against SigningPubKey");
+}
+/** Split a canonical STObject into its top-level fields. */
+function splitFields(bytes) {
+	const fields = [];
+	let pos = 0;
+	while (pos < bytes.length) {
+		const field = parseField(bytes, pos);
+		fields.push(field.field);
+		pos = field.end;
+	}
+	return fields;
+}
+/** Parse ONE field at `pos`; returns the field and the offset past it. */
+function parseField(bytes, pos) {
+	const start = pos;
+	const first = bytes[pos++];
+	if (first === void 0) throw new Error("truncated");
+	let type = first >> 4;
+	let fieldCode = first & 15;
+	if (type === 0) {
+		const t = bytes[pos++];
+		if (t === void 0) throw new Error("truncated type");
+		type = t;
+	}
+	if (fieldCode === 0) {
+		const f = bytes[pos++];
+		if (f === void 0) throw new Error("truncated field code");
+		fieldCode = f;
+	}
+	let valueStart = pos;
+	switch (type) {
+		case 1:
+			pos += 2;
+			break;
+		case 2:
+			pos += 4;
+			break;
+		case 5:
+			pos += 32;
+			break;
+		case 6: {
+			const head = bytes[pos];
+			if (head === void 0) throw new Error("truncated amount");
+			pos += (head & 128) !== 0 ? 48 : 8;
+			break;
+		}
+		case 7:
+		case 8: {
+			const vl = readVl(bytes, pos);
+			valueStart = vl.next;
+			pos = vl.next + vl.length;
+			break;
+		}
+		case 14:
+			while (bytes[pos] !== 225) {
+				if (pos >= bytes.length) throw new Error("unterminated inner object");
+				pos = parseField(bytes, pos).end;
+			}
+			pos += 1;
+			break;
+		case 15:
+			while (bytes[pos] !== 241) {
+				if (pos >= bytes.length) throw new Error("unterminated array");
+				pos = parseField(bytes, pos).end;
+			}
+			pos += 1;
+			break;
+		default: throw new Error("unsupported-field");
+	}
+	if (pos > bytes.length) throw new Error("truncated field");
+	return {
+		field: {
+			header: type << 4 | (fieldCode <= 15 ? fieldCode : 0),
+			value: bytes.slice(valueStart, pos),
+			raw: bytes.slice(start, pos)
+		},
+		end: pos
+	};
+}
+/** XRPL variable-length prefix. */
+function readVl(bytes, pos) {
+	const b1 = bytes[pos];
+	if (b1 === void 0) throw new Error("truncated length");
+	if (b1 <= 192) return {
+		length: b1,
+		next: pos + 1
+	};
+	if (b1 <= 240) {
+		const b2 = bytes[pos + 1];
+		if (b2 === void 0) throw new Error("truncated length");
+		return {
+			length: 193 + (b1 - 193) * 256 + b2,
+			next: pos + 2
+		};
+	}
+	const b2 = bytes[pos + 1];
+	const b3 = bytes[pos + 2];
+	if (b2 === void 0 || b3 === void 0) throw new Error("truncated length");
+	return {
+		length: 12481 + (b1 - 241) * 65536 + b2 * 256 + b3,
+		next: pos + 3
+	};
+}
+//#endregion
+export { PsbtInputType, bocRootHash, parsePsbt, verifyBtcMessageHeader, verifyCardanoSignature, verifyCosmosSignature, verifyEvmSignature, verifySignedPsbt, verifySolanaSignature, verifySuiSignature, verifyTonSignature, verifyTronSignature, verifyXrpSignature };
 
 //# sourceMappingURL=verify.js.map