sdk-blockchain-circuits-ts 1.0.0

package/CIRCUITS_MANAGER_USAGE.md

@@ -0,0 +1,222 @@
+# CircuitsManager Usage Guide
+
+## Overview
+
+`CircuitsManager` is a TypeScript class that provides a convenient wrapper around the Circuits smart contract. It simplifies interactions with the contract by providing type-safe methods for all contract operations.
+
+## Installation
+
+The `CircuitsManager` is automatically exported from the fidelity-sdk package:
+
+```typescript
+import { CircuitsManager } from "sdk-blockchain-fidelity-ts";
+```
+
+## Basic Setup
+
+```typescript
+import { ethers } from "ethers";
+import { CircuitsManager } from "sdk-blockchain-fidelity-ts";
+
+// Get your provider and signer
+const provider = new ethers.providers.JsonRpcProvider("http://localhost:8545");
+const wallet = new ethers.Wallet("0x...", provider);
+
+// Create a CircuitsManager instance
+const circuitsAddress = "0x..."; // Your deployed Circuits contract address
+const manager = new CircuitsManager(circuitsAddress, wallet);
+```
+
+## Common Operations
+
+### Circuit Management
+
+```typescript
+// Create a new circuit (requires CIRCUIT_ADMIN_ROLE)
+const createTx = await manager.createCircuit();
+await createTx.wait();
+
+// Change circuit status
+await manager.changeCircuitStatus(1, 0); // circuitId=1, status=0
+
+// Check if a circuit is active
+const isActive = await manager.isCircuitActive(1);
+console.log("Circuit 1 is active:", isActive);
+
+// Get total number of circuits
+const count = await manager.getNumberOfCircuits();
+console.log("Total circuits:", count.toNumber());
+
+// Get all circuit IDs
+const circuitIds = await manager.getCircuits();
+console.log("Circuit IDs:", circuitIds.map(id => id.toNumber()));
+
+// Get circuit size (number of participants)
+const size = await manager.getCircuitSize(1);
+console.log("Circuit 1 size:", size.toNumber());
+```
+
+### User Management
+
+```typescript
+// Register a user (requires CIRCUIT_ADMIN_ROLE)
+const userAddress = "0x...";
+await manager.registerUser(1, userAddress);
+
+// Deactivate a user (requires CIRCUIT_ADMIN_ROLE)
+await manager.deactivateUser(1);
+
+// Check if user is registered
+const isRegistered = await manager.isRegistered(1);
+console.log("User 1 is registered:", isRegistered);
+
+// Get user's current circuit
+const userCircuit = await manager.getUserCircuit(1);
+console.log("User 1's circuit:", userCircuit.toNumber());
+```
+
+### Circuit Participation
+
+```typescript
+// Join a circuit
+const joinTx = await manager.joinCircuit(1, 1); // userId=1, circuitId=1
+await joinTx.wait();
+
+// Leave circuit
+const leaveTx = await manager.leaveCircuit(1); // userId=1
+await leaveTx.wait();
+
+// Check if user is in a specific circuit
+const isInCircuit = await manager.isRegisteredToCircuit(1, 1);
+console.log("User 1 is in circuit 1:", isInCircuit);
+
+// Get participants of a circuit
+const participants = await manager.getCircuitPartecipants(1);
+console.log("Circuit 1 participants:", participants.map(id => id.toNumber()));
+
+// Get participants with status
+const participantsWithStatus = await manager.getCircuitPartecipantsAndStatus(1);
+console.log("Participants with status:", participantsWithStatus);
+
+// Get single participant details
+const participant = await manager.getPartecipant(1);
+console.log("Participant 1:", participant);
+```
+
+### Governance
+
+```typescript
+// Create a proposal
+const proposeTx = await manager.propose(
+  2,    // userAffected
+  1,    // proposerId
+  1,    // circuitId
+  0     // proposalType (0=remove, 1=ban, etc.)
+);
+await proposeTx.wait();
+
+// Cast a vote
+const voteTx = await manager.castVote(1, 0); // userId=1, proposalId=0
+await voteTx.wait();
+
+// Remove a vote
+const removeVoteTx = await manager.removeVote(1, 0);
+await removeVoteTx.wait();
+
+// Close a proposal
+const closeTx = await manager.closePropose(1, 0); // userId=1, proposalId=0
+await closeTx.wait();
+
+// Check if proposal passed
+const passed = await manager.isVotationPassed(0); // proposalId=0
+console.log("Proposal 0 passed:", passed);
+
+// Get all participants and proposals for all circuits
+const allParticipants = await manager.getAllCircuitPartecipantsAndStatus();
+console.log("All participants:", allParticipants);
+```
+
+### Advanced Operations
+
+```typescript
+// Get the underlying contract instance (for advanced operations)
+const contract = manager.getContract();
+
+// Get the contract address
+const address = manager.getContractAddress();
+
+// Get current signer
+const signer = manager.getSigner();
+
+// Switch to a different signer (useful for multi-user scenarios)
+const newSigner = new ethers.Wallet("0x...", provider);
+manager.setSigner(newSigner);
+```
+
+## Transaction Handling
+
+All write operations return transaction objects. Use them with:
+
+```typescript
+const tx = await manager.joinCircuit(1, 1);
+
+// Wait for confirmation
+const receipt = await tx.wait();
+console.log("Transaction confirmed:", receipt.transactionHash);
+
+// Or access tx details directly
+console.log("Tx hash:", tx.hash);
+console.log("Tx from:", tx.from);
+```
+
+## Error Handling
+
+```typescript
+try {
+  await manager.joinCircuit(1, 1);
+} catch (error) {
+  if (error.code === "CALL_EXCEPTION") {
+    console.log("Contract execution failed:", error.reason);
+  } else if (error.code === "INSUFFICIENT_FUNDS") {
+    console.log("Not enough funds for transaction");
+  }
+}
+```
+
+## Roles and Permissions
+
+The Circuits contract uses role-based access control (RBAC):
+
+- **DEFAULT_ADMIN_ROLE**: Can grant/revoke roles
+- **DEVELOPER_ROLE**: For developers
+- **CIRCUIT_ADMIN_ROLE**: Can create circuits, register/deactivate users
+
+Most write operations require specific roles. Check contract requirements before calling.
+
+## TypeScript Support
+
+All methods are fully typed:
+
+```typescript
+// Type hints are automatically available
+const circuitSize: BigNumber = await manager.getCircuitSize(1);
+const participants: BigNumber[] = await manager.getCircuitPartecipants(1);
+const participant: ICircuits.PartecipantStruct = await manager.getPartecipant(1);
+```
+
+## Integration with Hardhat
+
+If using with Hardhat:
+
+```typescript
+import { ethers } from "hardhat";
+import { CircuitsManager } from "sdk-blockchain-fidelity-ts";
+
+export async function main() {
+  const [deployer] = await ethers.getSigners();
+  const circuits = "0x...";
+
+  const manager = new CircuitsManager(circuits, deployer);
+  await manager.createCircuit();
+}
+```

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024 OmniaGroup
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,386 @@
+# sdk-blockchain-circuits-ts
+
+[![npm version](https://img.shields.io/badge/npm-v1.0.0-blue)](https://www.npmjs.com/package/sdk-blockchain-circuits-ts)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue)](https://www.typescriptlang.org/)
+[![License: ISC](https://img.shields.io/badge/License-ISC-green.svg)](LICENSE)
+
+> TypeScript SDK for interacting with the Fidelity Project smart contracts. Provides a type-safe interface for managing circuits, users, and decentralized governance on Ethereum-compatible blockchains.
+
+## Features
+
+✅ **Circuit Management** - Create, activate, and manage circuits with full lifecycle control
+✅ **User Management** - Activate, deactivate, and manage users in the system
+✅ **Circuit Participation** - Join and leave circuits with comprehensive tracking
+✅ **Governance System** - Propose, vote on, and execute governance actions
+✅ **Role-Based Access Control** - RBAC for administrative operations
+✅ **Type Safety** - Full TypeScript support with generated contract bindings
+✅ **Comprehensive Testing** - 58+ test cases across 6 test suites
+✅ **Well Documented** - Complete API documentation and usage examples
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [API Reference](#api-reference)
+- [Usage Examples](#usage-examples)
+- [Error Handling](#error-handling)
+- [Testing](#testing)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+npm install sdk-blockchain-circuits-ts
+```
+
+### Prerequisites
+
+- Node.js 14.0.0 or higher
+- npm 6.0.0 or higher
+- TypeScript 5.0+
+- Access to an Ethereum-compatible blockchain (local node, testnet, or mainnet)
+
+---
+
+## Quick Start
+
+```typescript
+import { ethers } from "ethers";
+import { CircuitsManager } from "sdk-blockchain-circuits-ts";
+
+// Setup provider and wallet
+const provider = new ethers.providers.JsonRpcProvider("http://localhost:8545");
+const wallet = new ethers.Wallet("0x...", provider);
+
+// Initialize CircuitsManager
+const circuitsAddress = "0x..."; // Your deployed Circuits contract address
+const manager = new CircuitsManager(circuitsAddress, wallet);
+
+// Get circuit information
+const count = await manager.getNumberOfCircuits();
+console.log(`Total circuits: ${count.toNumber()}`);
+
+// Check if a circuit is active
+const isActive = await manager.isCircuitActive(1);
+console.log(`Circuit 1 is active: ${isActive}`);
+```
+
+---
+
+## API Reference
+
+### CircuitsManager
+
+The primary class for interacting with the Circuits smart contract.
+
+#### Constructor
+
+```typescript
+constructor(contractAddress: string, signer: Signer)
+```
+
+#### Circuit Management
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `createCircuit()` | - | Transaction | Create a new circuit (requires CIRCUIT_ADMIN_ROLE) |
+| `changeCircuitStatus(circuitId, status)` | `number, number` | Transaction | Change circuit status |
+| `isCircuitActive(circuitId)` | `number` | `boolean` | Check if circuit is active |
+| `getNumberOfCircuits()` | - | `BigNumber` | Get total number of circuits |
+| `getCircuits()` | - | `BigNumber[]` | Get all circuit IDs |
+| `getCircuitSize(circuitId)` | `number` | `BigNumber` | Get number of participants |
+
+#### User Management
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `activateUser(userId, userAddress)` | `number, string` | Transaction | Activate a user (requires CIRCUIT_ADMIN_ROLE) |
+| `deactivateUser(userId)` | `number` | Transaction | Deactivate a user |
+| `isRegistered(userId)` | `number` | `boolean` | Check if user is registered |
+| `getUserCircuit(userId)` | `number` | `BigNumber` | Get user's current circuit |
+
+#### Circuit Participation
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `joinCircuit(userId, circuitId)` | `number, number` | Transaction | Join a circuit |
+| `leaveCircuit(userId)` | `number` | Transaction | Leave current circuit |
+| `isRegisteredToCircuit(userId, circuitId)` | `number, number` | `boolean` | Check circuit membership |
+| `getCircuitPartecipants(circuitId)` | `number` | `BigNumber[]` | Get all participants |
+| `getCircuitPartecipantsAndStatus(circuitId)` | `number` | `object[]` | Get participants with status |
+| `getPartecipant(userId)` | `number` | `ICircuits.PartecipantStruct` | Get participant details |
+
+#### Governance
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `propose(userAffected, proposerId, circuitId, proposalType)` | `number, number, number, number` | Transaction | Create a proposal |
+| `castVote(userId, proposalId)` | `number, number` | Transaction | Cast a vote |
+| `removeVote(userId, proposalId)` | `number, number` | Transaction | Remove a vote |
+| `closePropose(userId, proposalId)` | `number, number` | Transaction | Close a proposal |
+| `isVotationPassed(proposalId)` | `number` | `boolean` | Check if proposal passed |
+| `getAllCircuitPartecipantsAndStatus()` | - | `object[]` | Get all participants across circuits |
+
+#### Utility Methods
+
+| Method | Parameters | Returns | Description |
+|--------|-----------|---------|-------------|
+| `getContract()` | - | `Circuits` | Get underlying contract instance |
+| `getContractAddress()` | - | `string` | Get contract address |
+| `getSigner()` | - | `Signer` | Get current signer |
+| `setSigner(newSigner)` | `Signer` | `void` | Switch to different signer |
+
+---
+
+## Usage Examples
+
+### Circuit Management
+
+```typescript
+// Create a new circuit (requires CIRCUIT_ADMIN_ROLE)
+const createTx = await manager.createCircuit();
+await createTx.wait();
+
+// Change circuit status
+await manager.changeCircuitStatus(1, 0); // circuitId=1, status=0
+
+// Get all circuit IDs
+const circuitIds = await manager.getCircuits();
+console.log("Circuit IDs:", circuitIds.map(id => id.toNumber()));
+
+// Check circuit size
+const size = await manager.getCircuitSize(1);
+console.log("Circuit 1 has", size.toNumber(), "participants");
+```
+
+### User Management
+
+```typescript
+// Activate a new user
+const userAddress = "0x1234567890123456789012345678901234567890";
+const activateTx = await manager.activateUser(1, userAddress);
+await activateTx.wait();
+
+// Check user registration status
+const userId = 1;
+const isRegistered = await manager.isRegistered(userId);
+console.log(`User ${userId} is registered:`, isRegistered);
+
+// Get user information
+const participant = await manager.getPartecipant(userId);
+console.log("Participant info:", participant);
+```
+
+### Circuit Participation
+
+```typescript
+// Join a circuit
+const joinTx = await manager.joinCircuit(1, 1); // userId=1, circuitId=1
+await joinTx.wait();
+
+// Check if user is in circuit
+const isInCircuit = await manager.isRegisteredToCircuit(1, 1);
+console.log("User is in circuit:", isInCircuit);
+
+// Get all participants
+const participants = await manager.getCircuitPartecipants(1);
+console.log("Participants:", participants.map(id => id.toNumber()));
+
+// Leave circuit
+const leaveTx = await manager.leaveCircuit(1);
+await leaveTx.wait();
+```
+
+### Governance
+
+```typescript
+// Create a proposal
+const proposeTx = await manager.propose(
+  2,    // userAffected
+  1,    // proposerId
+  1,    // circuitId
+  0     // proposalType (0=remove, 1=ban, etc.)
+);
+await proposeTx.wait();
+
+// Cast a vote
+const voteTx = await manager.castVote(1, 0); // userId=1, proposalId=0
+await voteTx.wait();
+
+// Check if proposal passed
+const passed = await manager.isVotationPassed(0);
+console.log("Proposal 0 passed:", passed);
+
+// Close a proposal
+const closeTx = await manager.closePropose(1, 0);
+await closeTx.wait();
+```
+
+---
+
+## Error Handling
+
+```typescript
+try {
+  await manager.joinCircuit(1, 1);
+} catch (error) {
+  if (error.code === "CALL_EXCEPTION") {
+    console.error("Contract execution failed:", error.reason);
+  } else if (error.code === "INSUFFICIENT_FUNDS") {
+    console.error("Insufficient funds for transaction");
+  } else if (error.message.includes("AccessControl")) {
+    console.error("Access denied: check user roles");
+  } else {
+    console.error("Unknown error:", error.message);
+  }
+}
+```
+
+---
+
+## Role-Based Access Control
+
+The contract uses role-based access control (RBAC):
+
+- **DEFAULT_ADMIN_ROLE** - Can grant/revoke roles
+- **DEVELOPER_ROLE** - For developers
+- **CIRCUIT_ADMIN_ROLE** - Can create circuits, manage users
+
+Check that your signer has the necessary roles before calling restricted operations.
+
+---
+
+## Testing
+
+The SDK includes a comprehensive test suite:
+
+```bash
+# Run all tests
+npm run test_all
+
+# Run specific test suites
+npm run test_circuits_manager       # Basic CircuitsManager tests
+npm run test_advanced              # Advanced circuit operations
+npm run test_governance            # Governance operations
+npm run test_governance_integration # Governance integration
+npm run test_integration           # Full integration tests
+npm run test_edge_cases            # Edge case handling
+```
+
+Test coverage includes:
+- Circuit lifecycle management
+- User registration and activation
+- Circuit participation flows
+- Governance proposal workflows
+- Role-based access control
+- Edge cases and error handling
+
+---
+
+## Documentation
+
+For detailed documentation and advanced usage, see:
+
+- **[CircuitsManager Usage Guide](CIRCUITS_MANAGER_USAGE.md)** - Complete API reference with examples
+- **[Test Suite Documentation](TEST_SUITE.md)** - Overview of all test cases
+- **[Running Tests Guide](TEST_RUNNING.md)** - Guide for running and debugging tests
+- **[Quick Start Guide](RUN_TESTS_QUICK_START.md)** - Get started quickly
+
+---
+
+## Project Structure
+
+```
+packages/fidelity-sdk/
+├── src/
+│   ├── CircuitsManager.ts      # Main SDK class
+│   └── index.ts                # Package exports
+├── typechain/                  # Auto-generated contract types
+├── test/                       # Test suites
+│   ├── CircuitsManager.spec.ts
+│   ├── CircuitsManager.Advanced.spec.ts
+│   ├── Governance.spec.ts
+│   ├── GovernanceIntegration.spec.ts
+│   ├── Integration.spec.ts
+│   └── EdgeCases.spec.ts
+├── build/                      # Compiled JavaScript (generated)
+├── tsconfig.json              # TypeScript configuration
+├── package.json               # Package metadata
+└── README.md                  # This file
+```
+
+---
+
+## Building
+
+```bash
+# Install dependencies
+npm install
+
+# Compile TypeScript to JavaScript
+npm run compile
+
+# Build for npm publishing
+npm run prepublishOnly
+```
+
+---
+
+## TypeScript Support
+
+Full TypeScript support with auto-generated types:
+
+```typescript
+import { CircuitsManager } from "sdk-blockchain-circuits-ts";
+import { BigNumber } from "ethers";
+
+const manager = new CircuitsManager(address, signer);
+
+// Full type inference
+const size: BigNumber = await manager.getCircuitSize(1);
+const ids: BigNumber[] = await manager.getCircuits();
+const isActive: boolean = await manager.isCircuitActive(1);
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+
+1. All tests pass (`npm run test_all`)
+2. Code follows the existing style
+3. New features include tests
+4. Documentation is updated
+5. TypeScript types are properly maintained
+
+---
+
+## License
+
+ISC License - see [LICENSE](LICENSE) file for details.
+
+---
+
+## Repository
+
+- **Git**: [https://bitbucket.org/omniadev/sdk-blockchain-fidelity-ts.git](https://bitbucket.org/omniadev/sdk-blockchain-fidelity-ts.git)
+- **Issues**: [https://bitbucket.org/omniadev/sdk-blockchain-fidelity-ts/issues](https://bitbucket.org/omniadev/sdk-blockchain-fidelity-ts/issues)
+
+---
+
+## Author
+
+**OmniaGroup**
+
+---
+
+## Support
+
+For questions and support, please open an issue in the repository.

package/build/index.d.ts

@@ -0,0 +1,60 @@
+import type * as openzeppelin from "./@openzeppelin";
+export type { openzeppelin };
+import type * as contracts from "./contracts";
+export type { contracts };
+import type * as linkedlistSolidity from "./linkedlist-solidity";
+export type { linkedlistSolidity };
+export * as factories from "./factories";
+export type { OwnableUpgradeable } from "./@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable";
+export { OwnableUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory";
+export type { Initializable } from "./@openzeppelin/contracts-upgradeable/proxy/utils/Initializable";
+export { Initializable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory";
+export type { ContextUpgradeable } from "./@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable";
+export { ContextUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory";
+export type { AccessControl } from "./@openzeppelin/contracts/access/AccessControl";
+export { AccessControl__factory } from "./factories/@openzeppelin/contracts/access/AccessControl__factory";
+export type { IAccessControl } from "./@openzeppelin/contracts/access/IAccessControl";
+export { IAccessControl__factory } from "./factories/@openzeppelin/contracts/access/IAccessControl__factory";
+export type { ERC165 } from "./@openzeppelin/contracts/utils/introspection/ERC165";
+export { ERC165__factory } from "./factories/@openzeppelin/contracts/utils/introspection/ERC165__factory";
+export type { IERC165 } from "./@openzeppelin/contracts/utils/introspection/IERC165";
+export { IERC165__factory } from "./factories/@openzeppelin/contracts/utils/introspection/IERC165__factory";
+export type { CircuitConnector } from "./contracts/CircuitConnector";
+export { CircuitConnector__factory } from "./factories/contracts/CircuitConnector__factory";
+export type { CircuitGovernance } from "./contracts/CircuitGovernance";
+export { CircuitGovernance__factory } from "./factories/contracts/CircuitGovernance__factory";
+export type { Circuits } from "./contracts/Circuits";
+export { Circuits__factory } from "./factories/contracts/Circuits__factory";
+export type { ICircuitGovernance } from "./contracts/ICircuitGovernance";
+export { ICircuitGovernance__factory } from "./factories/contracts/ICircuitGovernance__factory";
+export type { ICircuits } from "./contracts/ICircuits";
+export { ICircuits__factory } from "./factories/contracts/ICircuits__factory";
+export type { UserManagement } from "./contracts/UserManagement";
+export { UserManagement__factory } from "./factories/contracts/UserManagement__factory";
+export type { ListConst } from "./linkedlist-solidity/contracts/Constant/ListConst";
+export { ListConst__factory } from "./factories/linkedlist-solidity/contracts/Constant/ListConst__factory";
+export type { CheapLinkedList } from "./linkedlist-solidity/contracts/DoublyLinked/CheapLinkedList/CheapLinkedList";
+export { CheapLinkedList__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/CheapLinkedList/CheapLinkedList__factory";
+export type { LinkedList } from "./linkedlist-solidity/contracts/DoublyLinked/LinkedList/LinkedList";
+export { LinkedList__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/LinkedList/LinkedList__factory";
+export type { LinkedListClass } from "./linkedlist-solidity/contracts/DoublyLinked/LinkedList/LinkedListClass";
+export { LinkedListClass__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/LinkedList/LinkedListClass__factory";
+export type { DoublyListHandler } from "./linkedlist-solidity/contracts/DoublyLinked/ListHandler/DoublyListHandler";
+export { DoublyListHandler__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/ListHandler/DoublyListHandler__factory";
+export type { ListOfLinkedList } from "./linkedlist-solidity/contracts/DoublyLinked/ListOfLinkedList/ListOfLinkedList";
+export { ListOfLinkedList__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/ListOfLinkedList/ListOfLinkedList__factory";
+export type { MapOfLinkedList } from "./linkedlist-solidity/contracts/DoublyLinked/MapOfLinkedList/MapOfLinkedList";
+export { MapOfLinkedList__factory } from "./factories/linkedlist-solidity/contracts/DoublyLinked/MapOfLinkedList/MapOfLinkedList__factory";
+export type { ILinkedListClass } from "./linkedlist-solidity/contracts/Interfaces/Classes/ILinkedListClass";
+export { ILinkedListClass__factory } from "./factories/linkedlist-solidity/contracts/Interfaces/Classes/ILinkedListClass__factory";
+export type { ICheapLinkedList } from "./linkedlist-solidity/contracts/Interfaces/ICheapLinkedList";
+export { ICheapLinkedList__factory } from "./factories/linkedlist-solidity/contracts/Interfaces/ICheapLinkedList__factory";
+export type { ILinkedList } from "./linkedlist-solidity/contracts/Interfaces/ILinkedList";
+export { ILinkedList__factory } from "./factories/linkedlist-solidity/contracts/Interfaces/ILinkedList__factory";
+export type { IListOfLinkedList } from "./linkedlist-solidity/contracts/Interfaces/IListOfLinkedList";
+export { IListOfLinkedList__factory } from "./factories/linkedlist-solidity/contracts/Interfaces/IListOfLinkedList__factory";
+export type { SinglyListHandler } from "./linkedlist-solidity/contracts/SinglyLinked/ListHandler/SinglyListHandler";
+export { SinglyListHandler__factory } from "./factories/linkedlist-solidity/contracts/SinglyLinked/ListHandler/SinglyListHandler__factory";
+export type { LinkedListUtility } from "./linkedlist-solidity/contracts/Utility/LinkedListUtility";
+export { LinkedListUtility__factory } from "./factories/linkedlist-solidity/contracts/Utility/LinkedListUtility__factory";
+export { CircuitsManager } from "./src/CircuitsManager";