@owlmeans/basic-keys 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,474 @@
+# @owlmeans/basic-keys
+
+A core cryptographic library for the OwlMeans Common ecosystem, providing key pair generation, digital signing, encryption, and authentication credential management.
+
+## Overview
+
+The `@owlmeans/basic-keys` package implements the core cryptographic subsystem used primarily by the OwlMeans Authentication Subsystem. It provides a unified API for working with different cryptographic algorithms through an extensible plugin system.
+
+## Features
+
+- **Key Pair Management**: Generate, import, and export cryptographic key pairs
+- **Digital Signatures**: Sign and verify data with ED25519 
+- **Encryption**: Encrypt and decrypt data with XChaCha20-Poly1305
+- **Authentication**: Pack and unpack authentication credentials
+- **Plugin System**: Extensible architecture for different cryptographic algorithms
+- **CLI Tool**: Command-line interface for key generation
+- **Multiple Export Formats**: Support for various key export formats
+
+## Supported Algorithms
+
+- **ED25519**: Digital signatures and key derivation
+- **XChaCha20-Poly1305**: Symmetric encryption and decryption
+
+## Installation
+
+```bash
+npm install @owlmeans/basic-keys
+```
+
+## Available Exports
+
+The package provides three main export paths:
+
+```typescript
+// Main exports - core functionality
+import { makeKeyPairModel, KeyType, fromPubKey, matchAddress, inputToKeyPair, packAuthCredentials, unpackAuthCredentials } from '@owlmeans/basic-keys'
+
+// Plugin exports - cryptographic algorithm implementations  
+import { plugins, ed25519Plugin, xChahaPlugin, KeyPlugin } from '@owlmeans/basic-keys/plugins'
+
+// Utility exports - low-level helper functions
+import { prepareData, prepareKey, toAddress, assertType } from '@owlmeans/basic-keys/utils'
+```
+
+## Quick Start
+
+```typescript
+import { makeKeyPairModel, KeyType } from '@owlmeans/basic-keys'
+
+// Generate a new ED25519 key pair
+const keyPair = makeKeyPairModel()
+
+// Sign data
+const signature = await keyPair.sign("Hello, World!")
+
+// Verify signature
+const isValid = await keyPair.verify("Hello, World!", signature)
+
+// Export keys
+const privateKey = keyPair.export()          // "ed25519:base64privatekey"
+const publicKey = keyPair.exportPublic()     // "ed25519:base64publickey"
+const address = keyPair.exportAddress()      // "ed25519:base58address"
+```
+
+## API Reference
+
+### Core Types
+
+#### KeyPair
+
+Represents a cryptographic key pair with metadata.
+
+```typescript
+interface KeyPair {
+  privateKey: string  // Base64-encoded private key
+  publicKey: string   // Base64-encoded public key
+  address: string     // Algorithm-specific address
+  type: string        // Algorithm type (e.g., "ed25519", "xchacha")
+}
+```
+
+#### KeyPairModel
+
+A model object that wraps a KeyPair with cryptographic operations.
+
+```typescript
+interface KeyPairModel {
+  keyPair?: KeyPair
+  sign: (data: unknown) => Promise<string>
+  verify: (data: unknown, signature: string) => Promise<boolean>
+  export: () => string
+  exportPublic: () => string
+  exportAddress: () => string
+  encrypt: (data: unknown) => Promise<string>
+  decrypt: (data: unknown) => Promise<string>
+  dcrpt: (data: unknown) => Promise<Uint8Array>
+}
+```
+
+### Key Functions
+
+#### makeKeyPairModel(input?)
+
+Creates a KeyPairModel instance.
+
+```typescript
+function makeKeyPairModel(input?: KeyPair | string): KeyPairModel
+```
+
+**Parameters:**
+- `input` (optional): 
+  - `KeyPair` object
+  - Algorithm type string (e.g., "ed25519", "xchacha")
+  - Encoded private key string (e.g., "ed25519:base64key")
+
+**Returns:** `KeyPairModel` instance
+
+**Examples:**
+
+```typescript
+// Generate new ED25519 key pair
+const keyPair1 = makeKeyPairModel()
+
+// Generate new XChaCha20 key pair
+const keyPair2 = makeKeyPairModel(KeyType.XCHACHA)
+
+// Import from private key
+const keyPair3 = makeKeyPairModel("ed25519:abcd1234...")
+
+// Import from KeyPair object
+const keyPair4 = makeKeyPairModel({
+  privateKey: "abcd1234...",
+  publicKey: "efgh5678...",
+  address: "ijkl9012...",
+  type: "ed25519"
+})
+```
+
+#### fromPubKey(pubKey, type?)
+
+Creates a KeyPairModel from a public key (verification/encryption only).
+
+```typescript
+function fromPubKey(pubKey: string, type?: string): KeyPairModel
+```
+
+**Parameters:**
+- `pubKey`: Public key string (with or without type prefix)
+- `type` (optional): Algorithm type if not included in pubKey
+
+**Returns:** `KeyPairModel` instance (without private key operations)
+
+**Examples:**
+
+```typescript
+// With type prefix
+const publicKeyModel = fromPubKey("ed25519:abcd1234...")
+
+// Without type prefix (defaults to ED25519)
+const publicKeyModel2 = fromPubKey("abcd1234...")
+
+// Explicit type
+const publicKeyModel3 = fromPubKey("abcd1234...", KeyType.ED25519)
+```
+
+#### matchAddress(address, pubKey)
+
+Verifies if a public key matches an address.
+
+```typescript
+function matchAddress(address: string, pubKey: string): boolean
+```
+
+**Parameters:**
+- `address`: Address string to verify
+- `pubKey`: Public key string
+
+**Returns:** `boolean` - true if the public key matches the address
+
+#### inputToKeyPair(input?)
+
+Converts various input formats to a KeyPair object.
+
+```typescript
+function inputToKeyPair(input?: KeyPair | string): KeyPair
+```
+
+**Parameters:**
+- `input` (optional): 
+  - `KeyPair` object
+  - Algorithm type string (generates new key)
+  - Encoded private key string (e.g., "ed25519:base64key")
+
+**Returns:** `KeyPair` object
+
+**Examples:**
+
+```typescript
+// Generate new ED25519 key pair
+const keyPair1 = inputToKeyPair()
+
+// Generate new XChaCha20 key pair
+const keyPair2 = inputToKeyPair(KeyType.XCHACHA)
+
+// Import from private key
+const keyPair3 = inputToKeyPair("ed25519:abcd1234...")
+```
+
+### Authentication Helpers
+
+#### packAuthCredentials(auth, extra, signer)
+
+Packs authentication credentials with a signature.
+
+```typescript
+function packAuthCredentials<T>(
+  auth: UnsignedAuthCredentials,
+  extra: T,
+  signer: KeyPairModel | PayloadSigner
+): Promise<AuthCredentials>
+```
+
+**Parameters:**
+- `auth`: Unsigned authentication credentials
+- `extra`: Additional data to include in credentials
+- `signer`: KeyPairModel or custom signing function
+
+**Returns:** Promise resolving to signed `AuthCredentials`
+
+#### unpackAuthCredentials(auth, verifier?)
+
+Unpacks and optionally verifies authentication credentials.
+
+```typescript
+function unpackAuthCredentials<T>(
+  auth: AuthCredentials,
+  verifier?: KeyPairModel | PayloadVerifier
+): Promise<UnpackedAuthCredentials<T>>
+```
+
+**Parameters:**
+- `auth`: Signed authentication credentials
+- `verifier` (optional): KeyPairModel or custom verification function
+
+**Returns:** Promise resolving to `UnpackedAuthCredentials<T>`
+
+### Constants
+
+#### KeyType
+
+Enumeration of supported cryptographic algorithm types.
+
+```typescript
+enum KeyType {
+  ED25519 = 'ed25519',
+  XCHACHA = 'xchacha'
+}
+```
+
+### Utility Functions
+
+#### toAddress(publicKey)
+
+Converts a public key to its corresponding address.
+
+```typescript
+function toAddress(publicKey: Uint8Array): Uint8Array
+```
+
+**Parameters:**
+- `publicKey`: Public key as Uint8Array
+
+**Returns:** `Uint8Array` - Address bytes (last 20 bytes of Keccak-256 hash)
+
+#### prepareData(data)
+
+Converts various data types to Uint8Array for cryptographic operations.
+
+```typescript
+function prepareData(data: unknown): Uint8Array
+```
+
+#### prepareKey(key)
+
+Converts a base64-encoded key string to Uint8Array.
+
+```typescript
+function prepareKey(key: string): Uint8Array
+```
+
+#### assertType(type?)
+
+Validates that a cryptographic algorithm type is supported.
+
+```typescript
+function assertType(type?: string): void
+```
+
+## Plugin System
+
+The library uses a plugin architecture to support different cryptographic algorithms. Each plugin implements the `KeyPlugin` interface:
+
+```typescript
+interface KeyPlugin {
+  type: string
+  random: () => Uint8Array
+  fromSeed?: (seed: Uint8Array) => Uint8Array
+  derive?: (pk: Uint8Array, path: string) => Uint8Array
+  sign: (data: Uint8Array, pk: Uint8Array) => Uint8Array
+  verify: (data: Uint8Array, signature: Uint8Array, pub: Uint8Array) => boolean
+  toPublic: (pk: Uint8Array) => Uint8Array
+  toAdress: (pub: Uint8Array) => string
+  encrypt: (data: Uint8Array, pk: Uint8Array) => Uint8Array
+  decrypt: (data: Uint8Array, pk: Uint8Array) => Uint8Array
+}
+```
+
+### Built-in Plugins
+
+#### ED25519 Plugin
+
+- **Type**: `ed25519`
+- **Capabilities**: Digital signatures, key derivation
+- **Address Format**: Base58-encoded Keccak-256 hash
+- **Encryption**: Not supported (throws error)
+
+#### XChaCha20-Poly1305 Plugin
+
+- **Type**: `xchacha`
+- **Capabilities**: Symmetric encryption and decryption
+- **Address Format**: "no-address" (not applicable)
+- **Signing**: Not supported (throws error)
+
+### Using Plugins
+
+```typescript
+import { plugins } from '@owlmeans/basic-keys/plugins'
+// Or import individual plugins
+import { ed25519Plugin, xChahaPlugin } from '@owlmeans/basic-keys/plugins'
+
+// Access plugin directly
+const ed25519Plugin = plugins['ed25519']
+
+// Generate random private key
+const privateKey = ed25519Plugin.random()
+
+// Convert to public key
+const publicKey = ed25519Plugin.toPublic(privateKey)
+
+// Sign data
+const signature = ed25519Plugin.sign(data, privateKey)
+
+// Verify signature
+const isValid = ed25519Plugin.verify(data, signature, publicKey)
+```
+
+## CLI Tool
+
+The package includes a command-line tool for key generation:
+
+```bash
+# Generate keys
+npx owlkeys
+
+# Or if installed globally
+owlkeys
+```
+
+The CLI tool generates and displays:
+- ED25519 private key export
+- ED25519 public key export
+- ED25519 address (DID format)
+- XChaCha20 key export
+
+## Advanced Usage
+
+### Custom Signing and Verification
+
+```typescript
+import type { PayloadSigner, PayloadVerifier } from '@owlmeans/basic-keys'
+
+// Custom signer function
+const customSigner: PayloadSigner = async (payload) => {
+  // Custom signing logic
+  return signature
+}
+
+// Custom verifier function
+const customVerifier: PayloadVerifier = async (payload, signature) => {
+  // Custom verification logic
+  return isValid
+}
+
+// Use with authentication helpers
+const credentials = await packAuthCredentials(auth, extra, customSigner)
+const unpacked = await unpackAuthCredentials(credentials, customVerifier)
+```
+
+### Working with Raw Data
+
+```typescript
+import { prepareData, prepareKey, toAddress, assertType } from '@owlmeans/basic-keys/utils'
+
+// Prepare various data types for cryptographic operations
+const data1 = prepareData("string data")           // UTF-8 encoded
+const data2 = prepareData({ key: "value" })        // JSON canonicalized
+const data3 = prepareData(new Uint8Array([1, 2]))  // As-is
+
+// Prepare keys
+const keyBytes = prepareKey("base64KeyString")
+
+// Generate address from public key
+const address = toAddress(publicKeyBytes)
+
+// Assert algorithm type is supported
+assertType("ed25519") // No error
+assertType("unknown") // Throws error
+```
+
+### Encryption and Decryption
+
+```typescript
+// For encryption, use XChaCha20 keys
+const encryptionKey = makeKeyPairModel(KeyType.XCHACHA)
+
+// Encrypt data
+const encrypted = await encryptionKey.encrypt("sensitive data")
+
+// Decrypt data  
+const decrypted = await encryptionKey.decrypt(encrypted)
+
+// Decrypt to raw bytes
+const rawBytes = await encryptionKey.dcrpt(encrypted)
+```
+
+## Error Handling
+
+The library throws descriptive errors for various failure conditions:
+
+- `basic.keys:string-type-or-key` - Invalid key string format
+- `basic.keys:missing-keypair` - KeyPair not available
+- `basic.keys:missing-pk` - Private key not available
+- `basic.keys:sign-data-type` - Invalid data type for signing
+- `basic.keys:unknown-type` - Unsupported algorithm type
+- `ed25519:encryption-support` - ED25519 doesn't support encryption
+- `xchacha:signing` - XChaCha20 doesn't support signing
+- `xchacha:verification` - XChaCha20 doesn't support verification
+
+## Integration with OwlMeans Common
+
+This package is designed to integrate seamlessly with other OwlMeans Common libraries:
+
+- **@owlmeans/auth**: Authentication and authorization
+- **@owlmeans/client-auth**: Client-side authentication
+- **@owlmeans/server-auth**: Server-side authentication
+
+## TypeScript Support
+
+The library is written in TypeScript and provides comprehensive type definitions. All exports are properly typed for optimal developer experience.
+
+## Security Considerations
+
+- Private keys are stored as base64-encoded strings
+- All cryptographic operations use well-established libraries (@noble/curves, @noble/ciphers)
+- Data is canonicalized before signing to prevent signature malleability
+- Key generation uses cryptographically secure random number generation
+
+## Contributing
+
+This package is part of the OwlMeans Common ecosystem. Please refer to the main repository for contribution guidelines.
+
+## License
+
+See the LICENSE file in the repository root for license information.

package/build/auth.d.ts

@@ -0,0 +1,5 @@
+import type { AuthCredentials } from '@owlmeans/auth';
+import type { KeyPairModel, PayloadSigner, PayloadVerifier, UnpackedAuthCredentials, UnsignedAuthCredentials } from './types.js';
+export declare const packAuthCredentials: <T extends {} | undefined>(auth: UnsignedAuthCredentials, extra: T, signer: KeyPairModel | PayloadSigner) => Promise<AuthCredentials>;
+export declare const unpackAuthCredentials: <T extends {} | undefined>(auth: AuthCredentials, verifier?: KeyPairModel | PayloadVerifier) => Promise<UnpackedAuthCredentials<T>>;
+//# sourceMappingURL=auth.d.ts.map

package/build/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAGhI,eAAO,MAAM,mBAAmB,GAAU,CAAC,SAAS,EAAE,GAAG,SAAS,QAC1D,uBAAuB,SACtB,CAAC,UACA,YAAY,GAAG,aAAa,KACnC,OAAO,CAAC,eAAe,CAiBzB,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAU,CAAC,SAAS,EAAE,GAAG,SAAS,QAC5D,eAAe,aACV,YAAY,GAAG,eAAe,KACxC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,CA6BpC,CAAA"}

package/build/auth.js

@@ -0,0 +1,45 @@
+import canonicalize from 'canonicalize';
+export const packAuthCredentials = async (auth, extra, signer) => {
+    const unsigned = {
+        ...auth,
+        ...(extra == null ? {} : { credential: canonicalize(extra) })
+    };
+    if (typeof signer !== 'function') {
+        const _signer = signer;
+        signer = async (payload) => await _signer.sign(payload);
+    }
+    const signature = await signer(unsigned);
+    return {
+        ...auth,
+        credential: extra == null ? signature : canonicalize({ ...extra, signature }),
+    };
+};
+export const unpackAuthCredentials = async (auth, verifier) => {
+    let signature = '';
+    let extras;
+    try {
+        extras = JSON.parse(auth.credential);
+        if (typeof extras === 'object' && extras != null && "signature" in extras) {
+            signature = extras.signature;
+            delete extras.signature;
+        }
+    }
+    catch {
+        signature = auth.credential;
+        extras = undefined;
+    }
+    const unsigned = {
+        ...auth,
+        ...(extras == null ? {} : { credential: canonicalize(extras) })
+    };
+    let isValid = undefined;
+    if (verifier != null) {
+        if (typeof verifier !== 'function') {
+            const _verifier = verifier;
+            verifier = async (payload, signature) => await _verifier.verify(payload, signature);
+        }
+        isValid = await verifier(unsigned, signature);
+    }
+    return { unsigned, signature, isValid, extras };
+};
+//# sourceMappingURL=auth.js.map

package/build/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAEA,OAAO,YAAY,MAAM,cAAc,CAAA;AAEvC,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,EACtC,IAA6B,EAC7B,KAAQ,EACR,MAAoC,EACV,EAAE;IAC5B,MAAM,QAAQ,GAA4B;QACxC,GAAG,IAAI;QACP,GAAG,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,KAAK,CAAW,EAAE,CAAC;KACxE,CAAA;IAED,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,CAAA;QACtB,MAAM,GAAG,KAAK,EAAC,OAAO,EAAC,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvD,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAA;IAExC,OAAO;QACL,GAAG,IAAI;QACP,UAAU,EAAE,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,CAAW;KACxF,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,IAAqB,EACrB,QAAyC,EACJ,EAAE;IACvC,IAAI,SAAS,GAAW,EAAE,CAAA;IAC1B,IAAI,MAAS,CAAA;IACb,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QACpC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,IAAI,IAAI,IAAI,WAAW,IAAI,MAAM,EAAE,CAAC;YAC1E,SAAS,GAAG,MAAM,CAAC,SAAmB,CAAA;YACtC,OAAO,MAAM,CAAC,SAAS,CAAA;QACzB,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,SAAS,GAAG,IAAI,CAAC,UAAU,CAAA;QAC3B,MAAM,GAAG,SAAc,CAAA;IACzB,CAAC;IACD,MAAM,QAAQ,GAA4B;QACxC,GAAG,IAAI;QACP,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,YAAY,CAAC,MAAM,CAAW,EAAE,CAAC;KAC1E,CAAA;IACD,IAAI,OAAO,GAAwB,SAAS,CAAA;IAE5C,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;QACrB,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,SAAS,GAAG,QAAQ,CAAA;YAC1B,QAAQ,GAAG,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;QACrF,CAAC;QAED,OAAO,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAA;IAC/C,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAA;AACjD,CAAC,CAAA"}

package/build/bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/build/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/build/bin.js

@@ -0,0 +1,9 @@
+import { KeyType } from './consts.js';
+import { makeKeyPairModel } from './model.js';
+const keyPair = makeKeyPairModel();
+console.info('Private export: ', keyPair.export());
+console.info('Public export: ', keyPair.exportPublic());
+console.info('DID export: ', keyPair.exportAddress());
+const xChachaKey = makeKeyPairModel(KeyType.XCHACHA);
+console.info('XChaha key export: ', xChachaKey.export());
+//# sourceMappingURL=bin.js.map

package/build/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,OAAO,GAAG,gBAAgB,EAAE,CAAA;AAElC,OAAO,CAAC,IAAI,CAAC,kBAAkB,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;AAClD,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC,CAAA;AACvD,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAA;AAGrD,MAAM,UAAU,GAAG,gBAAgB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;AACpD,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAA"}

package/build/consts.d.ts

@@ -0,0 +1,5 @@
+export declare enum KeyType {
+    ED25519 = "ed25519",
+    XCHACHA = "xchacha"
+}
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,oBAAY,OAAO;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB"}

package/build/consts.js

@@ -0,0 +1,6 @@
+export var KeyType;
+(function (KeyType) {
+    KeyType["ED25519"] = "ed25519";
+    KeyType["XCHACHA"] = "xchacha";
+})(KeyType || (KeyType = {}));
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAN,IAAY,OAGX;AAHD,WAAY,OAAO;IACjB,8BAAmB,CAAA;IACnB,8BAAmB,CAAA;AACrB,CAAC,EAHW,OAAO,KAAP,OAAO,QAGlB"}

package/build/helper.d.ts

@@ -0,0 +1,4 @@
+import type { KeyPairModel } from './types.js';
+export declare const fromPubKey: (pubKey: string, type?: string) => KeyPairModel;
+export declare const matchAddress: (address: string, pubKey: string) => boolean;
+//# sourceMappingURL=helper.d.ts.map

package/build/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAW,YAAY,EAAE,MAAM,YAAY,CAAA;AAGvD,eAAO,MAAM,UAAU,WAAY,MAAM,SAAS,MAAM,KAAG,YAiB1D,CAAA;AAED,eAAO,MAAM,YAAY,YAAa,MAAM,UAAU,MAAM,KAAG,OACf,CAAA"}

package/build/helper.js

@@ -0,0 +1,22 @@
+import { KeyType } from './consts.js';
+import { makeKeyPairModel } from './model.js';
+import { plugins } from './plugins/index.js';
+import { prepareKey } from './utils.js';
+export const fromPubKey = (pubKey, type) => {
+    if (type == null) {
+        [type, pubKey] = pubKey.includes(':') ? pubKey.split(':', 2) : [KeyType.ED25519, pubKey];
+        if (pubKey == null) {
+            pubKey = type;
+            type = KeyType.ED25519;
+        }
+    }
+    const keyPair = {
+        privateKey: '',
+        publicKey: pubKey,
+        type,
+        address: plugins[type].toAdress(prepareKey(pubKey))
+    };
+    return makeKeyPairModel(keyPair);
+};
+export const matchAddress = (address, pubKey) => address === fromPubKey(pubKey).exportAddress();
+//# sourceMappingURL=helper.js.map

package/build/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAE5C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAc,EAAE,IAAa,EAAgB,EAAE;IACxE,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;QACjB,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;QACxF,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;YACnB,MAAM,GAAG,IAAI,CAAA;YACb,IAAI,GAAG,OAAO,CAAC,OAAO,CAAA;QACxB,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAAY;QACvB,UAAU,EAAE,EAAE;QACd,SAAS,EAAE,MAAM;QACjB,IAAI;QACJ,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;KACpD,CAAA;IAED,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAA;AAClC,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,OAAe,EAAE,MAAc,EAAW,EAAE,CACvE,OAAO,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC,aAAa,EAAE,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './types.js';
+export * from './consts.js';
+export * from './helper.js';
+export * from './keypair.js';
+export * from './model.js';
+export * from './auth.js';
+export * from './plugins/index.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA;AAE/B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,oBAAoB,CAAA"}

package/build/index.js

@@ -0,0 +1,7 @@
+export * from './consts.js';
+export * from './helper.js';
+export * from './keypair.js';
+export * from './model.js';
+export * from './auth.js';
+export * from './plugins/index.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AACzB,cAAc,oBAAoB,CAAA"}

package/build/keypair.d.ts

@@ -0,0 +1,3 @@
+import type { KeyPair } from './types.js';
+export declare const inputToKeyPair: (input?: KeyPair | string) => KeyPair;
+//# sourceMappingURL=keypair.d.ts.map

package/build/keypair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keypair.d.ts","sourceRoot":"","sources":["../src/keypair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAMzC,eAAO,MAAM,cAAc,WAAY,OAAO,GAAG,MAAM,KAAG,OAqCzD,CAAA"}