shogun-core 1.2.7 → 1.2.8

package/dist/contracts/base.js

@@ -1,152 +0,0 @@
-"use strict";
-/**
- * Shogun Protocol Contracts SDK
- * This file provides interfaces and ABIs for interacting with the Shogun Protocol smart contracts
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseContract = exports.ENTRY_POINT_ABI = exports.SIMPLE_RELAY_ABI = exports.REGISTRY_ABI = exports.RelayOperatingMode = void 0;
-const ethers_1 = require("ethers");
-const errorHandler_1 = require("../utils/errorHandler");
-const logger_1 = require("../utils/logger");
-// ABI for the Registry contract
-const REGISTRY_ABI = [
-    // Read functions
-    "function isRegisteredRelay(address _relayAddress) external view returns (bool)",
-    "function isRelayActive(address _relayAddress) external view returns (bool)",
-    "function findRelayByUrl(string calldata _url) external view returns (address)",
-    "function getRelayInfo(address _relayAddress) external view returns (address owner, string memory url, string memory metadata, uint256 registrationTime, bool active)",
-    "function getRelayCountByOwner(address _owner) external view returns (uint256)",
-    "function getRelaysByOwner(address _owner, uint256 _offset, uint256 _limit) external view returns (tuple(address[] relays, uint256 total, uint256 offset, uint256 limit))",
-    "function getAllRelays(bool _onlyActive, uint256 _offset, uint256 _limit) external view returns (tuple(address[] relays, uint256 total, uint256 offset, uint256 limit))",
-    // Write functions
-    "function registerRelay(address _relayAddress, string calldata _url, string calldata _metadata) external",
-    "function updateRelay(address _relayAddress, string calldata _newUrl, string calldata _newMetadata) external",
-    "function deactivateRelay(address _relayAddress) external",
-    "function reactivateRelay(address _relayAddress) external",
-    "function setRegistrationOpen(bool _isOpen) external",
-];
-exports.REGISTRY_ABI = REGISTRY_ABI;
-// ABI for the SimpleRelay contract
-const SIMPLE_RELAY_ABI = [
-    // Read functions
-    "function isSubscriptionActive(address _user) external view returns (bool)",
-    "function getUserSubscriptionInfo(address _user) external view returns (uint256 expires, bytes memory pubKey)",
-    "function isAuthorizedByPubKey(bytes calldata _pubKey) external view returns (bool)",
-    "function isSubscribed(bytes calldata _pubKey) external view returns (bool)",
-    "function pricePerMonth() external view returns (uint256)",
-    "function daysPerMonth() external view returns (uint256)",
-    "function relayUrl() external view returns (string)",
-    "function getRelayOperationalConfig() external view returns (string memory _url, uint256 _price, uint256 _daysInMonth)",
-    // Protocol Integration functions
-    "function mode() external view returns (uint8)",
-    "function registryAddress() external view returns (address)",
-    "function entryPointAddress() external view returns (address)",
-    "function isRegisteredInRegistry() external view returns (bool)",
-    "function getRelayMode() external view returns (uint8 _mode, address _registry, address _entryPoint, bool _isRegistered)",
-    // Protocol Integration write functions
-    "function setRegistry(address _registryAddress, bool _autoRegister, string calldata _metadata) external",
-    "function setEntryPoint(address _entryPointAddress, bool _enableProtocolMode) external",
-    "function setOperatingMode(uint8 _newMode) external",
-    "function registerInRegistry(string calldata _metadata) external",
-    // Write functions
-    "function subscribe(uint256 _months, bytes calldata _pubKey) external payable",
-    "function setPrice(uint256 _newPrice) external",
-    "function setDaysPerMonth(uint256 _days) external",
-    "function updateRelayUrl(string calldata _newUrl) external",
-    "function withdrawFunds() external",
-    "function decommissionAndWithdrawAllFunds() external",
-    "function execute(address _to, uint256 _value, bytes calldata _data) external returns (bool success, bytes memory result)",
-];
-exports.SIMPLE_RELAY_ABI = SIMPLE_RELAY_ABI;
-// ABI for the EntryPoint contract
-const ENTRY_POINT_ABI = [
-    // Read functions
-    "function registry() external view returns (address)",
-    "function serviceFeePercentage() external view returns (uint256)",
-    "function calculateFee(uint256 _amount) external view returns (uint256)",
-    "function checkSubscription(address _user, address _relayAddress) external view returns (bool)",
-    "function hasRegisteredPubKey(address _user, address _relayAddress) external view returns (bool)",
-    "function isPubKeySubscribed(address _relayAddress, bytes calldata _pubKey) external view returns (bool)",
-    "function batchCheckPubKeySubscription(address[] calldata _relayAddresses, bytes[] calldata _pubKeys) external view returns (bool[] memory)",
-    "function getSubscriptionDetails(address _user, address _relayAddress) external view returns (uint256 expires, bytes memory pubKey)",
-    "function batchCheckSubscriptions(address _user, address[] calldata _relayAddresses) external view returns (bool[] memory)",
-    "function batchCheckPubKeys(address _user, address[] calldata _relayAddresses) external view returns (bool[] memory)",
-    "function getStatistics() external view returns (uint256 _userCount, uint256 _totalSubscriptions, uint256 _totalViaUrl, uint256 _totalViaDirect, uint256 _totalAmountProcessed, uint256 _totalFeesCollected, uint256 _currentBalance)",
-    // Write functions
-    "function subscribeViaUrl(string calldata _relayUrl, uint256 _months, bytes calldata _pubKey) external payable",
-    "function subscribeDirect(address _relayAddress, uint256 _months, bytes calldata _pubKey) external payable",
-    "function batchSubscribe(address[] calldata _relayAddresses, uint256 _months, bytes[] calldata _pubKeys) external payable",
-    "function updateRegistry(address _newRegistry) external",
-    "function updateServiceFee(uint256 _newFeePercentage) external",
-    "function withdrawFees() external",
-];
-exports.ENTRY_POINT_ABI = ENTRY_POINT_ABI;
-// Enum for Relay operating mode
-var RelayOperatingMode;
-(function (RelayOperatingMode) {
-    RelayOperatingMode[RelayOperatingMode["SINGLE"] = 0] = "SINGLE";
-    RelayOperatingMode[RelayOperatingMode["PROTOCOL"] = 1] = "PROTOCOL";
-})(RelayOperatingMode || (exports.RelayOperatingMode = RelayOperatingMode = {}));
-// Base class for contract interactions
-class BaseContract {
-    provider = null;
-    signer = null;
-    contract = null;
-    contractAddress;
-    constructor(address, abi, config) {
-        this.contractAddress = address;
-        // Setup provider
-        if (config.provider) {
-            this.provider = config.provider;
-        }
-        else if (config.providerUrl) {
-            this.provider = new ethers_1.ethers.JsonRpcProvider(config.providerUrl);
-        }
-        // Setup signer
-        this.signer = config.signer || null;
-        // Initialize contract
-        if (!this.provider) {
-            (0, logger_1.logError)("No provider available for contract initialization");
-            return;
-        }
-        try {
-            if (this.signer) {
-                this.contract = new ethers_1.ethers.Contract(address, abi, this.signer);
-            }
-            else {
-                this.contract = new ethers_1.ethers.Contract(address, abi, this.provider);
-            }
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "CONTRACT_INIT_FAILED", `Failed to initialize contract at ${address}`, error);
-        }
-    }
-    /**
-     * Set a new provider
-     * @param provider - The new provider
-     */
-    setProvider(provider) {
-        this.provider = provider;
-        if (this.contract) {
-            this.contract = this.contract.connect(provider);
-        }
-    }
-    /**
-     * Set a new signer
-     * @param signer - The new signer
-     */
-    setSigner(signer) {
-        this.signer = signer;
-        if (this.contract && this.signer) {
-            this.contract = this.contract.connect(signer);
-        }
-    }
-    /**
-     * Get the contract address
-     * @returns The contract address
-     */
-    getAddress() {
-        return this.contractAddress;
-    }
-}
-exports.BaseContract = BaseContract;

package/dist/contracts/entryPoint.js

@@ -1,407 +0,0 @@
-"use strict";
-/**
- * EntryPoint Class - Provides interaction with the Shogun Protocol EntryPoint contract
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntryPoint = void 0;
-const ethers_1 = require("ethers");
-const errorHandler_1 = require("../utils/errorHandler");
-const base_1 = require("./base");
-/**
- * EntryPoint - A class to interact with the Shogun Protocol EntryPoint contract
- */
-class EntryPoint extends base_1.BaseContract {
-    /**
-     * Create a new EntryPoint instance
-     * @param config - Configuration for the EntryPoint
-     */
-    constructor(config) {
-        super(config.entryPointAddress, base_1.ENTRY_POINT_ABI, config);
-    }
-    /**
-     * Get the registry address
-     * @returns The registry address or null if the call fails
-     */
-    async getRegistryAddress() {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.registry();
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_GET_REGISTRY_FAILED", "Failed to get registry address", error);
-            return null;
-        }
-    }
-    /**
-     * Get the service fee percentage
-     * @returns The fee percentage or null if the call fails
-     */
-    async getServiceFeePercentage() {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            const feePercentage = await this.contract.serviceFeePercentage();
-            return Number(feePercentage);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_GET_FEE_PERCENTAGE_FAILED", "Failed to get service fee percentage", error);
-            return null;
-        }
-    }
-    /**
-     * Calculate fee amount
-     * @param amount - The amount to calculate fee on
-     * @returns The fee amount or null if the call fails
-     */
-    async calculateFee(amount) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.calculateFee(amount);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_CALCULATE_FEE_FAILED", "Failed to calculate fee", error);
-            return 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
-     */
-    async checkSubscription(userAddress, relayAddress) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.checkSubscription(userAddress, relayAddress);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_CHECK_SUBSCRIPTION_FAILED", `Failed to check subscription for user ${userAddress} on relay ${relayAddress}`, error);
-            return false;
-        }
-    }
-    /**
-     * 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
-     */
-    async hasRegisteredPubKey(userAddress, relayAddress) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.hasRegisteredPubKey(userAddress, relayAddress);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_HAS_REGISTERED_PUBKEY_FAILED", `Failed to check if user ${userAddress} has registered pubkey on relay ${relayAddress}`, error);
-            return false;
-        }
-    }
-    /**
-     * 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
-     */
-    async isPubKeySubscribed(relayAddress, pubKey) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            // Convert Uint8Array to hex string if needed
-            const pubKeyHex = pubKey instanceof Uint8Array ? ethers_1.ethers.hexlify(pubKey) : pubKey;
-            return await this.contract.isPubKeySubscribed(relayAddress, pubKeyHex);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_IS_PUBKEY_SUBSCRIBED_FAILED", `Failed to check if pubkey is subscribed on relay ${relayAddress}`, error);
-            return false;
-        }
-    }
-    /**
-     * 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
-     */
-    async batchCheckPubKeySubscription(relayAddresses, pubKeys) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (relayAddresses.length !== pubKeys.length) {
-                throw new Error("Array lengths must match");
-            }
-            // Convert Uint8Arrays to hex strings
-            const pubKeyHexes = pubKeys.map((pk) => pk instanceof Uint8Array ? ethers_1.ethers.hexlify(pk) : pk);
-            return await this.contract.batchCheckPubKeySubscription(relayAddresses, pubKeyHexes);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_BATCH_CHECK_PUBKEYS_FAILED", "Failed to batch check public key subscriptions", error);
-            return Array(relayAddresses.length).fill(false);
-        }
-    }
-    /**
-     * 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
-     */
-    async getSubscriptionDetails(userAddress, relayAddress) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            const [expires, pubKey] = await this.contract.getSubscriptionDetails(userAddress, relayAddress);
-            return {
-                expires,
-                pubKey: ethers_1.ethers.hexlify(pubKey),
-            };
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_GET_SUBSCRIPTION_DETAILS_FAILED", `Failed to get subscription details for user ${userAddress} on relay ${relayAddress}`, error);
-            return 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
-     */
-    async batchCheckSubscriptions(userAddress, relayAddresses) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.batchCheckSubscriptions(userAddress, relayAddresses);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_BATCH_CHECK_SUBSCRIPTIONS_FAILED", `Failed to batch check subscriptions for user ${userAddress}`, error);
-            return Array(relayAddresses.length).fill(false);
-        }
-    }
-    /**
-     * 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
-     */
-    async batchCheckPubKeys(userAddress, relayAddresses) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            return await this.contract.batchCheckPubKeys(userAddress, relayAddresses);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_BATCH_CHECK_PUBKEYS_FAILED", `Failed to batch check pubkeys for user ${userAddress}`, error);
-            return Array(relayAddresses.length).fill(false);
-        }
-    }
-    /**
-     * Get EntryPoint statistics
-     * @returns The EntryPoint statistics or null if the call fails
-     */
-    async getStatistics() {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            const [userCount, totalSubscriptions, totalViaUrl, totalViaDirect, totalAmountProcessed, totalFeesCollected, currentBalance,] = await this.contract.getStatistics();
-            return {
-                userCount,
-                totalSubscriptions,
-                totalViaUrl,
-                totalViaDirect,
-                totalAmountProcessed,
-                totalFeesCollected,
-                currentBalance,
-            };
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_GET_STATISTICS_FAILED", "Failed to get EntryPoint statistics", error);
-            return 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
-     */
-    async subscribeViaUrl(relayUrl, months, pubKey, value) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            // Convert Uint8Array to hex string if needed
-            const pubKeyHex = pubKey instanceof Uint8Array ? ethers_1.ethers.hexlify(pubKey) : pubKey;
-            // If value is not provided, we need to query the correct amount
-            // This is a simplified estimation and may not be accurate
-            // In production, you would need to get the price from the relay and add the service fee
-            const txOptions = {
-                value: value || ethers_1.ethers.parseEther("0.01"), // Default value as a placeholder
-            };
-            return await this.contract.subscribeViaUrl(relayUrl, months, pubKeyHex, txOptions);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_SUBSCRIBE_VIA_URL_FAILED", `Failed to subscribe via URL ${relayUrl} for ${months} months`, error);
-            return 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
-     */
-    async subscribeDirect(relayAddress, months, pubKey, value) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            // Convert Uint8Array to hex string if needed
-            const pubKeyHex = pubKey instanceof Uint8Array ? ethers_1.ethers.hexlify(pubKey) : pubKey;
-            // If value is not provided, we need to query the correct amount
-            // This is a simplified estimation and may not be accurate
-            // In production, you would need to get the price from the relay and add the service fee
-            const txOptions = {
-                value: value || ethers_1.ethers.parseEther("0.01"), // Default value as a placeholder
-            };
-            return await this.contract.subscribeDirect(relayAddress, months, pubKeyHex, txOptions);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_SUBSCRIBE_DIRECT_FAILED", `Failed to subscribe directly to relay ${relayAddress} for ${months} months`, error);
-            return 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
-     */
-    async batchSubscribe(relayAddresses, months, pubKeys, value) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            if (relayAddresses.length !== pubKeys.length) {
-                throw new Error("Array lengths must match");
-            }
-            // Convert Uint8Arrays to hex strings
-            const pubKeyHexes = pubKeys.map((pk) => pk instanceof Uint8Array ? ethers_1.ethers.hexlify(pk) : pk);
-            // If value is not provided, we need to query the correct amount
-            // This is a simplified estimation and may not be accurate
-            // In production, you would need to calculate based on all relay prices and service fees
-            const txOptions = {
-                value: value || ethers_1.ethers.parseEther("0.01") * BigInt(relayAddresses.length),
-            };
-            return await this.contract.batchSubscribe(relayAddresses, months, pubKeyHexes, txOptions);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_BATCH_SUBSCRIBE_FAILED", `Failed to batch subscribe to ${relayAddresses.length} relays for ${months} months`, error);
-            return null;
-        }
-    }
-    /**
-     * Update the registry address (owner only)
-     * @param newRegistryAddress - The new registry address
-     * @returns The transaction response or null if the call fails
-     */
-    async updateRegistry(newRegistryAddress) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            return await this.contract.updateRegistry(newRegistryAddress);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_UPDATE_REGISTRY_FAILED", `Failed to update registry to ${newRegistryAddress}`, error);
-            return null;
-        }
-    }
-    /**
-     * Update the service fee percentage (owner only)
-     * @param newFeePercentage - The new fee percentage
-     * @returns The transaction response or null if the call fails
-     */
-    async updateServiceFee(newFeePercentage) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            return await this.contract.updateServiceFee(newFeePercentage);
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_UPDATE_SERVICE_FEE_FAILED", `Failed to update service fee to ${newFeePercentage}`, error);
-            return null;
-        }
-    }
-    /**
-     * Withdraw accumulated fees (owner only)
-     * @returns The transaction response or null if the call fails
-     */
-    async withdrawFees() {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            if (!this.signer) {
-                throw new Error("Signer required for this operation");
-            }
-            return await this.contract.withdrawFees();
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_WITHDRAW_FEES_FAILED", "Failed to withdraw fees", error);
-            return 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
-     */
-    async isRelayInProtocolMode(relayAddress) {
-        try {
-            if (!this.contract) {
-                throw new Error("EntryPoint contract not initialized");
-            }
-            const mode = await this.contract.isRelayInProtocolMode(relayAddress);
-            return mode === 1; // 1 is PROTOCOL
-        }
-        catch (error) {
-            errorHandler_1.ErrorHandler.handle(errorHandler_1.ErrorType.CONTRACT, "ENTRY_POINT_IS_RELAY_IN_PROTOCOL_MODE_FAILED", `Failed to check if relay ${relayAddress} is in protocol mode`, error);
-            return false;
-        }
-    }
-}
-exports.EntryPoint = EntryPoint;

package/dist/contracts/index.js

@@ -1,47 +0,0 @@
-"use strict";
-/**
- * Relay module - Provides interaction with the Shogun Protocol Relay system
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelayVerifier = exports.RelayEventType = exports.getUsageDataForChart = exports.subscribeToRelayEvents = exports.getNetworkSummary = exports.getRelayPerformance = exports.getSubscriptionHistory = exports.getRegisteredPubKeys = exports.getRelayUrls = exports.SimpleRelay = exports.Registry = exports.EntryPoint = void 0;
-// Export all relay SDK components
-// Contract interfaces and ABIs
-__exportStar(require("./base"), exports);
-// Registry functionality
-__exportStar(require("./registry"), exports);
-// SimpleRelay functionality
-__exportStar(require("./relay"), exports);
-// EntryPoint functionality
-__exportStar(require("./entryPoint"), exports);
-var entryPoint_1 = require("./entryPoint");
-Object.defineProperty(exports, "EntryPoint", { enumerable: true, get: function () { return entryPoint_1.EntryPoint; } });
-var registry_1 = require("./registry");
-Object.defineProperty(exports, "Registry", { enumerable: true, get: function () { return registry_1.Registry; } });
-var relay_1 = require("./relay");
-Object.defineProperty(exports, "SimpleRelay", { enumerable: true, get: function () { return relay_1.SimpleRelay; } });
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "getRelayUrls", { enumerable: true, get: function () { return utils_1.getRelayUrls; } });
-Object.defineProperty(exports, "getRegisteredPubKeys", { enumerable: true, get: function () { return utils_1.getRegisteredPubKeys; } });
-Object.defineProperty(exports, "getSubscriptionHistory", { enumerable: true, get: function () { return utils_1.getSubscriptionHistory; } });
-Object.defineProperty(exports, "getRelayPerformance", { enumerable: true, get: function () { return utils_1.getRelayPerformance; } });
-Object.defineProperty(exports, "getNetworkSummary", { enumerable: true, get: function () { return utils_1.getNetworkSummary; } });
-Object.defineProperty(exports, "subscribeToRelayEvents", { enumerable: true, get: function () { return utils_1.subscribeToRelayEvents; } });
-Object.defineProperty(exports, "getUsageDataForChart", { enumerable: true, get: function () { return utils_1.getUsageDataForChart; } });
-Object.defineProperty(exports, "RelayEventType", { enumerable: true, get: function () { return utils_1.RelayEventType; } });
-// Export contract relationships to handle the protocol integration
-var utils_2 = require("./utils");
-Object.defineProperty(exports, "RelayVerifier", { enumerable: true, get: function () { return utils_2.RelayVerifier; } });