gun-eth 2.0.1 → 3.0.0

package/dist/types/features/proof/ProofChain.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Result of proof verification
+ * @typedef {Object} ProofResult
+ * @property {boolean} isValid - Whether the data is valid
+ * @property {number} timestamp - Verification timestamp
+ * @property {string} updater - Address of last update
+ */
+/**
+ * Latest record
+ * @typedef {Object} LatestRecord
+ * @property {string} contentHash - Content hash
+ * @property {number} timestamp - Last update timestamp
+ * @property {string} updater - Address of last updater
+ */
+/**
+ * Callback for proof operations
+ * @typedef {Object} ProofCallback
+ * @property {boolean} [ok] - Whether operation was successful
+ * @property {string} [message] - Success/error message
+ * @property {string} [err] - Error message
+ * @property {number} [timestamp] - Operation timestamp
+ * @property {string} [updater] - Updater address
+ * @property {LatestRecord} [latestRecord] - Latest record
+ * @property {string} [nodeId] - Created node ID
+ * @property {string} [txHash] - Transaction hash
+ */
+/**
+ * Options for proof transactions
+ * @typedef {Object} ProofOptions
+ * @property {number} [gasLimit] - Gas limit for transaction
+ * @property {number} [gasPrice] - Gas price
+ */
+/**
+ * Extended Gun with additional methods
+ * @typedef {import('gun').IGun & { get: (path: string) => any }} ExtendedGun
+ */
+/**
+ * Extended transaction with additional methods
+ * @typedef {import('ethers').ContractTransaction & { wait: () => Promise<any>, hash: string }} ExtendedTransaction
+ */
+/**
+ * Configuration for ProofChain
+ * @typedef {Object} ProofChainConfig
+ * @property {string} [contractAddress] - Address of deployed ProofOfIntegrity contract
+ * @property {string} [abi] - ABI of the contract (optional, defaults to PROOF_OF_INTEGRITY_ABI)
+ */
+/**
+ * Class for handling blockchain proof of integrity
+ * @class
+ */
+export class ProofChain {
+    /**
+     * Extends Gun with proof methods
+     * @param {typeof Gun} Gun - Gun constructor
+     */
+    static extendGun(Gun: import("gun").IGun): void;
+    /**
+     * Creates a new ProofChain instance
+     * @param {Gun} gun - Gun instance
+     * @param {ProofChainConfig} [config] - Optional configuration
+     */
+    constructor(gun: import("gun").IGun, config?: ProofChainConfig);
+    /** @type {ExtendedGun} */
+    gun: ExtendedGun;
+    contractAddress: string;
+    contractAbi: any;
+    /**
+     * Gets contract instance for the specified chain
+     * @param {string} chain - Chain identifier
+     * @returns {Promise<Contract>} Contract instance
+     */
+    getContract(chain: string): Promise<Contract>;
+    /**
+     * Converts an ID to bytes32
+     * @param {ethers.BytesLike} id - ID to convert
+     * @returns {string} ID converted to bytes32
+     */
+    convertToBytes32(id: ethers.BytesLike): string;
+    /**
+     * Verifies data on-chain
+     * @param {string} chain - Chain identifier
+     * @param {string} nodeId - Node ID to verify
+     * @param {string} contentHash - Content hash to verify
+     * @returns {Promise<ProofResult>} Verification result
+     */
+    verifyOnChain(chain: string, nodeId: string, contentHash: string): Promise<ProofResult>;
+    /**
+     * Writes data on-chain
+     * @param {string} chain - Chain identifier
+     * @param {string} nodeId - Node ID to write
+     * @param {string} contentHash - Content hash to write
+     * @param {Object} options - Transaction options
+     * @returns {Promise<ExtendedTransaction>} Resulting transaction
+     */
+    writeOnChain(chain: string, nodeId: string, contentHash: string, options?: any): Promise<ExtendedTransaction>;
+    /**
+     * Gets the latest record
+     * @param {string} chain - Chain name
+     * @param {ethers.BytesLike} nodeId - Node ID
+     * @returns {Promise<LatestRecord>} Latest record
+     */
+    getLatestRecord(chain: string, nodeId: ethers.BytesLike): Promise<LatestRecord>;
+    /**
+     * Verifies or writes data with proof of integrity
+     * @param {string} chain - Chain name
+     * @param {string} nodeId - Node ID (for verification)
+     * @param {object} data - Data to write
+     * @param {function} callback - Callback function
+     * @param {object} options - Transaction options
+     * @returns {Promise<this>} Current instance
+     */
+    proof(chain: string, nodeId: string, data: object, callback: Function, options?: object): Promise<this>;
+}
+/**
+ * Result of proof verification
+ */
+export type ProofResult = {
+    /**
+     * - Whether the data is valid
+     */
+    isValid: boolean;
+    /**
+     * - Verification timestamp
+     */
+    timestamp: number;
+    /**
+     * - Address of last update
+     */
+    updater: string;
+};
+/**
+ * Latest record
+ */
+export type LatestRecord = {
+    /**
+     * - Content hash
+     */
+    contentHash: string;
+    /**
+     * - Last update timestamp
+     */
+    timestamp: number;
+    /**
+     * - Address of last updater
+     */
+    updater: string;
+};
+/**
+ * Callback for proof operations
+ */
+export type ProofCallback = {
+    /**
+     * - Whether operation was successful
+     */
+    ok?: boolean;
+    /**
+     * - Success/error message
+     */
+    message?: string;
+    /**
+     * - Error message
+     */
+    err?: string;
+    /**
+     * - Operation timestamp
+     */
+    timestamp?: number;
+    /**
+     * - Updater address
+     */
+    updater?: string;
+    /**
+     * - Latest record
+     */
+    latestRecord?: LatestRecord;
+    /**
+     * - Created node ID
+     */
+    nodeId?: string;
+    /**
+     * - Transaction hash
+     */
+    txHash?: string;
+};
+/**
+ * Options for proof transactions
+ */
+export type ProofOptions = {
+    /**
+     * - Gas limit for transaction
+     */
+    gasLimit?: number;
+    /**
+     * - Gas price
+     */
+    gasPrice?: number;
+};
+/**
+ * Extended Gun with additional methods
+ */
+export type ExtendedGun = import("gun").IGun & {
+    get: (path: string) => any;
+};
+/**
+ * Extended transaction with additional methods
+ */
+export type ExtendedTransaction = import("ethers").ContractTransaction & {
+    wait: () => Promise<any>;
+    hash: string;
+};
+/**
+ * Configuration for ProofChain
+ */
+export type ProofChainConfig = {
+    /**
+     * - Address of deployed ProofOfIntegrity contract
+     */
+    contractAddress?: string;
+    /**
+     * - ABI of the contract (optional, defaults to PROOF_OF_INTEGRITY_ABI)
+     */
+    abi?: string;
+};
+import { Contract } from "ethers";
+import { ethers } from 'ethers';

package/dist/types/features/stealth/StealthChain.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Extended Gun with additional methods
+ * @typedef {import('gun').IGun & {
+ *   get: (path: string) => any,
+ *   verifySignature: (message: string, signature: string) => Promise<string>,
+ *   put: (data: any) => void,
+ *   set: (data: any) => void,
+ *   map: () => any,
+ *   once: (callback: (data: any, key: string) => void) => void
+ * }} ExtendedGun
+ */
+/**
+ * @typedef {Object} StealthAddressResult
+ * @property {string} stealthPrivateKey - The private key of the stealth address
+ * @property {string} stealthAddress - The stealth address
+ * @property {ethers.Wallet} wallet - The stealth wallet
+ */
+/**
+ * @typedef {Object} StealthAddressGenerationResult
+ * @property {string} stealthAddress - The generated stealth address
+ * @property {string} senderPublicKey - The public key of the sender
+ * @property {string} spendingPublicKey - The spending public key of the recipient
+ */
+/**
+ * @typedef {Object} StealthPaymentOptions
+ * @property {boolean} [onChain] - If true, announce on-chain, otherwise off-chain
+ * @property {string} [chain] - The chain to announce on (if onChain=true)
+ */
+/**
+ * @typedef {Object} StealthPaymentResult
+ * @property {ethers.Wallet} wallet - The recovered wallet
+ * @property {string} address - The recovered address
+ */
+/**
+ * @typedef {Object} PublicKeysResult
+ * @property {string} viewingPublicKey - The viewing public key
+ * @property {string} spendingPublicKey - The spending public key
+ */
+/**
+ * Configuration for StealthChain
+ * @typedef {Object} StealthChainConfig
+ * @property {string} [contractAddress] - Address of deployed StealthAnnouncer contract
+ * @property {string} [abi] - ABI of the contract (optional, defaults to STEALTH_ANNOUNCER_ABI)
+ */
+export class StealthChain {
+    /**
+     * Creates a new StealthChain instance
+     * @param {ExtendedGun} gun - Gun instance
+     * @param {StealthChainConfig} [config] - Optional configuration
+     */
+    constructor(gun: ExtendedGun, config?: StealthChainConfig);
+    /** @type {ExtendedGun} */
+    gun: ExtendedGun;
+    /** @type {string | undefined} */
+    contractAddress: string | undefined;
+    /** @type {any} */
+    contractAbi: any;
+    /**
+     * Gets contract instance for the specified chain
+     * @param {string} chain - Chain identifier
+     * @returns {Promise<ethers.Contract>} Contract instance
+     */
+    getContract(chain: string): Promise<ethers.Contract>;
+    /**
+     * Derives a stealth address from shared secret and spending public key
+     * @param {string} sharedSecret - The shared secret
+     * @param {string} spendingPublicKey - The spending public key
+     * @returns {StealthAddressResult} The derived stealth address details
+     */
+    deriveStealthAddress(sharedSecret: string, spendingPublicKey: string): StealthAddressResult;
+    /**
+     * Generates a stealth address for a recipient
+     * @param {string} recipientAddress - The recipient's address
+     * @param {string} signature - The signature
+     * @param {Object} options - Additional options
+     * @returns {Promise<StealthAddressGenerationResult>} The generated stealth address details
+     */
+    generateStealthAddress(recipientAddress: string, signature: string, options?: any): Promise<StealthAddressGenerationResult>;
+    /**
+     * Announces a stealth payment on-chain or off-chain
+     * @param {string} stealthAddress - The stealth address of the recipient
+     * @param {string} senderPublicKey - The sender's public key
+     * @param {string} spendingPublicKey - The recipient's spending public key
+     * @param {string} signature - The sender's signature
+     * @param {StealthPaymentOptions} options - Additional options
+     * @returns {Promise<{stealthAddress: string, senderPublicKey: string, spendingPublicKey: string, timestamp: number, source: string}>}
+     */
+    announceStealthPayment(stealthAddress: string, senderPublicKey: string, spendingPublicKey: string, signature: string, options?: StealthPaymentOptions): Promise<{
+        stealthAddress: string;
+        senderPublicKey: string;
+        spendingPublicKey: string;
+        timestamp: number;
+        source: string;
+    }>;
+    /**
+     * Retrieves stealth payments
+     * @param {string} signature - The signature
+     * @param {Object} options - Additional options
+     * @returns {Promise<Array>} The list of stealth payments
+     */
+    getStealthPayments(signature: string, options?: any): Promise<any[]>;
+    /**
+     * Recovers stealth funds
+     * @param {string} stealthAddress - The stealth address
+     * @param {string} senderPublicKey - The sender's public key
+     * @param {string} signature - The signature
+     * @param {string} spendingPublicKey - The spending public key
+     * @returns {Promise<StealthPaymentResult>} The recovered funds details
+     */
+    recoverStealthFunds(stealthAddress: string, senderPublicKey: string, signature: string, spendingPublicKey: string): Promise<StealthPaymentResult>;
+    /**
+     * Publishes user's stealth keys
+     * @param {string} signature - The signature
+     * @returns {Promise<PublicKeysResult>} The published public keys
+     */
+    publishStealthKeys(signature: string): Promise<PublicKeysResult>;
+}
+/**
+ * Extended Gun with additional methods
+ */
+export type ExtendedGun = import("gun").IGun & {
+    get: (path: string) => any;
+    verifySignature: (message: string, signature: string) => Promise<string>;
+    put: (data: any) => void;
+    set: (data: any) => void;
+    map: () => any;
+    once: (callback: (data: any, key: string) => void) => void;
+};
+export type StealthAddressResult = {
+    /**
+     * - The private key of the stealth address
+     */
+    stealthPrivateKey: string;
+    /**
+     * - The stealth address
+     */
+    stealthAddress: string;
+    /**
+     * - The stealth wallet
+     */
+    wallet: ethers.Wallet;
+};
+export type StealthAddressGenerationResult = {
+    /**
+     * - The generated stealth address
+     */
+    stealthAddress: string;
+    /**
+     * - The public key of the sender
+     */
+    senderPublicKey: string;
+    /**
+     * - The spending public key of the recipient
+     */
+    spendingPublicKey: string;
+};
+export type StealthPaymentOptions = {
+    /**
+     * - If true, announce on-chain, otherwise off-chain
+     */
+    onChain?: boolean;
+    /**
+     * - The chain to announce on (if onChain=true)
+     */
+    chain?: string;
+};
+export type StealthPaymentResult = {
+    /**
+     * - The recovered wallet
+     */
+    wallet: ethers.Wallet;
+    /**
+     * - The recovered address
+     */
+    address: string;
+};
+export type PublicKeysResult = {
+    /**
+     * - The viewing public key
+     */
+    viewingPublicKey: string;
+    /**
+     * - The spending public key
+     */
+    spendingPublicKey: string;
+};
+/**
+ * Configuration for StealthChain
+ */
+export type StealthChainConfig = {
+    /**
+     * - Address of deployed StealthAnnouncer contract
+     */
+    contractAddress?: string;
+    /**
+     * - ABI of the contract (optional, defaults to STEALTH_ANNOUNCER_ABI)
+     */
+    abi?: string;
+};
+import { ethers } from "ethers";

package/dist/types/index.d.ts

@@ -0,0 +1,61 @@
+export type BubbleProviderOptions = {
+    /**
+     * - RPC URL for the provider
+     */
+    rpcUrl: string;
+    /**
+     * - Contract address
+     */
+    contractAddress: string;
+    /**
+     * - Contract ABI
+     */
+    contractAbi?: any;
+    /**
+     * - Gun instance
+     */
+    gun: any;
+    /**
+     * - Encryption keypair
+     */
+    keypair: {
+        epub: string;
+        epriv: string;
+    };
+};
+export type GunNode = {
+    name?: string;
+    owner?: string;
+    filePath?: string;
+    content?: string;
+    created?: number;
+    updated?: number;
+    size?: number;
+    readOnly?: boolean;
+    encryptionInfo?: {
+        ownerEpub: string;
+        ownerAddress: string;
+    };
+};
+export type EthereumProvider = {
+    request: (request: {
+        method: string;
+        params?: any[] | Record<string, any>;
+    }) => Promise<any>;
+    chainId?: string;
+    isMetaMask?: boolean;
+};
+export type FileMetadata = {
+    name: string;
+    owner: string;
+    filePath: string;
+    created: number;
+    updated: number;
+    size: number;
+    readOnly: boolean;
+};
+import { GunEth } from "./core/gun-eth.js";
+import { ProofChain } from "./features/proof/ProofChain.js";
+import { StealthChain } from "./features/stealth/StealthChain.js";
+import { GUNBubbleProvider } from "./features/bubbles/providers/gun-bubble-provider.js";
+export { GunEth, ProofChain, StealthChain, GUNBubbleProvider };

package/dist/types/utils/common.d.ts

@@ -0,0 +1,11 @@
+export function generateRandomId(): string;
+export function getContractAddresses(chain?: string): {
+    PROOF_OF_INTEGRITY_ADDRESS: string;
+    STEALTH_ANNOUNCER_ADDRESS: string;
+};
+export function setSigner(newRpcUrl: any, newPrivateKey: any): any;
+export function getSigner(chain?: string): Promise<any>;
+export type EthereumProvider = import("ethers").Eip1193Provider;
+export type WindowWithEthereum = Window & {
+    ethereum?: EthereumProvider;
+};

package/dist/types/utils/encryption.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {Object|string} KeyPair
+ * @property {string} [epriv] - Private encryption key
+ * @property {string} [epub] - Public encryption key
+ * @property {string} [pub] - Optional public key
+ * @property {string} [priv] - Optional private key
+ */
+/**
+ * Encrypts data using SEA encryption
+ * @param {string|Object} data - Data to encrypt
+ * @param {KeyPair} keypair - Keypair for encryption
+ * @returns {Promise<string>} Encrypted data
+ * @throws {Error} If encryption fails
+ */
+export function encrypt(data: string | any, keypair: KeyPair): Promise<string>;
+/**
+ * Decrypts data using SEA decryption
+ * @param {string} data - Encrypted data to decrypt
+ * @param {KeyPair} keypair - Keypair for decryption
+ * @returns {Promise<string|Object>} Decrypted data
+ * @throws {Error} If decryption fails
+ */
+export function decrypt(data: string, keypair: KeyPair): Promise<string | any>;
+/**
+ * Derives a shared secret key between two keypairs
+ * @param {string} recipientEpub - Recipient's public encryption key
+ * @param {KeyPair} senderKeypair - Sender's keypair
+ * @returns {Promise<string>} Derived shared key
+ * @throws {Error} If key derivation fails
+ */
+export function deriveSharedKey(recipientEpub: string, senderKeypair: KeyPair): Promise<string>;
+export type KeyPair = any | string;

package/package.json

@@ -1,36 +1,120 @@
 {
   "name": "gun-eth",
-  "version": "2.0.1",
+  "version": "3.0.0",
+  "type": "module",
+  "main": "./dist/gun-eth.cjs",
+  "module": "./dist/gun-eth.mjs",
+  "browser": "./dist/gun-eth.browser.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "browser": "./dist/gun-eth.browser.mjs",
+        "default": "./dist/gun-eth.mjs"
+      },
+      "require": "./dist/gun-eth.cjs"
+    }
+  },
   "description": "A GunDB plugin for Ethereum, and Web3",
-  "source": "src/index.js",
-  "main": "dist/gun-eth-protocol.cjs.js",
-  "module": "dist/gun-eth-protocol.esm.js",
-  "browser": "dist/gun-eth-protocol.umd.js",
-  "react": "dist/gun-eth-protocol.react.js",
-  "license": "GPL-3.0",
-  "private": false,
+  "scripts": {
+    "test": "hardhat test",
+    "compile": "hardhat compile",
+    "start-node": "hardhat node",
+    "deploy-local": "hardhat run scripts/start-local-node.cjs --network localhost",
+    "deploy-contracts": "hardhat run scripts/deploy-contracts.cjs",
+    "test-stealth": "cross-env NODE_ENV=development node --experimental-json-modules test/stealth-example.js",
+    "test-proof": "cross-env NODE_ENV=development node --experimental-json-modules test/proof-example.js",
+    "test-bubble": "cross-env NODE_ENV=development node --experimental-json-modules test/bubble-test.js",
+    "test-contracts": "npx hardhat test ./test/index.test.cjs --config hardhat.config.cjs",
+    "test-all": "npm run test-stealth && npm run test-proof && npm run test-bubble && npm run test-contracts",
+    "build": "rollup -c",
+    "prepare": "npm run build",
+    "clean": "rimraf dist",
+    "start-provider": "node ./templates/template-bubble-provider.js",
+    "start-client": "node ./templates/template-bubble-client.js"
+  },
   "dependencies": {
-    "axios": "^0.24.0",
-    "gun": "^0.2020.1235",
-    "gun-avatar": "^1.3.5",
-    "hyperswarm-web": "^2.1.1",
-    "rxjs": "^7.4.0",
-    "slugid": "^3.0.0",
-    "sodium-universal": "^3.0.4",
-    "uuid": "^8.3.2"
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@nomiclabs/hardhat-waffle": "^2.0.6",
+    "@openzeppelin/contracts": "^5.1.0",
+    "@peculiar/webcrypto": "^1.5.0",
+    "@scobru/mogu": "^4.0.7",
+    "cors": "^2.8.5",
+    "ethereum-waffle": "^4.0.10",
+    "ethers": "^6.0.0",
+    "express": "^4.21.1",
+    "gun": "^0.2020.1239",
+    "hardhat-verify": "^1.0.0",
+    "node-fetch": "^3.3.2",
+    "text-encoding": "^0.7.0"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^21.0.1",
-    "@rollup/plugin-node-resolve": "^15.3.0",
-    "jsdoc": "^4.0.4",
-    "rollup": "^2.66.1",
+    "@babel/core": "^7.23.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/preset-env": "^7.23.2",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.12",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
+    "@rollup/plugin-babel": "^6.0.0",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "@rollup/plugin-replace": "^5.0.0",
+    "@typechain/ethers-v6": "^0.4.0",
+    "@typechain/hardhat": "^8.0.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": "^10.0.1",
+    "assert": "^2.1.0",
+    "buffer": "^6.0.3",
+    "chai": "^4.3.7",
+    "core-js": "3",
+    "cross-env": "^7.0.3",
+    "crypto-browserify": "^3.12.1",
+    "file-loader": "^6.2.0",
+    "hardhat": "^2.22.16",
+    "hardhat-gas-reporter": "^1.0.8",
+    "path-browserify": "^1.0.1",
+    "process": "^0.11.10",
+    "rimraf": "^5.0.0",
+    "rollup": "^3.0.0",
     "rollup-plugin-terser": "^7.0.2",
-    "tsd-jsdoc": "^2.5.0"
+    "solidity-coverage": "^0.8.1",
+    "stream-browserify": "^3.0.0",
+    "terser-webpack-plugin": "^5.3.9",
+    "ts-node": "^10.9.1",
+    "typechain": "^8.2.0",
+    "typescript": "^5.0.0",
+    "url": "^0.11.0",
+    "util": "^0.12.4",
+    "webpack": "^5.0.0",
+    "webpack-cli": "^4.0.0"
   },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rollup -c",
-    "generate-types": "jsdoc -t node_modules/tsd-jsdoc/dist -r ./src -d types"
+  "author": "scobru",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scobru/gun-eth.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "gundb",
+    "web3",
+    "evm",
+    "ethereum",
+    "decentralized",
+    "storage",
+    "gun",
+    "db"
+  ],
+  "bugs": {
+    "url": "https://github.com/scobru/gun-eth/issues"
   },
-  "author": ""
+  "homepage": "https://github.com/scobru/gun-eth#readme",
+  "files": [
+    "dist"
+  ]
 }