gun-eth 2.0.1 → 3.0.1

package/dist/types/browser.d.ts

@@ -0,0 +1,6 @@
+export default browserGunEth;
+export type BrowserGunEth = {
+    GunEth: typeof import("./core/gun-eth.js").GunEth;
+};
+/** @type {BrowserGunEth} */
+declare const browserGunEth: BrowserGunEth;

package/dist/types/config/local.d.ts

@@ -0,0 +1,7 @@
+export namespace LOCAL_CONFIG {
+    let STEALTH_ANNOUNCER_ADDRESS: any;
+    let PROOF_OF_INTEGRITY_ADDRESS: any;
+    let BUBBLE_REGISTRY_ADDRESS: any;
+    let RPC_URL: string;
+    let CHAIN_ID: number;
+}

package/dist/types/constants/abis.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Ottiene le configurazioni degli indirizzi per una specifica chain
+ * @param {string} [chain='localhost'] - Nome della chain
+ * @returns {ChainConfig} Configurazione degli indirizzi per la chain specificata
+ * @throws {Error} Se la configurazione della chain non viene trovata
+ */
+export function getAddressesForChain(chain?: string): ChainConfig;
+export const STEALTH_ANNOUNCER_ABI: any;
+export const BUBBLE_REGISTRY_ABI: any;
+export const PROOF_OF_INTEGRITY_ABI: any;
+/** @type {boolean} */
+export const isLocalEnvironment: boolean;
+export const PROOF_OF_INTEGRITY_ADDRESS: string;
+export const STEALTH_ANNOUNCER_ADDRESS: string;
+export const BUBBLE_REGISTRY_ADDRESS: string;
+export type ChainConfig = {
+    /**
+     * - ID della chain
+     */
+    CHAIN_ID: number;
+    /**
+     * - URL del nodo RPC
+     */
+    RPC_URL: string;
+    /**
+     * - Indirizzo del contratto ProofOfIntegrity
+     */
+    PROOF_OF_INTEGRITY_ADDRESS: string;
+    /**
+     * - Indirizzo del contratto StealthAnnouncer
+     */
+    STEALTH_ANNOUNCER_ADDRESS: string;
+    /**
+     * - Indirizzo del contratto BubbleRegistry
+     */
+    BUBBLE_REGISTRY_ADDRESS: string;
+};

package/dist/types/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./abis.js";

package/dist/types/core/gun-eth.d.ts

@@ -0,0 +1,419 @@
+/**
+ * Classe principale per l'integrazione di Gun con Ethereum
+ */
+export class GunEth {
+    static keypair: any;
+    static v_keypair: any;
+    static s_keypair: any;
+    static init(chain?: string): Promise<typeof GunEth>;
+    static generateRandomId: typeof generateRandomId;
+    static generatePassword: typeof generatePassword;
+    static getSigner: typeof getSigner;
+    static verifySignature: typeof verifySignature;
+    static MESSAGE_TO_SIGN: string;
+    static getContractAddresses: typeof getContractAddresses;
+    static extendGun: typeof extendGun;
+    static initializeGun: typeof initializeGun;
+    static setSigner: typeof setSigner;
+    static gunToEthAccount: typeof gunToEthAccount;
+    static decryptPair: typeof decryptPair;
+    static decryptPairFromPassword: typeof decryptPairFromPassword;
+    static ethToGunAccount: typeof ethToGunAccount;
+    static createAndStoreEncryptedPair: typeof createAndStoreEncryptedPair;
+    static getAndDecryptPair: typeof getAndDecryptPair;
+    static createSignature: typeof createSignature;
+    static LOCAL_CONFIG: {
+        STEALTH_ANNOUNCER_ADDRESS: any;
+        PROOF_OF_INTEGRITY_ADDRESS: any;
+        BUBBLE_REGISTRY_ADDRESS: any;
+        RPC_URL: string;
+        CHAIN_ID: number;
+    };
+    static contractAddresses: {
+        PROOF_OF_INTEGRITY_ADDRESS: string;
+        STEALTH_ANNOUNCER_ADDRESS: string;
+    };
+}
+export type IGunChain = import("gun").IGunChain<any, any, any, any>;
+export type IGunInstance = import("gun").IGunInstance;
+export type IGun = import("gun").IGun;
+export type GunOptions = import("gun").GunOptions;
+export type GunSchema = import("gun").GunSchema;
+export type GunHookCallbackCreate = import("gun").GunHookCallbackCreate;
+export type GunHookCallbackOpt = import("gun").GunHookCallbackOpt;
+export type GunMethods = {
+    /**
+     * - Get method
+     */
+    get: (path: string) => IGunInstance;
+    /**
+     * - Put method
+     */
+    put: (data: any) => IGunInstance;
+    /**
+     * - Set method
+     */
+    set: (data: any) => IGunInstance;
+    /**
+     * - Map method
+     */
+    map: () => IGunInstance;
+    /**
+     * - Back method
+     */
+    back: () => IGunInstance;
+    /**
+     * - Off method
+     */
+    off: () => IGunInstance;
+    /**
+     * - On method
+     */
+    on: {
+        (event: "create", callback: GunHookCallbackCreate): void;
+        (event: "opt", callback: GunHookCallbackOpt): void;
+        (event: string, callback: Function): IGunInstance;
+    };
+    /**
+     * - Once method
+     */
+    once: (callback: (data: any, key: string) => void) => IGunInstance;
+};
+export type GunBase = {
+    /**
+     * - Gun state
+     */
+    state: any;
+    /**
+     * - Gun chain
+     */
+    chain: IGunChain & IGunInstance;
+    /**
+     * - Gun SEA
+     */
+    SEA: any;
+    /**
+     * - Verify signature method
+     */
+    verifySignature: (message: string, signature: string) => Promise<string>;
+    /**
+     * - Gun internal properties
+     */
+    _: any;
+    /**
+     * - Gun user instance
+     */
+    user: any;
+    /**
+     * - Gun options
+     */
+    opt: any;
+};
+export type GunExtended = GunBase & GunMethods & {
+    (options?: GunOptions): IGunInstance;
+    new (options?: GunOptions): IGunInstance;
+};
+export type StealthMethodsBase = {
+    generateStealthAddress: (this: IGunInstance, arg1: string, arg2: string, arg3: any) => Promise<any>;
+    announceStealthPayment: (this: IGunInstance, arg1: string, arg2: string, arg3: string, arg4: string, arg5: any) => Promise<{
+        stealthAddress: string;
+        senderPublicKey: string;
+        spendingPublicKey: string;
+        timestamp: number;
+        source: string;
+    }>;
+    getStealthPayments: (this: IGunInstance, arg1: string, arg2: any) => Promise<Array<any>>;
+    recoverStealthFunds: (this: IGunInstance, arg1: string, arg2: string, arg3: string, arg4: string) => Promise<any>;
+    publishStealthKeys: (this: IGunInstance, arg1: string) => Promise<any>;
+    stealth: (this: IGunInstance, arg1: string, ...args: any[][]) => Promise<any>;
+    monitorStealthEvents: (this: IGunInstance, arg1: (arg0: any) => void) => any;
+};
+export type ExtendedSigner = {
+    /**
+     * - Ethereum address
+     */
+    address: string;
+    /**
+     * - Private key
+     */
+    privateKey: string;
+    /**
+     * - Signs a message
+     */
+    signMessage: (arg0: string) => Promise<string>;
+    /**
+     * - Gets the signer address
+     */
+    getAddress: () => Promise<string>;
+    /**
+     * - Provider instance
+     */
+    provider: any;
+};
+export type BaseMethods = {
+    MESSAGE_TO_SIGN: string;
+    setSigner: Function;
+    getSigner: Function;
+    verifySignature: Function;
+    generatePassword: Function;
+    createSignature: Function;
+    createAndStoreEncryptedPair: Function;
+    getAndDecryptPair: Function;
+    ethToGunAccount: Function;
+    gunToEthAccount: Function;
+    getAddressesForChain: Function;
+};
+export type StealthMethods = StealthMethodsBase & IGunInstance;
+export type ExtendedGunBase = {
+    /**
+     * - Gun state
+     */
+    state: any;
+    /**
+     * - Gun chain
+     */
+    chain: IGunChain & IGunInstance;
+    /**
+     * - Gun SEA
+     */
+    SEA: any;
+    /**
+     * - Get method
+     */
+    get: (path: string) => any;
+    /**
+     * - Put method
+     */
+    put: (data: any) => void;
+    /**
+     * - Set method
+     */
+    set: (data: any) => void;
+    /**
+     * - Map method
+     */
+    map: () => any;
+    /**
+     * - On method
+     */
+    on: (event: string, callback: Function) => any;
+    /**
+     * - Once method
+     */
+    once: (callback: (data: any, key: string) => void) => void;
+    /**
+     * - Verify signature method
+     */
+    verifySignature: (message: string, signature: string) => Promise<string>;
+    /**
+     * - Gun internal properties
+     */
+    _: any;
+    /**
+     * - Gun user instance
+     */
+    user: any;
+    /**
+     * - Gun options
+     */
+    opt: any;
+};
+export type ExtendedGun = ExtendedGunBase & IGun;
+export type FullGunInstance = ExtendedGun & IGunInstance;
+export type GunHookCallbacks = {
+    /**
+     * - Create callback
+     */
+    create: Function;
+    /**
+     * - Put callback
+     */
+    put: Function;
+    /**
+     * - Get callback
+     */
+    get: Function;
+    /**
+     * - Opt callback
+     */
+    opt: Function;
+};
+import { generateRandomId } from '../utils/common.js';
+/**
+ * @param {ethers.BytesLike} signature
+ */
+export function generatePassword(signature: ethers.BytesLike): string;
+export function getSigner(chain?: string): Promise<any>;
+/**
+ * @param {string | Uint8Array} message
+ * @param {ethers.SignatureLike} signature
+ */
+export function verifySignature(message: string | Uint8Array, signature: ethers.SignatureLike): Promise<string>;
+import { getContractAddresses } from '../utils/common.js';
+/**
+ * @param {import("gun").IGun} Gun
+ */
+export function extendGun(Gun: import("gun").IGun): void;
+/**
+ * Inizializza Gun con le estensioni e le opzioni specificate
+ * @param {string} chain - Chain da utilizzare
+ * @param {Object} [options] - Opzioni di configurazione per Gun
+ * @returns {Promise<IGunInstance>} Istanza di Gun configurata
+ */
+export function initializeGun(chain?: string, options?: any): Promise<IGunInstance>;
+/**
+ * @param {string} newRpcUrl
+ * @param {string} newPrivateKey
+ */
+export function setSigner(newRpcUrl: string, newPrivateKey: string): any;
+/**
+ * @param {string} gunPrivateKey
+ */
+export function gunToEthAccount(gunPrivateKey: string): any;
+/**
+ * @param {string} encryptedPair
+ * @param {any} password
+ */
+export function decryptPair(encryptedPair: string, password: any): Promise<any>;
+/**
+ * @param {string} encryptedPair
+ * @param {any} password
+ */
+export function decryptPairFromPassword(encryptedPair: string, password: any): Promise<any>;
+export function ethToGunAccount(): Promise<{
+    pair: import("gun").ISEAPair;
+    v_pair: import("gun").ISEAPair;
+    s_pair: import("gun").ISEAPair;
+    ethAddress: string;
+    ethPrivateKey: string;
+    env_pair: string;
+    env_v_pair: string;
+    env_s_pair: string;
+    publicKeys: {
+        viewingPublicKey: string;
+        spendingPublicKey: any;
+        ethViewingAddress: any;
+    };
+}>;
+/**
+ * @param {any} address
+ */
+export function createAndStoreEncryptedPair(address: any): Promise<void>;
+/**
+ * @param {any} address
+ * @param {any} signature
+ */
+export function getAndDecryptPair(address: any, signature: any): Promise<any>;
+/**
+ * Crea una firma utilizzando il signer corrente
+ * @param {string} message - Messaggio da firmare
+ * @returns {Promise<string>} Firma generata
+ */
+export function createSignature(message: string): Promise<string>;
+/**
+ * @typedef {import('gun').IGunChain<any, any, any, any>} IGunChain
+ * @typedef {import('gun').IGunInstance} IGunInstance
+ * @typedef {import('gun').IGun} IGun
+ * @typedef {import('gun').GunOptions} GunOptions
+ * @typedef {import('gun').GunSchema} GunSchema
+ * @typedef {import('gun').GunHookCallbackCreate} GunHookCallbackCreate
+ * @typedef {import('gun').GunHookCallbackOpt} GunHookCallbackOpt
+ */
+/**
+ * @typedef {Object} GunMethods
+ * @property {(path: string) => IGunInstance} get - Get method
+ * @property {(data: any) => IGunInstance} put - Put method
+ * @property {(data: any) => IGunInstance} set - Set method
+ * @property {() => IGunInstance} map - Map method
+ * @property {() => IGunInstance} back - Back method
+ * @property {() => IGunInstance} off - Off method
+ * @property {{
+ *   (event: "create", callback: GunHookCallbackCreate): void;
+ *   (event: "opt", callback: GunHookCallbackOpt): void;
+ *   (event: string, callback: Function): IGunInstance;
+ * }} on - On method
+ * @property {(callback: (data: any, key: string) => void) => IGunInstance} once - Once method
+ */
+/**
+ * @typedef {Object} GunBase
+ * @property {Object} state - Gun state
+ * @property {IGunChain & IGunInstance} chain - Gun chain
+ * @property {Object} SEA - Gun SEA
+ * @property {(message: string, signature: string) => Promise<string>} verifySignature - Verify signature method
+ * @property {Object} _ - Gun internal properties
+ * @property {Object} user - Gun user instance
+ * @property {Object} opt - Gun options
+ */
+/**
+ * @typedef {GunBase & GunMethods & {
+ *   (options?: GunOptions): IGunInstance;
+ *   new (options?: GunOptions): IGunInstance;
+ * }} GunExtended
+ */
+/**
+ * @typedef {Object} StealthMethodsBase
+ * @property {function(this: IGunInstance, string, string, Object): Promise<any>} generateStealthAddress
+ * @property {function(this: IGunInstance, string, string, string, string, Object): Promise<{stealthAddress: string, senderPublicKey: string, spendingPublicKey: string, timestamp: number, source: string}>} announceStealthPayment
+ * @property {function(this: IGunInstance, string, Object): Promise<Array<any>>} getStealthPayments
+ * @property {function(this: IGunInstance, string, string, string, string): Promise<any>} recoverStealthFunds
+ * @property {function(this: IGunInstance, string): Promise<any>} publishStealthKeys
+ * @property {function(this: IGunInstance, string, ...any[]): Promise<any>} stealth
+ * @property {function(this: IGunInstance, function(any): void): any} monitorStealthEvents
+ */
+/**
+ * @typedef {Object} ExtendedSigner
+ * @property {string} address - Ethereum address
+ * @property {string} privateKey - Private key
+ * @property {function(string): Promise<string>} signMessage - Signs a message
+ * @property {function(): Promise<string>} getAddress - Gets the signer address
+ * @property {Object} provider - Provider instance
+ */
+/**
+ * @typedef {Object} BaseMethods
+ * @property {string} MESSAGE_TO_SIGN
+ * @property {function} setSigner
+ * @property {function} getSigner
+ * @property {function} verifySignature
+ * @property {function} generatePassword
+ * @property {function} createSignature
+ * @property {function} createAndStoreEncryptedPair
+ * @property {function} getAndDecryptPair
+ * @property {function} ethToGunAccount
+ * @property {function} gunToEthAccount
+ * @property {function} getAddressesForChain
+ */
+/**
+ * @typedef {StealthMethodsBase & IGunInstance} StealthMethods
+ */
+/**
+ * @typedef {Object} ExtendedGunBase
+ * @property {Object} state - Gun state
+ * @property {IGunChain & IGunInstance} chain - Gun chain
+ * @property {Object} SEA - Gun SEA
+ * @property {(path: string) => any} get - Get method
+ * @property {(data: any) => void} put - Put method
+ * @property {(data: any) => void} set - Set method
+ * @property {() => any} map - Map method
+ * @property {(event: string, callback: Function) => any} on - On method
+ * @property {(callback: (data: any, key: string) => void) => void} once - Once method
+ * @property {(message: string, signature: string) => Promise<string>} verifySignature - Verify signature method
+ * @property {Object} _ - Gun internal properties
+ * @property {Object} user - Gun user instance
+ * @property {Object} opt - Gun options
+ */
+/**
+ * @typedef {ExtendedGunBase & IGun} ExtendedGun
+ */
+/**
+ * @typedef {ExtendedGun & IGunInstance} FullGunInstance
+ */
+/**
+ * @typedef {Object} GunHookCallbacks
+ * @property {function} create - Create callback
+ * @property {function} put - Put callback
+ * @property {function} get - Get callback
+ * @property {function} opt - Opt callback
+ */
+export const MESSAGE_TO_SIGN: "Access GunDB with Ethereum";
+import { ethers } from "ethers";
+export { generateRandomId, getContractAddresses };

package/dist/types/features/bubbles/client/bubble-client.d.ts

@@ -0,0 +1,184 @@
+/**
+ * Client per interagire con il servizio Bubble
+ */
+export class BubbleClient {
+    /**
+     * @param {BubbleClientOptions} options
+     */
+    constructor(options: BubbleClientOptions);
+    baseUrl: string;
+    signer: {
+        /**
+         * - Indirizzo Ethereum del signer
+         */
+        address: string;
+    };
+    keypair: {
+        /**
+         * - Chiave pubblica di crittografia
+         */
+        epub: string;
+        /**
+         * - Chiave privata di crittografia
+         */
+        epriv: string;
+    };
+    contractAddress: string;
+    contractAbi: any;
+    /**
+     * Inizializza la sessione bubble
+     * @returns {Promise<boolean>}
+     */
+    initBubbleSession(): Promise<boolean>;
+    /**
+     * Crea una nuova bubble
+     * @param {string} name - Nome della bubble
+     * @param {BubbleCreateOptions} [options] - Opzioni di creazione
+     * @returns {Promise<BubbleMetadata>}
+     */
+    createBubble(name: string, options?: BubbleCreateOptions): Promise<BubbleMetadata>;
+    /**
+     * Scrive un file nella bubble
+     * @param {string} bubbleId - ID della bubble
+     * @param {string} fileName - Nome del file
+     * @param {string} content - Contenuto del file
+     * @returns {Promise<BubbleWriteResult>}
+     */
+    writeBubble(bubbleId: string, fileName: string, content: string): Promise<BubbleWriteResult>;
+    /**
+     * Legge un file dalla bubble
+     * @param {string} bubbleId - ID della bubble
+     * @param {string} fileName - Nome del file
+     * @returns {Promise<BubbleReadResult>}
+     */
+    readBubble(bubbleId: string, fileName: string): Promise<BubbleReadResult>;
+    /**
+     * Condivide una bubble con un altro utente
+     * @param {string} bubbleId - ID della bubble
+     * @param {string} granteeAddress - Indirizzo del destinatario
+     * @param {BubbleShareOptions} [options] - Opzioni di condivisione
+     * @returns {Promise<BubbleShareResult>}
+     */
+    shareBubble(bubbleId: string, granteeAddress: string, options?: BubbleShareOptions): Promise<BubbleShareResult>;
+    /**
+     * Elimina una bubble
+     * @param {string} bubbleId - ID della bubble
+     * @param {Object} [options] - Opzioni aggiuntive
+     * @param {string} [options.userAddress] - Indirizzo dell'utente (opzionale, default: this.signer.address)
+     * @returns {Promise<{success: boolean}>}
+     */
+    deleteBubble(bubbleId: string, options?: {
+        userAddress?: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+}
+export type BubbleClientOptions = {
+    /**
+     * - URL del provider del servizio bubble
+     */
+    providerUrl: string;
+    /**
+     * - Signer Ethereum per autenticare le richieste
+     */
+    signer: {
+        address: string;
+    };
+    /**
+     * - Coppia di chiavi per crittografia
+     */
+    keypair: {
+        epub: string;
+        epriv: string;
+    };
+    /**
+     * - Optional custom contract address
+     */
+    contractAddress?: string;
+    /**
+     * - Optional custom contract ABI
+     */
+    contractAbi?: any;
+};
+export type BubbleCreateOptions = {
+    /**
+     * - Se la bubble deve essere privata
+     */
+    isPrivate?: boolean;
+};
+export type BubbleShareOptions = {
+    /**
+     * - Public key of recipient
+     */
+    granteeEpub: string;
+};
+export type BubbleMetadata = {
+    /**
+     * - ID della bubble
+     */
+    id: string;
+    /**
+     * - Nome della bubble
+     */
+    name: string;
+    /**
+     * - Indirizzo del proprietario
+     */
+    owner: string;
+    /**
+     * - Se la bubble è privata
+     */
+    isPrivate: boolean;
+    /**
+     * - Timestamp di creazione
+     */
+    createdAt: number;
+};
+export type FileMetadata = {
+    /**
+     * - Nome del file
+     */
+    name: string;
+    /**
+     * - Dimensione in bytes
+     */
+    size: number;
+    /**
+     * - Indirizzo del proprietario
+     */
+    owner: string;
+    /**
+     * - Timestamp di creazione
+     */
+    created: number;
+    /**
+     * - Timestamp ultimo aggiornamento
+     */
+    updated: number;
+};
+export type BubbleWriteResult = {
+    /**
+     * - Contenuto criptato
+     */
+    content: string;
+    /**
+     * - Metadati del file
+     */
+    metadata: FileMetadata;
+};
+export type BubbleReadResult = {
+    /**
+     * - Contenuto criptato
+     */
+    content: string;
+    /**
+     * - Metadati del file
+     */
+    metadata: FileMetadata;
+};
+export type BubbleShareResult = {
+    /**
+     * - Se la condivisione è avvenuta con successo
+     */
+    success: boolean;
+};