shogun-core 1.2.7 → 1.2.8

package/dist/types/contracts/entryPoint.d.ts

@@ -1,138 +0,0 @@
-/**
- * EntryPoint Class - Provides interaction with the Shogun Protocol EntryPoint contract
- */
-import { ethers } from "ethers";
-import { BaseContract, ContractConfig, EntryPointStats, SubscriptionDetails } from "./base";
-export interface EntryPointConfig extends ContractConfig {
-    entryPointAddress: string;
-}
-/**
- * EntryPoint - A class to interact with the Shogun Protocol EntryPoint contract
- */
-export declare class EntryPoint extends BaseContract {
-    /**
-     * Create a new EntryPoint instance
-     * @param config - Configuration for the EntryPoint
-     */
-    constructor(config: EntryPointConfig);
-    /**
-     * Get the registry address
-     * @returns The registry address or null if the call fails
-     */
-    getRegistryAddress(): Promise<string | null>;
-    /**
-     * Get the service fee percentage
-     * @returns The fee percentage or null if the call fails
-     */
-    getServiceFeePercentage(): Promise<number | null>;
-    /**
-     * Calculate fee amount
-     * @param amount - The amount to calculate fee on
-     * @returns The fee amount or null if the call fails
-     */
-    calculateFee(amount: bigint): Promise<bigint | null>;
-    /**
-     * Check if a user has an active subscription on a relay
-     * @param userAddress - The address of the user
-     * @param relayAddress - The address of the relay
-     * @returns True if the user has an active subscription, false otherwise
-     */
-    checkSubscription(userAddress: string, relayAddress: string): Promise<boolean>;
-    /**
-     * Check if a user has a registered public key on a relay
-     * @param userAddress - The address of the user
-     * @param relayAddress - The address of the relay
-     * @returns True if the user has a registered public key, false otherwise
-     */
-    hasRegisteredPubKey(userAddress: string, relayAddress: string): Promise<boolean>;
-    /**
-     * Check if a specific public key is subscribed on a relay
-     * @param relayAddress - The address of the relay
-     * @param pubKey - The public key to check (hex string or Uint8Array)
-     * @returns True if the public key is subscribed, false otherwise
-     */
-    isPubKeySubscribed(relayAddress: string, pubKey: string | Uint8Array): Promise<boolean>;
-    /**
-     * Check if public keys are subscribed on multiple relays
-     * @param relayAddresses - Array of relay addresses
-     * @param pubKeys - Array of public keys (hex strings or Uint8Arrays)
-     * @returns Array of booleans indicating subscription status for each relay/pubkey pair
-     */
-    batchCheckPubKeySubscription(relayAddresses: string[], pubKeys: (string | Uint8Array)[]): Promise<boolean[]>;
-    /**
-     * Get detailed subscription information
-     * @param userAddress - The address of the user
-     * @param relayAddress - The address of the relay
-     * @returns The subscription details or null if not found
-     */
-    getSubscriptionDetails(userAddress: string, relayAddress: string): Promise<SubscriptionDetails | null>;
-    /**
-     * Check if a user has active subscriptions on multiple relays
-     * @param userAddress - The address of the user
-     * @param relayAddresses - Array of relay addresses
-     * @returns Array of booleans indicating subscription status for each relay
-     */
-    batchCheckSubscriptions(userAddress: string, relayAddresses: string[]): Promise<boolean[]>;
-    /**
-     * Check if a user has registered public keys on multiple relays
-     * @param userAddress - The address of the user
-     * @param relayAddresses - Array of relay addresses
-     * @returns Array of booleans indicating if public keys are registered for each relay
-     */
-    batchCheckPubKeys(userAddress: string, relayAddresses: string[]): Promise<boolean[]>;
-    /**
-     * Get EntryPoint statistics
-     * @returns The EntryPoint statistics or null if the call fails
-     */
-    getStatistics(): Promise<EntryPointStats | null>;
-    /**
-     * Subscribe to a relay via URL
-     * @param relayUrl - The URL of the relay
-     * @param months - Number of months to subscribe for
-     * @param pubKey - The public key to register (hex string or Uint8Array)
-     * @param value - The payment amount (will be calculated if not provided)
-     * @returns The transaction response or null if the call fails
-     */
-    subscribeViaUrl(relayUrl: string, months: number, pubKey: string | Uint8Array, value?: bigint): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Subscribe directly to a relay
-     * @param relayAddress - The address of the relay
-     * @param months - Number of months to subscribe for
-     * @param pubKey - The public key to register (hex string or Uint8Array)
-     * @param value - The payment amount (will be calculated if not provided)
-     * @returns The transaction response or null if the call fails
-     */
-    subscribeDirect(relayAddress: string, months: number, pubKey: string | Uint8Array, value?: bigint): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Subscribe to multiple relays in a single transaction
-     * @param relayAddresses - Array of relay addresses
-     * @param months - Number of months to subscribe for
-     * @param pubKeys - Array of public keys (hex strings or Uint8Arrays)
-     * @param value - The payment amount (will be calculated if not provided)
-     * @returns The transaction response or null if the call fails
-     */
-    batchSubscribe(relayAddresses: string[], months: number, pubKeys: (string | Uint8Array)[], value?: bigint): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Update the registry address (owner only)
-     * @param newRegistryAddress - The new registry address
-     * @returns The transaction response or null if the call fails
-     */
-    updateRegistry(newRegistryAddress: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Update the service fee percentage (owner only)
-     * @param newFeePercentage - The new fee percentage
-     * @returns The transaction response or null if the call fails
-     */
-    updateServiceFee(newFeePercentage: number): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Withdraw accumulated fees (owner only)
-     * @returns The transaction response or null if the call fails
-     */
-    withdrawFees(): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Check if a relay is in protocol mode
-     * @param relayAddress - The address of the relay
-     * @returns True if the relay is in protocol mode, false otherwise
-     */
-    isRelayInProtocolMode(relayAddress: string): Promise<boolean>;
-}

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

@@ -1,17 +0,0 @@
-/**
- * Relay module - Provides interaction with the Shogun Protocol Relay system
- */
-export * from "./base";
-export * from "./registry";
-export * from "./relay";
-export * from "./entryPoint";
-export { EntryPoint } from "./entryPoint";
-export type { EntryPointConfig } from "./entryPoint";
-export { Registry } from "./registry";
-export type { RegistryConfig } from "./registry";
-export { SimpleRelay } from "./relay";
-export type { SimpleRelayConfig, SubscriptionInfo } from "./relay";
-export type { RelayInfo, RelayPage, RelayConfig, BaseContract, ContractConfig, SubscriptionDetails, } from "./base";
-export { getRelayUrls, getRegisteredPubKeys, getSubscriptionHistory, getRelayPerformance, getNetworkSummary, subscribeToRelayEvents, getUsageDataForChart, RelayEventType, } from "./utils";
-export type { RegisteredPubKey, GroupedPubKeys, RelayPerformance, NetworkSummary, ChartDataPoint, ChartData, RelayEvent, } from "./utils";
-export { RelayVerifier } from "./utils";

package/dist/types/contracts/registry.d.ts

@@ -1,97 +0,0 @@
-/**
- * Registry Class - Provides interaction with the Shogun Protocol Registry contract
- */
-import { ethers } from "ethers";
-import { BaseContract, ContractConfig, RelayInfo, RelayPage } from "./base";
-export interface RegistryConfig extends ContractConfig {
-}
-/**
- * Registry - A class to interact with the Shogun Protocol Registry contract
- */
-export declare class Registry extends BaseContract {
-    /**
-     * Create a new Registry instance
-     * @param config - Configuration for the Registry
-     */
-    constructor(config: RegistryConfig);
-    /**
-     * Check if a relay is registered
-     * @param relayAddress - The address of the relay to check
-     * @returns True if the relay is registered, false otherwise
-     */
-    isRegisteredRelay(relayAddress: string): Promise<boolean>;
-    /**
-     * Check if a relay is active
-     * @param relayAddress - The address of the relay to check
-     * @returns True if the relay is active, false otherwise
-     */
-    isRelayActive(relayAddress: string): Promise<boolean>;
-    /**
-     * Find a relay by its URL
-     * @param url - The URL of the relay to find
-     * @returns The address of the relay or zero address if not found
-     */
-    findRelayByUrl(url: string): Promise<string>;
-    /**
-     * Get information about a specific relay
-     * @param relayAddress - The address of the relay
-     * @returns The relay information or null if not found
-     */
-    getRelayInfo(relayAddress: string): Promise<RelayInfo | null>;
-    /**
-     * Get the number of relays owned by a specific address
-     * @param ownerAddress - The address of the owner
-     * @returns The number of relays or 0 if the call fails
-     */
-    getRelayCountByOwner(ownerAddress: string): Promise<number>;
-    /**
-     * Get relays owned by a specific address with pagination
-     * @param ownerAddress - The address of the owner
-     * @param offset - Starting index for pagination
-     * @param limit - Maximum number of items to return
-     * @returns Page of relay addresses or null if the call fails
-     */
-    getRelaysByOwner(ownerAddress: string, offset?: number, limit?: number): Promise<RelayPage | null>;
-    /**
-     * Get all relays with pagination
-     * @param onlyActive - If true, only return active relays
-     * @param offset - Starting index for pagination
-     * @param limit - Maximum number of items to return
-     * @returns Page of relay addresses or null if the call fails
-     */
-    getAllRelays(onlyActive?: boolean, offset?: number, limit?: number): Promise<RelayPage | null>;
-    /**
-     * Register a new relay
-     * @param relayAddress - The address of the relay contract
-     * @param url - The URL of the relay
-     * @param metadata - Additional metadata for the relay (JSON string)
-     * @returns The transaction response or null if the call fails
-     */
-    registerRelay(relayAddress: string, url: string, metadata: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Update relay information
-     * @param relayAddress - The address of the relay to update
-     * @param newUrl - The new URL (empty to keep current)
-     * @param newMetadata - The new metadata (empty to keep current)
-     * @returns The transaction response or null if the call fails
-     */
-    updateRelay(relayAddress: string, newUrl?: string, newMetadata?: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Deactivate a relay
-     * @param relayAddress - The address of the relay to deactivate
-     * @returns The transaction response or null if the call fails
-     */
-    deactivateRelay(relayAddress: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Reactivate a relay
-     * @param relayAddress - The address of the relay to reactivate
-     * @returns The transaction response or null if the call fails
-     */
-    reactivateRelay(relayAddress: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Set whether registration is open
-     * @param isOpen - Whether registration should be open
-     * @returns The transaction response or null if the call fails
-     */
-    setRegistrationOpen(isOpen: boolean): Promise<ethers.TransactionResponse | null>;
-}

package/dist/types/contracts/relay.d.ts

@@ -1,165 +0,0 @@
-/**
- * SimpleRelay Class - Provides interaction with the Shogun Protocol SimpleRelay contract
- */
-import { ethers } from "ethers";
-import { BaseContract, ContractConfig, RelayConfig, RelayOperatingMode, RelayModeInfo } from "./base";
-export interface SimpleRelayConfig extends ContractConfig {
-    relayAddress: string;
-}
-export interface SubscriptionInfo {
-    expires: bigint;
-    pubKey: string;
-    isActive: boolean;
-}
-/**
- * SimpleRelay - A class to interact with the Shogun Protocol SimpleRelay contract
- */
-export declare class SimpleRelay extends BaseContract {
-    /**
-     * Create a new SimpleRelay instance
-     * @param config - Configuration for the SimpleRelay
-     */
-    constructor(config: SimpleRelayConfig);
-    /**
-     * Check if a user's subscription is active
-     * @param userAddress - The address of the user
-     * @returns True if the subscription is active, false otherwise
-     */
-    isSubscriptionActive(userAddress: string): Promise<boolean>;
-    /**
-     * Get detailed subscription information for a user
-     * @param userAddress - The address of the user
-     * @returns The subscription information or null if not found
-     */
-    getUserSubscriptionInfo(userAddress: string): Promise<SubscriptionInfo | null>;
-    /**
-     * Check if a public key is authorized
-     * @param pubKey - The public key to check (hex string or Uint8Array)
-     * @returns True if the public key is authorized, false otherwise
-     */
-    isAuthorizedByPubKey(pubKey: string | Uint8Array): Promise<boolean>;
-    /**
-     * Check if a public key is subscribed (alias for isAuthorizedByPubKey)
-     * @param pubKey - The public key to check (hex string or Uint8Array)
-     * @returns True if the public key is subscribed, false otherwise
-     */
-    isSubscribed(pubKey: string | Uint8Array): Promise<boolean>;
-    /**
-     * Get the monthly subscription price
-     * @returns The price in wei or null if the call fails
-     */
-    getPricePerMonth(): Promise<bigint | null>;
-    /**
-     * Get the number of days per month used for subscription calculations
-     * @returns The days per month or null if the call fails
-     */
-    getDaysPerMonth(): Promise<number | null>;
-    /**
-     * Get the relay URL
-     * @returns The relay URL or null if the call fails
-     */
-    getRelayUrl(): Promise<string | null>;
-    /**
-     * Get complete relay operational configuration
-     * @returns The relay configuration or null if the call fails
-     */
-    getRelayOperationalConfig(): Promise<RelayConfig | null>;
-    /**
-     * Subscribe to the relay
-     * @param months - Number of months to subscribe for
-     * @param pubKey - The public key to register (hex string or Uint8Array)
-     * @returns The transaction response or null if the call fails
-     */
-    subscribe(months: number, pubKey: string | Uint8Array): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Set new price per month (owner only)
-     * @param newPrice - The new price in wei
-     * @returns The transaction response or null if the call fails
-     */
-    setPrice(newPrice: bigint): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Set new days per month for subscription calculations (owner only)
-     * @param days - The new number of days (1-31)
-     * @returns The transaction response or null if the call fails
-     */
-    setDaysPerMonth(days: number): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Update the relay URL (owner only)
-     * @param newUrl - The new URL
-     * @returns The transaction response or null if the call fails
-     */
-    updateRelayUrl(newUrl: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Withdraw accumulated funds (owner only)
-     * @returns The transaction response or null if the call fails
-     */
-    withdrawFunds(): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Decommission the relay and withdraw all funds (owner only)
-     * @returns The transaction response or null if the call fails
-     */
-    decommissionAndWithdrawAllFunds(): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Execute a generic transaction (owner only)
-     * @param to - The destination address
-     * @param value - The amount of ETH to send
-     * @param data - The calldata to send
-     * @returns The transaction response and result or null if the call fails
-     */
-    execute(to: string, value: bigint, data: string): Promise<{
-        success: boolean;
-        result: string;
-    } | null>;
-    /**
-     * Get the current operating mode of the relay
-     * @returns The operating mode (SINGLE or PROTOCOL) or null if the call fails
-     */
-    getOperatingMode(): Promise<RelayOperatingMode | null>;
-    /**
-     * Get the registry address set in the relay
-     * @returns The registry address or null if the call fails
-     */
-    getRegistryAddress(): Promise<string | null>;
-    /**
-     * Get the entry point address set in the relay
-     * @returns The entry point address or null if the call fails
-     */
-    getEntryPointAddress(): Promise<string | null>;
-    /**
-     * Check if the relay is registered in the registry
-     * @returns True if the relay is registered, false otherwise
-     */
-    isRegisteredInRegistry(): Promise<boolean>;
-    /**
-     * Get complete relay mode information
-     * @returns The relay mode information or null if the call fails
-     */
-    getRelayMode(): Promise<RelayModeInfo | null>;
-    /**
-     * Set the registry address for the relay
-     * @param registryAddress - The registry contract address
-     * @param autoRegister - Whether to automatically register the relay in the registry
-     * @param metadata - Metadata for registry registration (only used if autoRegister is true)
-     * @returns The transaction response or null if the call fails
-     */
-    setRegistry(registryAddress: string, autoRegister?: boolean, metadata?: string): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Set the entry point address for the relay
-     * @param entryPointAddress - The entry point contract address
-     * @param enableProtocolMode - Whether to enable PROTOCOL mode automatically
-     * @returns The transaction response or null if the call fails
-     */
-    setEntryPoint(entryPointAddress: string, enableProtocolMode?: boolean): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Set the operating mode for the relay
-     * @param mode - The new operating mode (SINGLE or PROTOCOL)
-     * @returns The transaction response or null if the call fails
-     */
-    setOperatingMode(mode: RelayOperatingMode): Promise<ethers.TransactionResponse | null>;
-    /**
-     * Register the relay in the registry
-     * @param metadata - Metadata for registry registration
-     * @returns The transaction response or null if the call fails
-     */
-    registerInRegistry(metadata?: string): Promise<ethers.TransactionResponse | null>;
-}

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

@@ -1,173 +0,0 @@
-/**
- * Utility functions for working with the relay system
- */
-import { Registry } from "./registry";
-import { SimpleRelay } from "./relay";
-import { EntryPoint } from "./entryPoint";
-export interface RegisteredPubKey {
-    relayAddress: string;
-    relayUrl: string;
-    pubKey: string;
-    userAddress?: string;
-    expires?: bigint;
-}
-export interface GroupedPubKeys {
-    [pubKey: string]: {
-        pubKey: string;
-        relays: {
-            relayAddress: string;
-            relayUrl: string;
-            userAddress?: string;
-            expires?: bigint;
-        }[];
-    };
-}
-export interface RelayPerformance {
-    uptime: number;
-    responseTime: number;
-    successRate: number;
-    lastChecked: string;
-}
-export interface NetworkSummary {
-    totalRelays: number;
-    activeRelays: number;
-    totalSubscriptions: number;
-    activeSubscriptions: number;
-    averagePrice: string;
-    totalProcessedAmount: string;
-    totalFeesCollected: string;
-}
-export interface ChartDataPoint {
-    label: string;
-    value: number;
-}
-export interface ChartData {
-    dataPoints: ChartDataPoint[];
-    title: string;
-    description: string;
-}
-export declare enum RelayEventType {
-    NEW_SUBSCRIPTION = "newSubscription",
-    SUBSCRIPTION_EXPIRED = "subscriptionExpired",
-    RELAY_REGISTERED = "relayRegistered",
-    RELAY_DEACTIVATED = "relayDeactivated",
-    RELAY_REACTIVATED = "relayReactivated"
-}
-export interface RelayEvent {
-    type: RelayEventType;
-    timestamp: number;
-    relayAddress?: string;
-    userAddress?: string;
-    transactionHash?: string;
-    data?: any;
-}
-/**
- * Fetch all relay URLs from the registry
- * @param registry - Registry instance
- * @param onlyActive - Whether to only fetch active relays (default: true)
- * @returns Array of relay URLs and addresses
- */
-export declare function getRelayUrls(registry: Registry, onlyActive?: boolean): Promise<Array<{
-    url: string;
-    address: string;
-}>>;
-/**
- * Retrieve all public keys registered in relays and group them
- * @param registry - Registry instance
- * @param entryPoint - EntryPoint instance
- * @param userAddresses - Optional list of user addresses to check
- * @param onlyActive - Whether to only fetch active relays (default: true)
- * @returns Grouped public keys with their associated relays
- */
-export declare function getRegisteredPubKeys(registry: Registry, entryPoint: EntryPoint, userAddresses?: string[], onlyActive?: boolean): Promise<GroupedPubKeys>;
-/**
- * Ottieni la cronologia delle sottoscrizioni nel periodo specificato
- * @param entryPoint - Istanza di EntryPoint
- * @param timeframe - Periodo di tempo ('day', 'week', 'month')
- * @returns Array di oggetti con date e conteggio sottoscrizioni
- */
-export declare function getSubscriptionHistory(entryPoint: EntryPoint, timeframe?: "day" | "week" | "month"): Promise<Array<{
-    date: string;
-    count: number;
-}>>;
-/**
- * Ottieni le metriche di performance di un relay
- * @param registry - Istanza di Registry
- * @param relayAddress - Indirizzo del relay
- * @returns Oggetto con metriche di performance
- */
-export declare function getRelayPerformance(registry: Registry, relayAddress: string): Promise<RelayPerformance>;
-/**
- * Ottiene un riepilogo di tutte le informazioni della rete relay
- * @param registry - Istanza di Registry
- * @param entryPoint - Istanza di EntryPoint
- * @returns Oggetto con statistiche di rete
- */
-export declare function getNetworkSummary(registry: Registry, entryPoint: EntryPoint): Promise<NetworkSummary>;
-/**
- * Iscriviti agli eventi dei relay
- * @param registry - Istanza di Registry
- * @param callback - Funzione di callback da eseguire quando si verifica un evento
- * @returns Funzione per annullare l'iscrizione
- */
-export declare function subscribeToRelayEvents(registry: Registry, callback: (event: RelayEvent) => void): () => void;
-/**
- * Ottieni dati per grafici relativi all'utilizzo dei relay
- * @param entryPoint - Istanza di EntryPoint
- * @param metric - Metrica da visualizzare ('subscriptions', 'revenue', 'users')
- * @param period - Periodo di tempo ('daily', 'weekly', 'monthly')
- * @returns Dati formattati per grafici
- */
-export declare function getUsageDataForChart(entryPoint: EntryPoint, metric: "subscriptions" | "revenue" | "users", period: "daily" | "weekly" | "monthly"): Promise<ChartData>;
-/**
- * Create a combined relay verifier that can check public key authorization across all contract types
- */
-export declare class RelayVerifier {
-    private registry;
-    private entryPoint;
-    private simpleRelay;
-    /**
-     * Create a new RelayVerifier
-     * @param registry - Optional Registry instance
-     * @param entryPoint - Optional EntryPoint instance
-     * @param simpleRelay - Optional SimpleRelay instance
-     */
-    constructor(registry?: Registry, entryPoint?: EntryPoint, simpleRelay?: SimpleRelay);
-    /**
-     * Check if a public key is authorized (subscribed) to any relay
-     * @param registryAddress - The address of the registry (or any value if checking directly)
-     * @param pubKey - The public key to check (hex string or Uint8Array)
-     * @returns True if the public key is authorized, false otherwise
-     */
-    isPublicKeyAuthorized(registryAddress: string, pubKey: string | Uint8Array): Promise<boolean>;
-    /**
-     * Check if a user is subscribed to a specific relay
-     * @param relayAddress - The address of the relay
-     * @param pubKey - The public key to check (hex string or Uint8Array)
-     * @returns True if the user is subscribed, false otherwise
-     */
-    isUserSubscribedToRelay(relayAddress: string, pubKey: string | Uint8Array): Promise<boolean>;
-    /**
-     * Get all relays from registry
-     * @param onlyActive - If true, only return active relays
-     * @param offset - Starting index for pagination
-     * @param limit - Maximum number of items to return
-     * @returns Array of relay addresses
-     */
-    getAllRelays(onlyActive?: boolean, offset?: number, limit?: number): Promise<string[]>;
-    /**
-     * Set registry instance
-     * @param registry - The Registry instance
-     */
-    setRegistry(registry: Registry): void;
-    /**
-     * Set entryPoint instance
-     * @param entryPoint - The EntryPoint instance
-     */
-    setEntryPoint(entryPoint: EntryPoint): void;
-    /**
-     * Set simpleRelay instance
-     * @param simpleRelay - The SimpleRelay instance
-     */
-    setSimpleRelay(simpleRelay: SimpleRelay): void;
-}