@peerbit/crypto 1.0.3 → 1.0.5

package/lib/esm/encryption.d.ts

@@ -24,7 +24,7 @@ export declare class DecryptedThing<T> extends MaybeEncrypted<T> {
     });
     _value?: T;
     getValue(clazz: AbstractType<T>): T;
-    encrypt(x25519Keypair: X25519Keypair, ...recieverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]): Promise<EncryptedThing<T>>;
+    encrypt(x25519Keypair: X25519Keypair, ...receiverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]): Promise<EncryptedThing<T>>;
     get decrypted(): DecryptedThing<T>;
     decrypt(): DecryptedThing<T>;
     equals(other: MaybeEncrypted<T>): boolean;
@@ -42,10 +42,10 @@ export declare class CipherWithNonce {
 }
 export declare class K {
     _encryptedKey: CipherWithNonce;
-    _recieverPublicKey: X25519PublicKey;
+    _receiverPublicKey: X25519PublicKey;
     constructor(props?: {
         encryptedKey: CipherWithNonce;
-        recieverPublicKey: X25519PublicKey;
+        receiverPublicKey: X25519PublicKey;
     });
     equals(other: K): boolean;
 }

package/lib/esm/encryption.js

@@ -59,25 +59,25 @@ export let DecryptedThing = DecryptedThing_1 = class DecryptedThing extends Mayb
         }
         return deserialize(this._data, clazz);
     }
-    async encrypt(x25519Keypair, ...recieverPublicKeys) {
+    async encrypt(x25519Keypair, ...receiverPublicKeys) {
         const bytes = serialize(this);
         const epheremalKey = sodium.crypto_secretbox_keygen();
         const nonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodim random
         const cipher = sodium.crypto_secretbox_easy(bytes, nonce, epheremalKey);
-        const recieverX25519PublicKeys = await Promise.all(recieverPublicKeys.map((key) => {
+        const receiverX25519PublicKeys = await Promise.all(receiverPublicKeys.map((key) => {
             if (key instanceof Ed25519PublicKey) {
                 return X25519PublicKey.from(key);
             }
             return key;
         }));
-        const ks = recieverX25519PublicKeys.map((recieverPublicKey) => {
+        const ks = receiverX25519PublicKeys.map((receiverPublicKey) => {
             const kNonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodium random
             return new K({
                 encryptedKey: new CipherWithNonce({
-                    cipher: sodium.crypto_box_easy(epheremalKey, kNonce, recieverPublicKey.publicKey, x25519Keypair.secretKey.secretKey),
+                    cipher: sodium.crypto_box_easy(epheremalKey, kNonce, receiverPublicKey.publicKey, x25519Keypair.secretKey.secretKey),
                     nonce: kNonce,
                 }),
-                recieverPublicKey,
+                receiverPublicKey,
             });
         });
         const enc = new EncryptedThing({
@@ -152,17 +152,17 @@ CipherWithNonce = CipherWithNonce_1 = __decorate([
 ], CipherWithNonce);
 export let K = K_1 = class K {
     _encryptedKey;
-    _recieverPublicKey;
+    _receiverPublicKey;
     constructor(props) {
         if (props) {
             this._encryptedKey = props.encryptedKey;
-            this._recieverPublicKey = props.recieverPublicKey;
+            this._receiverPublicKey = props.receiverPublicKey;
         }
     }
     equals(other) {
         if (other instanceof K_1) {
             return (this._encryptedKey.equals(other._encryptedKey) &&
-                this._recieverPublicKey.equals(other._recieverPublicKey));
+                this._receiverPublicKey.equals(other._receiverPublicKey));
         }
         else {
             return false;
@@ -176,7 +176,7 @@ __decorate([
 __decorate([
     field({ type: X25519PublicKey }),
     __metadata("design:type", X25519PublicKey)
-], K.prototype, "_recieverPublicKey", void 0);
+], K.prototype, "_receiverPublicKey", void 0);
 K = K_1 = __decorate([
     variant(0),
     __metadata("design:paramtypes", [Object])
@@ -252,7 +252,7 @@ export let EncryptedThing = EncryptedThing_1 = class EncryptedThing extends Mayb
         let key;
         if (keyResolver instanceof X25519Keypair) {
             for (const [i, k] of this._envelope._ks.entries()) {
-                if (k._recieverPublicKey.equals(keyResolver.publicKey)) {
+                if (k._receiverPublicKey.equals(keyResolver.publicKey)) {
                     key = {
                         index: i,
                         keypair: keyResolver,
@@ -262,7 +262,7 @@ export let EncryptedThing = EncryptedThing_1 = class EncryptedThing extends Mayb
         }
         else {
             for (const [i, k] of this._envelope._ks.entries()) {
-                const exported = await keyResolver.exportByKey(k._recieverPublicKey);
+                const exported = await keyResolver.exportByKey(k._receiverPublicKey);
                 if (exported) {
                     key = {
                         index: i,

package/lib/esm/keychain.js

@@ -112,7 +112,7 @@ export class Libp2pKeychain {
         this.cacheKey(keypair, id);
         // import as ed
         await this.keychain.importPeer(base58btc.encode(id), receiverKeyPeerId);
-        // import as x so we can decrypt messages with this public key (if recieved any)
+        // import as x so we can decrypt messages with this public key (if received any)
         const xKeypair = await X25519Keypair.from(keypair);
         this.cacheKey(xKeypair);
         await this.keychain.importPeer(base58btc.encode(xKeypair.publicKey.bytes), receiverKeyPeerId);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@peerbit/crypto",
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"description": "Crypto fn",
 	"type": "module",
 	"sideEffects": false,
@@ -47,9 +47,9 @@
 		"@ethersproject/wallet": "^5.7.0",
 		"@libp2p/crypto": "^1.0.17",
 		"@libp2p/peer-id": "^2.0.3",
-		"@peerbit/cache": "^1.0.1",
+		"@peerbit/cache": "^1.0.2",
 		"@peerbit/uint8arrays": "3.0.1",
 		"libsodium-wrappers": "^0.7.11"
 	},
-	"gitHead": "99e30817f094e45ffcd60f4babd90a717bd26a22"
+	"gitHead": "464e807d679e24b897b7811ac99d6f85fbd756f9"
 }

package/src/encryption.ts

@@ -71,15 +71,15 @@ export class DecryptedThing<T> extends MaybeEncrypted<T> {
 
 	async encrypt(
 		x25519Keypair: X25519Keypair,
-		...recieverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]
+		...receiverPublicKeys: (X25519PublicKey | Ed25519PublicKey)[]
 	): Promise<EncryptedThing<T>> {
 		const bytes = serialize(this);
 		const epheremalKey = sodium.crypto_secretbox_keygen();
 		const nonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodim random
 		const cipher = sodium.crypto_secretbox_easy(bytes, nonce, epheremalKey);
 
-		const recieverX25519PublicKeys = await Promise.all(
-			recieverPublicKeys.map((key) => {
+		const receiverX25519PublicKeys = await Promise.all(
+			receiverPublicKeys.map((key) => {
 				if (key instanceof Ed25519PublicKey) {
 					return X25519PublicKey.from(key);
 				}
@@ -87,19 +87,19 @@ export class DecryptedThing<T> extends MaybeEncrypted<T> {
 			})
 		);
 
-		const ks = recieverX25519PublicKeys.map((recieverPublicKey) => {
+		const ks = receiverX25519PublicKeys.map((receiverPublicKey) => {
 			const kNonce = randomBytes(NONCE_LENGTH); // crypto random is faster than sodium random
 			return new K({
 				encryptedKey: new CipherWithNonce({
 					cipher: sodium.crypto_box_easy(
 						epheremalKey,
 						kNonce,
-						recieverPublicKey.publicKey,
+						receiverPublicKey.publicKey,
 						x25519Keypair.secretKey.secretKey
 					),
 					nonce: kNonce,
 				}),
-				recieverPublicKey,
+				receiverPublicKey,
 			});
 		});
 
@@ -172,15 +172,15 @@ export class K {
 	_encryptedKey: CipherWithNonce;
 
 	@field({ type: X25519PublicKey })
-	_recieverPublicKey: X25519PublicKey;
+	_receiverPublicKey: X25519PublicKey;
 
 	constructor(props?: {
 		encryptedKey: CipherWithNonce;
-		recieverPublicKey: X25519PublicKey;
+		receiverPublicKey: X25519PublicKey;
 	}) {
 		if (props) {
 			this._encryptedKey = props.encryptedKey;
-			this._recieverPublicKey = props.recieverPublicKey;
+			this._receiverPublicKey = props.receiverPublicKey;
 		}
 	}
 
@@ -188,7 +188,7 @@ export class K {
 		if (other instanceof K) {
 			return (
 				this._encryptedKey.equals(other._encryptedKey) &&
-				this._recieverPublicKey.equals(other._recieverPublicKey)
+				this._receiverPublicKey.equals(other._receiverPublicKey)
 			);
 		} else {
 			return false;
@@ -281,7 +281,7 @@ export class EncryptedThing<T> extends MaybeEncrypted<T> {
 		let key: { index: number; keypair: X25519Keypair } | undefined;
 		if (keyResolver instanceof X25519Keypair) {
 			for (const [i, k] of this._envelope._ks.entries()) {
-				if (k._recieverPublicKey.equals(keyResolver.publicKey)) {
+				if (k._receiverPublicKey.equals(keyResolver.publicKey)) {
 					key = {
 						index: i,
 						keypair: keyResolver,
@@ -290,7 +290,7 @@ export class EncryptedThing<T> extends MaybeEncrypted<T> {
 			}
 		} else {
 			for (const [i, k] of this._envelope._ks.entries()) {
-				const exported = await keyResolver.exportByKey(k._recieverPublicKey);
+				const exported = await keyResolver.exportByKey(k._receiverPublicKey);
 				if (exported) {
 					key = {
 						index: i,

package/src/keychain.ts

@@ -165,7 +165,7 @@ export class Libp2pKeychain implements Keychain {
 		// import as ed
 		await this.keychain.importPeer(base58btc.encode(id), receiverKeyPeerId);
 
-		// import as x so we can decrypt messages with this public key (if recieved any)
+		// import as x so we can decrypt messages with this public key (if received any)
 		const xKeypair = await X25519Keypair.from(keypair);
 		this.cacheKey(xKeypair);
 		await this.keychain.importPeer(