@bcts/components 1.0.0-alpha.16 → 1.0.0-alpha.18

package/README.md

@@ -10,7 +10,7 @@ Also includes a library of CBOR tags and UR types for use with these types.
 
 ## Rust Reference Implementation
 
-This TypeScript implementation is based on [bc-components-rust](https://github.com/BlockchainCommons/bc-components-rust) **v0.30.0** ([commit](https://github.com/BlockchainCommons/bc-components-rust/tree/f3d0081db048da942f316aa4cb5128af8921edd8)).
+This TypeScript implementation is based on [bc-components-rust](https://github.com/BlockchainCommons/bc-components-rust) **v0.31.1** ([commit](https://github.com/BlockchainCommons/bc-components-rust/tree/fe31ddd48c1a1b0dfa161e876f7ea5bbadfb5a8f)).
 
 ### Limitations: SSH Agent Integration
 

package/dist/index.cjs

@@ -2081,6 +2081,12 @@ var ARID = class ARID {
 		const ur = _bcts_uniform_resources.UR.fromURString(urString);
 		return ARID.fromUR(ur);
 	}
+	/**
+	* Alias for fromURString for Rust API compatibility.
+	*/
+	static fromUrString(urString) {
+		return ARID.fromURString(urString);
+	}
 };
 
 //#endregion
@@ -2403,6 +2409,28 @@ var XID = class XID {
 		return new XID(data);
 	}
 	/**
+	* Create a new XID from the given public key (the "genesis key").
+	*
+	* The XID is the SHA-256 digest of the CBOR encoding of the public key.
+	* This matches Rust's `XID::new(genesis_key: impl AsRef<SigningPublicKey>)`.
+	*/
+	static newFromSigningKey(signingPublicKey) {
+		const keyCborData = signingPublicKey.taggedCborData();
+		const digest = require_digest.Digest.fromImage(keyCborData);
+		return XID.fromData(digest.toData());
+	}
+	/**
+	* Validate the XID against the given public key.
+	*
+	* Returns true if the SHA-256 hash of the key's CBOR encoding matches
+	* the XID data. This matches Rust's `XID::validate(&self, key: &SigningPublicKey)`.
+	*/
+	validate(signingPublicKey) {
+		const keyData = signingPublicKey.taggedCborData();
+		const digest = require_digest.Digest.fromImage(keyData);
+		return this.equals(XID.fromData(digest.toData()));
+	}
+	/**
 	* Return the data of the XID.
 	*/
 	data() {
@@ -2473,10 +2501,11 @@ var XID = class XID {
 		return true;
 	}
 	/**
-	* Get string representation.
+	* Get string representation (short format, matching Rust Display).
+	* Uses first 4 bytes of the XID as hex, e.g., "XID(71274df1)".
 	*/
 	toString() {
-		return `XID(${this.toHex()})`;
+		return `XID(${this.shortDescription()})`;
 	}
 	/**
 	* Returns the CBOR tags associated with XID.
@@ -6106,15 +6135,15 @@ var Signature = class Signature {
 		switch (this._type) {
 			case SignatureScheme.Ed25519: return "Ed25519";
 			case SignatureScheme.Schnorr: return "Schnorr";
-			case SignatureScheme.Ecdsa: return "ECDSA";
+			case SignatureScheme.Ecdsa: return "Ecdsa";
 			case SignatureScheme.Sr25519: return "Sr25519";
 			case SignatureScheme.MLDSA44: return "MLDSA-44";
 			case SignatureScheme.MLDSA65: return "MLDSA-65";
 			case SignatureScheme.MLDSA87: return "MLDSA-87";
-			case SignatureScheme.SshEd25519: return "SSH-Ed25519";
-			case SignatureScheme.SshDsa: return "SSH-DSA";
-			case SignatureScheme.SshEcdsaP256: return "SSH-ECDSA-P256";
-			case SignatureScheme.SshEcdsaP384: return "SSH-ECDSA-P384";
+			case SignatureScheme.SshEd25519: return "SshEd25519";
+			case SignatureScheme.SshDsa: return "SshDsa";
+			case SignatureScheme.SshEcdsaP256: return "SshEcdsaP256";
+			case SignatureScheme.SshEcdsaP384: return "SshEcdsaP384";
 			default: return this._type;
 		}
 	}
@@ -11447,11 +11476,10 @@ var PrivateKeys = class PrivateKeys {
 *
 * Ported from bc-components-rust/src/private_key_base.rs
 */
-/** Size of PrivateKeyBase key material in bytes */
-const PRIVATE_KEY_BASE_SIZE = 32;
-/** Key derivation info strings */
-const INFO_SIGNING_ED25519 = "signing-ed25519";
-const INFO_AGREEMENT_X25519 = "agreement-x25519";
+/** Default size of PrivateKeyBase key material in bytes (used for random generation) */
+const PRIVATE_KEY_BASE_DEFAULT_SIZE = 32;
+/** Key derivation salt string - must match Rust's bc-crypto derive functions */
+const SALT_SIGNING = "signing";
 /**
 * PrivateKeyBase - Root cryptographic material for deterministic key derivation.
 *
@@ -11461,7 +11489,7 @@ const INFO_AGREEMENT_X25519 = "agreement-x25519";
 var PrivateKeyBase = class PrivateKeyBase {
 	_data;
 	constructor(data) {
-		if (data.length !== PRIVATE_KEY_BASE_SIZE) throw new Error(`PrivateKeyBase must be ${PRIVATE_KEY_BASE_SIZE} bytes, got ${data.length}`);
+		if (data.length === 0) throw new Error("PrivateKeyBase must have non-zero length");
 		this._data = new Uint8Array(data);
 	}
 	/**
@@ -11475,7 +11503,7 @@ var PrivateKeyBase = class PrivateKeyBase {
 	* Create a new random PrivateKeyBase using the provided RNG.
 	*/
 	static newUsing(rng) {
-		return new PrivateKeyBase(rng.randomData(PRIVATE_KEY_BASE_SIZE));
+		return new PrivateKeyBase(rng.randomData(PRIVATE_KEY_BASE_DEFAULT_SIZE));
 	}
 	/**
 	* Create a PrivateKeyBase from raw bytes.
@@ -11500,21 +11528,20 @@ var PrivateKeyBase = class PrivateKeyBase {
 	/**
 	* Derive an Ed25519 signing private key.
 	*
-	* Uses HKDF with info string "signing-ed25519".
+	* Uses HKDF with salt "signing", matching Rust's derive_signing_private_key().
 	*/
 	ed25519SigningPrivateKey() {
-		const derivedKey = this._deriveKey(INFO_SIGNING_ED25519);
+		const derivedKey = this._deriveKey(SALT_SIGNING);
 		const ed25519Key = Ed25519PrivateKey.from(derivedKey);
 		return SigningPrivateKey.newEd25519(ed25519Key);
 	}
 	/**
 	* Derive an X25519 agreement private key.
 	*
-	* Uses HKDF with info string "agreement-x25519".
+	* Uses HKDF with salt "agreement", matching Rust's derive_agreement_private_key().
 	*/
 	x25519PrivateKey() {
-		const derivedKey = this._deriveKey(INFO_AGREEMENT_X25519);
-		return X25519PrivateKey.fromData(derivedKey);
+		return X25519PrivateKey.deriveFromKeyMaterial(this._data);
 	}
 	/**
 	* Get EncapsulationPrivateKey for decryption.
@@ -11541,12 +11568,59 @@ var PrivateKeyBase = class PrivateKeyBase {
 		return this.ed25519PrivateKeys().publicKeys();
 	}
 	/**
+	* Derive a Schnorr signing private key.
+	*
+	* Uses ECPrivateKey.deriveFromKeyMaterial() matching Rust's
+	* PrivateKeyBase::schnorr_signing_private_key().
+	*/
+	schnorrSigningPrivateKey() {
+		const ecKey = ECPrivateKey.deriveFromKeyMaterial(this._data);
+		return SigningPrivateKey.newSchnorr(ecKey);
+	}
+	/**
+	* Derive a PrivateKeys container with Schnorr signing and X25519 agreement keys.
+	*
+	* Matches Rust's PrivateKeyBase::schnorr_private_keys().
+	*/
+	schnorrPrivateKeys() {
+		return PrivateKeys.withKeys(this.schnorrSigningPrivateKey(), this.encapsulationPrivateKey());
+	}
+	/**
+	* Derive a PublicKeys container from Schnorr derived keys.
+	*/
+	schnorrPublicKeys() {
+		return this.schnorrPrivateKeys().publicKeys();
+	}
+	/**
+	* Derive an ECDSA signing private key.
+	*
+	* Uses ECPrivateKey.deriveFromKeyMaterial() matching Rust's
+	* PrivateKeyBase::ecdsa_signing_private_key().
+	*/
+	ecdsaSigningPrivateKey() {
+		const ecKey = ECPrivateKey.deriveFromKeyMaterial(this._data);
+		return SigningPrivateKey.newEcdsa(ecKey);
+	}
+	/**
+	* Derive a PrivateKeys container with ECDSA signing and X25519 agreement keys.
+	*
+	* Matches Rust's PrivateKeyBase::ecdsa_private_keys().
+	*/
+	ecdsaPrivateKeys() {
+		return PrivateKeys.withKeys(this.ecdsaSigningPrivateKey(), this.encapsulationPrivateKey());
+	}
+	/**
+	* Derive a PublicKeys container from ECDSA derived keys.
+	*/
+	ecdsaPublicKeys() {
+		return this.ecdsaPrivateKeys().publicKeys();
+	}
+	/**
 	* Internal key derivation using HKDF-SHA256.
-	* Uses the info string as salt for domain separation.
+	* Matches Rust's hkdf_hmac_sha256(key_material, salt, key_len) with empty info.
 	*/
-	_deriveKey(info) {
-		const salt = new TextEncoder().encode(info);
-		return (0, _bcts_crypto.hkdfHmacSha256)(this._data, salt, 32);
+	_deriveKey(salt) {
+		return (0, _bcts_crypto.hkdfHmacSha256)(this._data, new TextEncoder().encode(salt), 32);
 	}
 	/**
 	* Compare with another PrivateKeyBase.
@@ -11605,7 +11679,7 @@ var PrivateKeyBase = class PrivateKeyBase {
 	* Static method to decode from tagged CBOR.
 	*/
 	static fromTaggedCbor(cborValue) {
-		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_SIZE)).fromTaggedCbor(cborValue);
+		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_DEFAULT_SIZE)).fromTaggedCbor(cborValue);
 	}
 	/**
 	* Static method to decode from tagged CBOR binary data.
@@ -11619,7 +11693,7 @@ var PrivateKeyBase = class PrivateKeyBase {
 	*/
 	static fromUntaggedCborData(data) {
 		const cborValue = (0, _bcts_dcbor.decodeCbor)(data);
-		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_SIZE)).fromUntaggedCbor(cborValue);
+		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_DEFAULT_SIZE)).fromUntaggedCbor(cborValue);
 	}
 	/**
 	* Returns the UR representation.
@@ -11640,7 +11714,7 @@ var PrivateKeyBase = class PrivateKeyBase {
 	*/
 	static fromUR(ur) {
 		if (ur.urTypeStr() !== _bcts_tags.PRIVATE_KEY_BASE.name) throw new Error(`Expected UR type ${_bcts_tags.PRIVATE_KEY_BASE.name}, got ${ur.urTypeStr()}`);
-		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_SIZE)).fromUntaggedCbor(ur.cbor());
+		return new PrivateKeyBase(new Uint8Array(PRIVATE_KEY_BASE_DEFAULT_SIZE)).fromUntaggedCbor(ur.cbor());
 	}
 	/**
 	* Creates a PrivateKeyBase from a UR string.