@phantom/crypto 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,114 @@
+# @phantom/crypto
+
+Cryptographic utilities for Phantom SDK, providing Ed25519 key generation, key pair management, and digital signing functionality.
+
+## Features
+
+- **Ed25519 Key Pair Generation**: Generate cryptographically secure key pairs
+- **Key Pair Recovery**: Recreate key pairs from existing secret keys
+- **Digital Signing**: Sign data using Ed25519 with detached signatures
+- **Base58 Encoding**: All keys are encoded in base58 format for compatibility
+- **Cross-platform**: Works in both Node.js and browser environments
+
+## Installation
+
+```bash
+npm install @phantom/crypto
+# or
+yarn add @phantom/crypto
+```
+
+## Usage
+
+### Generate a New Key Pair
+
+```typescript
+import { generateKeyPair } from "@phantom/crypto";
+
+const keyPair = generateKeyPair();
+console.log("Public Key:", keyPair.publicKey);
+console.log("Secret Key:", keyPair.secretKey);
+```
+
+### Create Key Pair from Existing Secret Key
+
+```typescript
+import { createKeyPairFromSecret } from "@phantom/crypto";
+
+const existingSecretKey = "your-base58-encoded-secret-key";
+const keyPair = createKeyPairFromSecret(existingSecretKey);
+console.log("Recovered Public Key:", keyPair.publicKey);
+```
+
+### Sign Data
+
+```typescript
+import { signWithSecret } from "@phantom/crypto";
+
+const secretKey = "your-base58-encoded-secret-key";
+const message = "Hello, world!";
+
+const signature = signWithSecret(secretKey, message);
+console.log("Signature:", signature);
+```
+
+## API Reference
+
+### Types
+
+#### `Keypair`
+
+```typescript
+interface Keypair {
+  publicKey: string; // Base58-encoded public key
+  secretKey: string; // Base58-encoded secret key
+}
+```
+
+### Functions
+
+#### `generateKeyPair(): Keypair`
+
+Generates a new Ed25519 key pair with cryptographically secure random keys.
+
+**Returns:** A `Keypair` object with base58-encoded public and secret keys.
+
+#### `createKeyPairFromSecret(b58PrivateKey: string): Keypair`
+
+Reconstructs a key pair from an existing base58-encoded secret key.
+
+**Parameters:**
+
+- `b58PrivateKey`: Base58-encoded private key string
+
+**Returns:** A `Keypair` object with the corresponding public key derived from the secret key.
+
+#### `signWithSecret(secretKey: string | Uint8Array, data: string | Uint8Array | Buffer): Uint8Array`
+
+Signs data using Ed25519 with a secret key, producing a detached signature.
+
+**Parameters:**
+
+- `secretKey`: Base58-encoded secret key string or raw Uint8Array
+- `data`: Data to sign (accepts string, Uint8Array, or Buffer)
+
+**Returns:** Raw signature as Uint8Array
+
+## Security Notes
+
+- Always keep secret keys secure and never expose them in client-side code
+- Use cryptographically secure random number generation (provided by TweetNaCl)
+- Ed25519 provides strong security with 128-bit security level
+- Signatures are deterministic but secure against forgery
+
+## Dependencies
+
+This package uses:
+
+- **TweetNaCl**: Cryptographic library for Ed25519 operations
+- **bs58**: Base58 encoding/decoding
+- **buffer**: Buffer polyfill for cross-platform compatibility
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Buffer } from 'buffer';
+
 interface Keypair {
     publicKey: string;
     secretKey: string;

package/dist/index.js

@@ -37,6 +37,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_tweetnacl = __toESM(require("tweetnacl"));
 var import_bs58 = __toESM(require("bs58"));
+var import_buffer = require("buffer");
 function generateKeyPair() {
   const keypair = import_tweetnacl.default.sign.keyPair();
   return {
@@ -57,7 +58,7 @@ function signWithSecret(secretKey, data) {
   let dataBytes;
   if (typeof data === "string") {
     dataBytes = new TextEncoder().encode(data);
-  } else if (data instanceof Buffer) {
+  } else if (data instanceof import_buffer.Buffer) {
     dataBytes = new Uint8Array(data);
   } else {
     dataBytes = data;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import nacl from \"tweetnacl\";\nimport bs58 from \"bs58\";\n\nexport interface Keypair {\n  publicKey: string;\n  secretKey: string;\n}\n\n/**\n * Generate a new Ed25519 keypair\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function generateKeyPair(): Keypair {\n  const keypair = nacl.sign.keyPair();\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Create a keypair from a base58-encoded private key\n * @param b58PrivateKey - Base58-encoded private key\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function createKeyPairFromSecret(b58PrivateKey: string): Keypair {\n  const secretKeyBytes = bs58.decode(b58PrivateKey);\n  const keypair = nacl.sign.keyPair.fromSecretKey(secretKeyBytes);\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Sign data using Ed25519 with a secret key\n * @param secretKey - Base58-encoded secret key or raw Uint8Array\n * @param data - Data to sign (string, Uint8Array, or Buffer)\n * @returns Base64-encoded signature\n */\nexport function signWithSecret(secretKey: string | Uint8Array, data: string | Uint8Array | Buffer): Uint8Array {\n  // Decode secret key if it's a string\n  const secretKeyBytes = typeof secretKey === \"string\" ? bs58.decode(secretKey) : secretKey;\n\n  // Convert data to Uint8Array if needed\n  let dataBytes: Uint8Array;\n  if (typeof data === \"string\") {\n    dataBytes = new TextEncoder().encode(data);\n  } else if (data instanceof Buffer) {\n    dataBytes = new Uint8Array(data);\n  } else {\n    dataBytes = data;\n  }\n\n  // Sign the data\n  return nacl.sign.detached(dataBytes, secretKeyBytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAiB;AACjB,kBAAiB;AAWV,SAAS,kBAA2B;AACzC,QAAM,UAAU,iBAAAA,QAAK,KAAK,QAAQ;AAClC,SAAO;AAAA,IACL,WAAW,YAAAC,QAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,YAAAA,QAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAOO,SAAS,wBAAwB,eAAgC;AACtE,QAAM,iBAAiB,YAAAA,QAAK,OAAO,aAAa;AAChD,QAAM,UAAU,iBAAAD,QAAK,KAAK,QAAQ,cAAc,cAAc;AAC9D,SAAO;AAAA,IACL,WAAW,YAAAC,QAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,YAAAA,QAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAQO,SAAS,eAAe,WAAgC,MAAgD;AAE7G,QAAM,iBAAiB,OAAO,cAAc,WAAW,YAAAA,QAAK,OAAO,SAAS,IAAI;AAGhF,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,gBAAY,IAAI,YAAY,EAAE,OAAO,IAAI;AAAA,EAC3C,WAAW,gBAAgB,QAAQ;AACjC,gBAAY,IAAI,WAAW,IAAI;AAAA,EACjC,OAAO;AACL,gBAAY;AAAA,EACd;AAGA,SAAO,iBAAAD,QAAK,KAAK,SAAS,WAAW,cAAc;AACrD;","names":["nacl","bs58"]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import nacl from \"tweetnacl\";\nimport bs58 from \"bs58\";\nimport { Buffer } from \"buffer\";\n\nexport interface Keypair {\n  publicKey: string;\n  secretKey: string;\n}\n\n/**\n * Generate a new Ed25519 keypair\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function generateKeyPair(): Keypair {\n  const keypair = nacl.sign.keyPair();\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Create a keypair from a base58-encoded private key\n * @param b58PrivateKey - Base58-encoded private key\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function createKeyPairFromSecret(b58PrivateKey: string): Keypair {\n  const secretKeyBytes = bs58.decode(b58PrivateKey);\n  const keypair = nacl.sign.keyPair.fromSecretKey(secretKeyBytes);\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Sign data using Ed25519 with a secret key\n * @param secretKey - Base58-encoded secret key or raw Uint8Array\n * @param data - Data to sign (string, Uint8Array, or Buffer)\n * @returns Base64-encoded signature\n */\nexport function signWithSecret(secretKey: string | Uint8Array, data: string | Uint8Array | Buffer): Uint8Array {\n  // Decode secret key if it's a string\n  const secretKeyBytes = typeof secretKey === \"string\" ? bs58.decode(secretKey) : secretKey;\n\n  // Convert data to Uint8Array if needed\n  let dataBytes: Uint8Array;\n  if (typeof data === \"string\") {\n    dataBytes = new TextEncoder().encode(data);\n  } else if (data instanceof Buffer) {\n    dataBytes = new Uint8Array(data);\n  } else {\n    dataBytes = data;\n  }\n\n  // Sign the data\n  return nacl.sign.detached(dataBytes, secretKeyBytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAiB;AACjB,kBAAiB;AACjB,oBAAuB;AAWhB,SAAS,kBAA2B;AACzC,QAAM,UAAU,iBAAAA,QAAK,KAAK,QAAQ;AAClC,SAAO;AAAA,IACL,WAAW,YAAAC,QAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,YAAAA,QAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAOO,SAAS,wBAAwB,eAAgC;AACtE,QAAM,iBAAiB,YAAAA,QAAK,OAAO,aAAa;AAChD,QAAM,UAAU,iBAAAD,QAAK,KAAK,QAAQ,cAAc,cAAc;AAC9D,SAAO;AAAA,IACL,WAAW,YAAAC,QAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,YAAAA,QAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAQO,SAAS,eAAe,WAAgC,MAAgD;AAE7G,QAAM,iBAAiB,OAAO,cAAc,WAAW,YAAAA,QAAK,OAAO,SAAS,IAAI;AAGhF,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,gBAAY,IAAI,YAAY,EAAE,OAAO,IAAI;AAAA,EAC3C,WAAW,gBAAgB,sBAAQ;AACjC,gBAAY,IAAI,WAAW,IAAI;AAAA,EACjC,OAAO;AACL,gBAAY;AAAA,EACd;AAGA,SAAO,iBAAAD,QAAK,KAAK,SAAS,WAAW,cAAc;AACrD;","names":["nacl","bs58"]}

package/dist/index.mjs

@@ -1,6 +1,7 @@
 // src/index.ts
 import nacl from "tweetnacl";
 import bs58 from "bs58";
+import { Buffer } from "buffer";
 function generateKeyPair() {
   const keypair = nacl.sign.keyPair();
   return {

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import nacl from \"tweetnacl\";\nimport bs58 from \"bs58\";\n\nexport interface Keypair {\n  publicKey: string;\n  secretKey: string;\n}\n\n/**\n * Generate a new Ed25519 keypair\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function generateKeyPair(): Keypair {\n  const keypair = nacl.sign.keyPair();\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Create a keypair from a base58-encoded private key\n * @param b58PrivateKey - Base58-encoded private key\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function createKeyPairFromSecret(b58PrivateKey: string): Keypair {\n  const secretKeyBytes = bs58.decode(b58PrivateKey);\n  const keypair = nacl.sign.keyPair.fromSecretKey(secretKeyBytes);\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Sign data using Ed25519 with a secret key\n * @param secretKey - Base58-encoded secret key or raw Uint8Array\n * @param data - Data to sign (string, Uint8Array, or Buffer)\n * @returns Base64-encoded signature\n */\nexport function signWithSecret(secretKey: string | Uint8Array, data: string | Uint8Array | Buffer): Uint8Array {\n  // Decode secret key if it's a string\n  const secretKeyBytes = typeof secretKey === \"string\" ? bs58.decode(secretKey) : secretKey;\n\n  // Convert data to Uint8Array if needed\n  let dataBytes: Uint8Array;\n  if (typeof data === \"string\") {\n    dataBytes = new TextEncoder().encode(data);\n  } else if (data instanceof Buffer) {\n    dataBytes = new Uint8Array(data);\n  } else {\n    dataBytes = data;\n  }\n\n  // Sign the data\n  return nacl.sign.detached(dataBytes, secretKeyBytes);\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,OAAO,UAAU;AAWV,SAAS,kBAA2B;AACzC,QAAM,UAAU,KAAK,KAAK,QAAQ;AAClC,SAAO;AAAA,IACL,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAOO,SAAS,wBAAwB,eAAgC;AACtE,QAAM,iBAAiB,KAAK,OAAO,aAAa;AAChD,QAAM,UAAU,KAAK,KAAK,QAAQ,cAAc,cAAc;AAC9D,SAAO;AAAA,IACL,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAQO,SAAS,eAAe,WAAgC,MAAgD;AAE7G,QAAM,iBAAiB,OAAO,cAAc,WAAW,KAAK,OAAO,SAAS,IAAI;AAGhF,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,gBAAY,IAAI,YAAY,EAAE,OAAO,IAAI;AAAA,EAC3C,WAAW,gBAAgB,QAAQ;AACjC,gBAAY,IAAI,WAAW,IAAI;AAAA,EACjC,OAAO;AACL,gBAAY;AAAA,EACd;AAGA,SAAO,KAAK,KAAK,SAAS,WAAW,cAAc;AACrD;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import nacl from \"tweetnacl\";\nimport bs58 from \"bs58\";\nimport { Buffer } from \"buffer\";\n\nexport interface Keypair {\n  publicKey: string;\n  secretKey: string;\n}\n\n/**\n * Generate a new Ed25519 keypair\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function generateKeyPair(): Keypair {\n  const keypair = nacl.sign.keyPair();\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Create a keypair from a base58-encoded private key\n * @param b58PrivateKey - Base58-encoded private key\n * @returns A keypair with base58-encoded public and secret keys\n */\nexport function createKeyPairFromSecret(b58PrivateKey: string): Keypair {\n  const secretKeyBytes = bs58.decode(b58PrivateKey);\n  const keypair = nacl.sign.keyPair.fromSecretKey(secretKeyBytes);\n  return {\n    publicKey: bs58.encode(keypair.publicKey),\n    secretKey: bs58.encode(keypair.secretKey),\n  };\n}\n\n/**\n * Sign data using Ed25519 with a secret key\n * @param secretKey - Base58-encoded secret key or raw Uint8Array\n * @param data - Data to sign (string, Uint8Array, or Buffer)\n * @returns Base64-encoded signature\n */\nexport function signWithSecret(secretKey: string | Uint8Array, data: string | Uint8Array | Buffer): Uint8Array {\n  // Decode secret key if it's a string\n  const secretKeyBytes = typeof secretKey === \"string\" ? bs58.decode(secretKey) : secretKey;\n\n  // Convert data to Uint8Array if needed\n  let dataBytes: Uint8Array;\n  if (typeof data === \"string\") {\n    dataBytes = new TextEncoder().encode(data);\n  } else if (data instanceof Buffer) {\n    dataBytes = new Uint8Array(data);\n  } else {\n    dataBytes = data;\n  }\n\n  // Sign the data\n  return nacl.sign.detached(dataBytes, secretKeyBytes);\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,OAAO,UAAU;AACjB,SAAS,cAAc;AAWhB,SAAS,kBAA2B;AACzC,QAAM,UAAU,KAAK,KAAK,QAAQ;AAClC,SAAO;AAAA,IACL,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAOO,SAAS,wBAAwB,eAAgC;AACtE,QAAM,iBAAiB,KAAK,OAAO,aAAa;AAChD,QAAM,UAAU,KAAK,KAAK,QAAQ,cAAc,cAAc;AAC9D,SAAO;AAAA,IACL,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,IACxC,WAAW,KAAK,OAAO,QAAQ,SAAS;AAAA,EAC1C;AACF;AAQO,SAAS,eAAe,WAAgC,MAAgD;AAE7G,QAAM,iBAAiB,OAAO,cAAc,WAAW,KAAK,OAAO,SAAS,IAAI;AAGhF,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,gBAAY,IAAI,YAAY,EAAE,OAAO,IAAI;AAAA,EAC3C,WAAW,gBAAgB,QAAQ;AACjC,gBAAY,IAAI,WAAW,IAAI;AAAA,EACjC,OAAO;AACL,gBAAY;AAAA,EACd;AAGA,SAAO,KAAK,KAAK,SAAS,WAAW,cAAc;AACrD;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phantom/crypto",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Cryptographic utilities for Phantom SDK",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,10 +24,12 @@
     "test": "jest",
     "test:watch": "jest --watch",
     "lint": "tsc --noEmit && eslint --cache . --ext .ts",
+    "check-types": "tsc --noEmit",
     "prettier": "prettier --write \"src/**/*.{ts}\""
   },
   "dependencies": {
     "bs58": "^5.0.0",
+    "buffer": "^6.0.3",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {