@phantom/indexed-db-stamper 0.1.1

package/README.md

@@ -0,0 +1,165 @@
+# @phantom/indexed-db-stamper
+
+A secure IndexedDB-based key stamper for the Phantom Wallet SDK that stores cryptographic keys directly in the browser's IndexedDB without ever exposing private key material.
+
+## Features
+
+- **Maximum Security**: Uses non-extractable Ed25519 keys that never exist in JavaScript memory
+- **Web Crypto API**: Leverages browser's native cryptographic secure context
+- **Secure Storage**: Keys stored as non-extractable CryptoKey objects in IndexedDB
+- **Raw Signatures**: Uses Ed25519 raw signature format for maximum efficiency
+- **Hardware Integration**: Utilizes browser's hardware-backed cryptographic isolation when available
+- **Compatible Interface**: Drop-in replacement for other stamper implementations
+
+## Installation
+
+```bash
+npm install @phantom/indexed-db-stamper
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { IndexedDbStamper } from '@phantom/indexed-db-stamper';
+
+// Create stamper instance
+const stamper = new IndexedDbStamper({
+  dbName: 'my-app-keys',      // optional, defaults to 'phantom-indexed-db-stamper'
+  storeName: 'crypto-keys',   // optional, defaults to 'crypto-keys'
+  keyName: 'signing-key'      // optional, defaults to 'signing-key'
+});
+
+// Initialize and generate/load keys
+const keyInfo = await stamper.init();
+console.log('Key ID:', keyInfo.keyId);
+console.log('Public Key:', keyInfo.publicKey);
+
+// Create X-Phantom-Stamp header value for API requests
+const requestData = Buffer.from(JSON.stringify({ action: 'transfer', amount: 100 }), 'utf8');
+const stamp = await stamper.stamp({ data: requestData });
+console.log('X-Phantom-Stamp:', stamp);
+```
+
+### Advanced Usage
+
+```typescript
+// Check if already initialized
+if (stamper.getKeyInfo()) {
+  console.log('Stamper already has keys');
+} else {
+  await stamper.init();
+}
+
+// Reset keys (generate new keypair)
+const newKeyInfo = await stamper.resetKeyPair();
+
+// Stamp different data types with PKI (default)
+const stringData = Buffer.from('string data', 'utf8');
+const binaryData = Buffer.from([1, 2, 3]);
+const jsonData = Buffer.from(JSON.stringify({ key: 'value' }), 'utf8');
+
+await stamper.stamp({ data: stringData });
+await stamper.stamp({ data: binaryData, type: 'PKI' }); // explicit PKI type
+await stamper.stamp({ data: jsonData });
+
+// OIDC type stamping (requires idToken and salt)
+const oidcStamp = await stamper.stamp({ 
+  data: requestData, 
+  type: 'OIDC', 
+  idToken: 'your-id-token',
+  salt: 'your-salt-value'
+});
+
+// Clear all stored keys
+await stamper.clear();
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new IndexedDbStamper(config?: IndexedDbStamperConfig)
+```
+
+**Config Options:**
+- `dbName?: string` - IndexedDB database name (default: 'phantom-indexed-db-stamper')
+- `storeName?: string` - Object store name (default: 'crypto-keys')  
+- `keyName?: string` - Key identifier prefix (default: 'signing-key')
+
+### Methods
+
+#### `init(): Promise<StamperKeyInfo>`
+Initialize the stamper and generate/load cryptographic keys.
+
+**Returns:** `StamperKeyInfo` with `keyId` and `publicKey`
+
+#### `getKeyInfo(): StamperKeyInfo | null`
+Get current key information without async operation.
+
+#### `resetKeyPair(): Promise<StamperKeyInfo>`  
+Generate and store a new key pair, replacing any existing keys.
+
+#### `stamp(params: { data: Buffer; type?: 'PKI'; idToken?: never; salt?: never; } | { data: Buffer; type: 'OIDC'; idToken: string; salt: string; }): Promise<string>`
+Create X-Phantom-Stamp header value using the stored private key.
+
+**Parameters:**
+- `params.data: Buffer` - Data to sign (typically JSON stringified request body)
+- `params.type?: 'PKI' | 'OIDC'` - Stamp type (defaults to 'PKI')
+- `params.idToken?: string` - Required for OIDC type
+- `params.salt?: string` - Required for OIDC type
+
+**Returns:** Complete X-Phantom-Stamp header value (base64url-encoded JSON with base64url-encoded publicKey, signature, and kind fields)
+
+**Note:** The public key is stored internally in base58 format but converted to base64url when creating stamps for API compatibility.
+
+#### `clear(): Promise<void>`
+Remove all stored keys from IndexedDB.
+
+## Security Features
+
+### Non-Extractable Keys
+The stamper generates Ed25519 CryptoKey objects with `extractable: false`, meaning private keys cannot be exported, extracted, or accessed outside of Web Crypto API signing operations. This provides the strongest possible security in browser environments.
+
+### Cryptographic Isolation  
+Keys are generated and stored entirely within the browser's secure cryptographic context:
+- Private keys never exist in JavaScript memory at any point
+- Signing operations happen within Web Crypto API secure boundaries
+- Secure elements used when available by the browser
+- Origin-based security isolation through IndexedDB
+
+### Signature Format
+The stamper uses Ed25519 signatures in their native 64-byte format, providing efficient and secure signing operations.
+
+## Error Handling
+
+The stamper includes comprehensive error handling for:
+
+```typescript
+// Environment validation
+if (typeof window === 'undefined') {
+  throw new Error('IndexedDbStamper requires a browser environment');
+}
+
+// Initialization checks
+if (!stamper.getKeyInfo()) {
+  throw new Error('Stamper not initialized. Call init() first.');
+}
+
+// Storage errors
+try {
+  await stamper.init();
+} catch (error) {
+  console.error('Failed to initialize stamper:', error);
+}
+```
+
+## Browser Compatibility
+
+Requires IndexedDB and Web Crypto API support.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { Buffer } from 'buffer';
+import { StamperWithKeyManagement, Algorithm, StamperKeyInfo } from '@phantom/sdk-types';
+
+type IndexedDbStamperConfig = {
+    dbName?: string;
+    storeName?: string;
+    keyName?: string;
+};
+/**
+ * IndexedDB-based key manager that stores cryptographic keys securely in IndexedDB
+ * and performs signing operations without ever exposing private key material.
+ *
+ * Security model:
+ * - Generates non-extractable Ed25519 keypairs using Web Crypto API
+ * - Stores keys entirely within Web Crypto API secure context
+ * - Private keys NEVER exist in JavaScript memory
+ * - Provides signing methods without exposing private keys
+ * - Maximum security using browser's native cryptographic isolation
+ */
+declare class IndexedDbStamper implements StamperWithKeyManagement {
+    private dbName;
+    private storeName;
+    private keyName;
+    private db;
+    private keyInfo;
+    private cryptoKeyPair;
+    algorithm: Algorithm;
+    constructor(config?: IndexedDbStamperConfig);
+    /**
+     * Initialize the stamper by opening IndexedDB and retrieving or generating keys
+     */
+    init(): Promise<StamperKeyInfo>;
+    /**
+     * Get the public key information
+     */
+    getKeyInfo(): StamperKeyInfo | null;
+    /**
+     * Reset the key pair by generating a new one
+     */
+    resetKeyPair(): Promise<StamperKeyInfo>;
+    /**
+     * Create X-Phantom-Stamp header value using stored private key
+     * @param params - Parameters object with data and optional type/options
+     * @returns Complete X-Phantom-Stamp header value
+     */
+    stamp(params: {
+        data: Buffer;
+        type?: 'PKI';
+        idToken?: never;
+        salt?: never;
+    } | {
+        data: Buffer;
+        type: 'OIDC';
+        idToken: string;
+        salt: string;
+    }): Promise<string>;
+    /**
+     * Clear all stored keys
+     */
+    clear(): Promise<void>;
+    private clearStoredKeys;
+    private openDB;
+    private generateAndStoreKeyPair;
+    private storeKeyPair;
+    private loadKeyPair;
+    private getStoredKeyInfo;
+}
+
+export { IndexedDbStamper, IndexedDbStamperConfig };

package/dist/index.js

@@ -0,0 +1,236 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  IndexedDbStamper: () => IndexedDbStamper
+});
+module.exports = __toCommonJS(src_exports);
+var import_base64url = require("@phantom/base64url");
+var import_bs58 = __toESM(require("bs58"));
+var import_sdk_types = require("@phantom/sdk-types");
+var IndexedDbStamper = class {
+  // Use Ed25519 for maximum security and performance
+  constructor(config = {}) {
+    this.db = null;
+    this.keyInfo = null;
+    this.cryptoKeyPair = null;
+    this.algorithm = import_sdk_types.Algorithm.ed25519;
+    if (typeof window === "undefined" || !window.indexedDB) {
+      throw new Error("IndexedDbStamper requires a browser environment with IndexedDB support");
+    }
+    this.dbName = config.dbName || "phantom-indexed-db-stamper";
+    this.storeName = config.storeName || "crypto-keys";
+    this.keyName = config.keyName || "signing-key";
+  }
+  /**
+   * Initialize the stamper by opening IndexedDB and retrieving or generating keys
+   */
+  async init() {
+    await this.openDB();
+    let keyInfo = await this.getStoredKeyInfo();
+    if (!keyInfo) {
+      keyInfo = await this.generateAndStoreKeyPair();
+    } else {
+      await this.loadKeyPair();
+    }
+    this.keyInfo = keyInfo;
+    return keyInfo;
+  }
+  /**
+   * Get the public key information
+   */
+  getKeyInfo() {
+    return this.keyInfo;
+  }
+  /**
+   * Reset the key pair by generating a new one
+   */
+  async resetKeyPair() {
+    await this.clearStoredKeys();
+    const keyInfo = await this.generateAndStoreKeyPair();
+    this.keyInfo = keyInfo;
+    return keyInfo;
+  }
+  /**
+   * Create X-Phantom-Stamp header value using stored private key
+   * @param params - Parameters object with data and optional type/options
+   * @returns Complete X-Phantom-Stamp header value
+   */
+  async stamp(params) {
+    const { data, type = "PKI" } = params;
+    if (!this.keyInfo || !this.cryptoKeyPair) {
+      throw new Error("Stamper not initialized. Call init() first.");
+    }
+    const dataBytes = new Uint8Array(data);
+    const signature = await crypto.subtle.sign(
+      {
+        name: this.algorithm,
+        hash: "SHA-256"
+      },
+      this.cryptoKeyPair.privateKey,
+      dataBytes
+    );
+    const signatureBase64url = (0, import_base64url.base64urlEncode)(new Uint8Array(signature));
+    const stampData = type === "PKI" ? {
+      // Decode base58 public key to bytes, then encode as base64url (consistent with ApiKeyStamper)
+      publicKey: (0, import_base64url.base64urlEncode)(import_bs58.default.decode(this.keyInfo.publicKey)),
+      signature: signatureBase64url,
+      kind: "PKI",
+      algorithm: this.algorithm
+    } : {
+      kind: "OIDC",
+      idToken: params.idToken,
+      publicKey: (0, import_base64url.base64urlEncode)(import_bs58.default.decode(this.keyInfo.publicKey)),
+      salt: params.salt,
+      algorithm: this.algorithm,
+      signature: signatureBase64url
+    };
+    const stampJson = JSON.stringify(stampData);
+    return (0, import_base64url.base64urlEncode)(stampJson);
+  }
+  /**
+   * Clear all stored keys
+   */
+  async clear() {
+    await this.clearStoredKeys();
+    this.keyInfo = null;
+    this.cryptoKeyPair = null;
+  }
+  async clearStoredKeys() {
+    if (!this.db) {
+      await this.openDB();
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const deleteKeyPair = store.delete(`${this.keyName}-keypair`);
+      const deleteKeyInfo = store.delete(`${this.keyName}-info`);
+      let completed = 0;
+      const total = 2;
+      const checkComplete = () => {
+        completed++;
+        if (completed === total) {
+          resolve();
+        }
+      };
+      deleteKeyPair.onsuccess = checkComplete;
+      deleteKeyInfo.onsuccess = checkComplete;
+      deleteKeyPair.onerror = () => reject(deleteKeyPair.error);
+      deleteKeyInfo.onerror = () => reject(deleteKeyInfo.error);
+    });
+  }
+  async openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+  }
+  async generateAndStoreKeyPair() {
+    this.cryptoKeyPair = await crypto.subtle.generateKey(
+      {
+        name: "Ed25519"
+      },
+      false,
+      // non-extractable - private key can never be exported
+      ["sign", "verify"]
+    );
+    const rawPublicKeyBuffer = await crypto.subtle.exportKey("raw", this.cryptoKeyPair.publicKey);
+    const publicKeyBase58 = import_bs58.default.encode(new Uint8Array(rawPublicKeyBuffer));
+    const keyIdBuffer = await crypto.subtle.digest("SHA-256", rawPublicKeyBuffer);
+    const keyId = (0, import_base64url.base64urlEncode)(new Uint8Array(keyIdBuffer)).substring(0, 16);
+    const keyInfo = {
+      keyId,
+      publicKey: publicKeyBase58
+    };
+    await this.storeKeyPair(this.cryptoKeyPair, keyInfo);
+    return keyInfo;
+  }
+  async storeKeyPair(keyPair, keyInfo) {
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const keyPairRequest = store.put(keyPair, `${this.keyName}-keypair`);
+      const keyInfoRequest = store.put(keyInfo, `${this.keyName}-info`);
+      let completed = 0;
+      const total = 2;
+      const checkComplete = () => {
+        completed++;
+        if (completed === total) {
+          resolve();
+        }
+      };
+      keyPairRequest.onsuccess = checkComplete;
+      keyInfoRequest.onsuccess = checkComplete;
+      keyPairRequest.onerror = () => reject(keyPairRequest.error);
+      keyInfoRequest.onerror = () => reject(keyInfoRequest.error);
+    });
+  }
+  async loadKeyPair() {
+    if (!this.db) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(`${this.keyName}-keypair`);
+      request.onsuccess = () => {
+        this.cryptoKeyPair = request.result || null;
+        resolve();
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getStoredKeyInfo() {
+    if (!this.db) {
+      return null;
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(`${this.keyName}-info`);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+};

package/dist/index.mjs

@@ -0,0 +1,205 @@
+// src/index.ts
+import { base64urlEncode } from "@phantom/base64url";
+import bs58 from "bs58";
+import { Algorithm } from "@phantom/sdk-types";
+var IndexedDbStamper = class {
+  // Use Ed25519 for maximum security and performance
+  constructor(config = {}) {
+    this.db = null;
+    this.keyInfo = null;
+    this.cryptoKeyPair = null;
+    this.algorithm = Algorithm.ed25519;
+    if (typeof window === "undefined" || !window.indexedDB) {
+      throw new Error("IndexedDbStamper requires a browser environment with IndexedDB support");
+    }
+    this.dbName = config.dbName || "phantom-indexed-db-stamper";
+    this.storeName = config.storeName || "crypto-keys";
+    this.keyName = config.keyName || "signing-key";
+  }
+  /**
+   * Initialize the stamper by opening IndexedDB and retrieving or generating keys
+   */
+  async init() {
+    await this.openDB();
+    let keyInfo = await this.getStoredKeyInfo();
+    if (!keyInfo) {
+      keyInfo = await this.generateAndStoreKeyPair();
+    } else {
+      await this.loadKeyPair();
+    }
+    this.keyInfo = keyInfo;
+    return keyInfo;
+  }
+  /**
+   * Get the public key information
+   */
+  getKeyInfo() {
+    return this.keyInfo;
+  }
+  /**
+   * Reset the key pair by generating a new one
+   */
+  async resetKeyPair() {
+    await this.clearStoredKeys();
+    const keyInfo = await this.generateAndStoreKeyPair();
+    this.keyInfo = keyInfo;
+    return keyInfo;
+  }
+  /**
+   * Create X-Phantom-Stamp header value using stored private key
+   * @param params - Parameters object with data and optional type/options
+   * @returns Complete X-Phantom-Stamp header value
+   */
+  async stamp(params) {
+    const { data, type = "PKI" } = params;
+    if (!this.keyInfo || !this.cryptoKeyPair) {
+      throw new Error("Stamper not initialized. Call init() first.");
+    }
+    const dataBytes = new Uint8Array(data);
+    const signature = await crypto.subtle.sign(
+      {
+        name: this.algorithm,
+        hash: "SHA-256"
+      },
+      this.cryptoKeyPair.privateKey,
+      dataBytes
+    );
+    const signatureBase64url = base64urlEncode(new Uint8Array(signature));
+    const stampData = type === "PKI" ? {
+      // Decode base58 public key to bytes, then encode as base64url (consistent with ApiKeyStamper)
+      publicKey: base64urlEncode(bs58.decode(this.keyInfo.publicKey)),
+      signature: signatureBase64url,
+      kind: "PKI",
+      algorithm: this.algorithm
+    } : {
+      kind: "OIDC",
+      idToken: params.idToken,
+      publicKey: base64urlEncode(bs58.decode(this.keyInfo.publicKey)),
+      salt: params.salt,
+      algorithm: this.algorithm,
+      signature: signatureBase64url
+    };
+    const stampJson = JSON.stringify(stampData);
+    return base64urlEncode(stampJson);
+  }
+  /**
+   * Clear all stored keys
+   */
+  async clear() {
+    await this.clearStoredKeys();
+    this.keyInfo = null;
+    this.cryptoKeyPair = null;
+  }
+  async clearStoredKeys() {
+    if (!this.db) {
+      await this.openDB();
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const deleteKeyPair = store.delete(`${this.keyName}-keypair`);
+      const deleteKeyInfo = store.delete(`${this.keyName}-info`);
+      let completed = 0;
+      const total = 2;
+      const checkComplete = () => {
+        completed++;
+        if (completed === total) {
+          resolve();
+        }
+      };
+      deleteKeyPair.onsuccess = checkComplete;
+      deleteKeyInfo.onsuccess = checkComplete;
+      deleteKeyPair.onerror = () => reject(deleteKeyPair.error);
+      deleteKeyInfo.onerror = () => reject(deleteKeyInfo.error);
+    });
+  }
+  async openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
+  }
+  async generateAndStoreKeyPair() {
+    this.cryptoKeyPair = await crypto.subtle.generateKey(
+      {
+        name: "Ed25519"
+      },
+      false,
+      // non-extractable - private key can never be exported
+      ["sign", "verify"]
+    );
+    const rawPublicKeyBuffer = await crypto.subtle.exportKey("raw", this.cryptoKeyPair.publicKey);
+    const publicKeyBase58 = bs58.encode(new Uint8Array(rawPublicKeyBuffer));
+    const keyIdBuffer = await crypto.subtle.digest("SHA-256", rawPublicKeyBuffer);
+    const keyId = base64urlEncode(new Uint8Array(keyIdBuffer)).substring(0, 16);
+    const keyInfo = {
+      keyId,
+      publicKey: publicKeyBase58
+    };
+    await this.storeKeyPair(this.cryptoKeyPair, keyInfo);
+    return keyInfo;
+  }
+  async storeKeyPair(keyPair, keyInfo) {
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const keyPairRequest = store.put(keyPair, `${this.keyName}-keypair`);
+      const keyInfoRequest = store.put(keyInfo, `${this.keyName}-info`);
+      let completed = 0;
+      const total = 2;
+      const checkComplete = () => {
+        completed++;
+        if (completed === total) {
+          resolve();
+        }
+      };
+      keyPairRequest.onsuccess = checkComplete;
+      keyInfoRequest.onsuccess = checkComplete;
+      keyPairRequest.onerror = () => reject(keyPairRequest.error);
+      keyInfoRequest.onerror = () => reject(keyInfoRequest.error);
+    });
+  }
+  async loadKeyPair() {
+    if (!this.db) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(`${this.keyName}-keypair`);
+      request.onsuccess = () => {
+        this.cryptoKeyPair = request.result || null;
+        resolve();
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getStoredKeyInfo() {
+    if (!this.db) {
+      return null;
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(`${this.keyName}-info`);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+};
+export {
+  IndexedDbStamper
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@phantom/indexed-db-stamper",
+  "version": "0.1.1",
+  "description": "IndexedDB stamper for Phantom Wallet SDK with non-extractable key storage",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "?pack-release": "When https://github.com/changesets/changesets/issues/432 has a solution we can remove this trick",
+    "pack-release": "rimraf ./_release && yarn pack && mkdir ./_release && tar zxvf ./package.tgz --directory ./_release && rm ./package.tgz",
+    "build": "rimraf ./dist && tsup",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "tsc --noEmit && eslint --cache . --ext .ts,.tsx",
+    "check-types": "tsc --noEmit",
+    "prettier": "prettier --write \"src/**/*.{ts,tsx}\""
+  },
+  "devDependencies": {
+    "@types/bs58": "^5.0.0",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.0",
+    "eslint": "8.53.0",
+    "fake-indexeddb": "^6.0.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "prettier": "^3.5.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.1.2",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "@phantom/base64url": "^0.1.0",
+    "@phantom/crypto": "^0.1.1",
+    "@phantom/embedded-provider-core": "^0.1.2",
+    "@phantom/sdk-types": "^0.1.1",
+    "bs58": "^6.0.0",
+    "buffer": "^6.0.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "directory": "_release/package"
+  }
+}