open-index/open-npm huggingface dataset:
npm package: @openworld-ui/copy-to-clipboard
Description: A React-based utility package for copying text to the clipboard, featuring a pre-built UI component and a custom hook.
Author: hexp-brne
Latest version: 1.5.1

# @openworld-ui/copy-to-clipboard

A React-based utility package for copying text to the clipboard, featuring a pre-built UI component and a custom hook.

## Installation

```bash
npm install @openworld-ui/copy-to-clipboard
# or
yarn add @openworld-ui/copy-to-clipboard
```

## Features

- **CopyButton**: A ready-to-use React component with a copy icon and toast notification.
- **useClipboard**: A custom React hook for programmatic clipboard access with state management.
- **clipboardCopy**: A low-level utility function for copying text, supporting both the Async Clipboard API and fallback mechanisms.

## Usage

### CopyButton

The `CopyButton` component provides a standard UI for copying text.

```jsx
import { CopyButton } from '@openworld-ui/copy-to-clipboard';

function App() {
  return (
    <CopyButton 
      copyValue="Text to copy" 
      label="Copy to clipboard" 
      toastText="Copied to clipboard!" 
    />
  );
}
```

#### Props

| Prop | Type | Description |
| :--- | :--- | :--- |
| `copyValue` | `string` | The text that will be copied to the clipboard. |
| `label` | `string` | Accessibility label for the button. |
| `toastText` | `string` | Message to display in the toast notification after copying. |

### useClipboard Hook

For more control over the copy behavior and UI, use the `useClipboard` hook.

```jsx
import { useClipboard } from '@openworld-ui/copy-to-clipboard';

function MyComponent() {
  const { copy, copied, isSupported } = useClipboard({
    copiedTimeout: 2000,
    onSuccess: () => console.log('Copied!'),
    onError: () => console.error('Failed to copy!')
  });

  return (
    <div>
      <button onClick={() => copy('Hello World')}>
        {copied ? 'Copied!' : 'Copy'}
      </button>
      {!isSupported() && <p>Clipboard API not supported in this browser.</p>}
    </div>
  );
}
```

#### Hook Options

- `copiedTimeout` (number): Duration (ms) for which the `copied` state remains true.
- `onSuccess` (function): Callback executed after a successful copy.
- `onError` (function): Callback executed when copying fails.
- `selectOnCopy` (boolean): If using `targetRef`, selects the text in the input/textarea on copy.

### clipboardCopy Utility

A standalone async function for copying text.

```javascript
import { clipboardCopy } from '@openworld-ui/copy-to-clipboard';

async function handleCopy() {
  try {
    await clipboardCopy('Text to copy');
    console.log('Copied successfully!');
  } catch (err) {
    console.error('Could not copy text: ', err);
  }
}
```

## Dependencies

This package requires `react` (>= 16.8).

## License

MIT
npm package: @openzeppelin/cli
Description: Command-line interface for the OpenZeppelin smart contract platform
Latest version: 2.8.2
Deprecated: The OpenZeppelin CLI is no longer being developed. For smart contract upgrades check out the OpenZeppelin Upgrades Plugins. https://zpl.in/upgrades-plugins

# OpenZeppelin SDK Command-Line Interface _(@openzeppelin/cli)_

[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg)](https://github.com/RichardLitt/standard-readme)
[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/cli.svg?style=flat-square)](https://www.npmjs.org/package/@openzeppelin/cli)
[![CircleCI](https://circleci.com/gh/OpenZeppelin/openzeppelin-sdk/tree/master.svg?style=shield)](https://circleci.com/gh/OpenZeppelin/openzeppelin-sdk/tree/master)

> Command-line interface for the OpenZeppelin smart contract platform.

OpenZeppelin SDK is a platform to develop, deploy and operate smart contract
projects on Ethereum and every other EVM and eWASM-powered blockchain.

This is the repository for the OpenZeppelin commmand-line interface, the
recommended way to use the OpenZeppelin SDK.

## Install

First, install [Node.js](http://nodejs.org/) and [npm](https://npmjs.com/).
Then, install the OpenZeppelin SDK running:

```sh
npm install --global @openzeppelin/cli
```

## Usage

To start, create a directory for the project and access it:

```sh
mkdir my-project
cd my-project
```

Use `npm` to create a `package.json` file:

```sh
npm init
```

And initialize the OpenZeppelin SDK project:

```sh
openzeppelin init my-project
```

Now it is possible to add contracts to the project with the `openzeppelin add` command,
push these contracts to a blockchain network with `openzeppelin push`, use
`openzeppelin deploy` to create instances for these contracts that later can be
upgraded, and many more things.

Run `openzeppelin --help` for more details about this and all the other functions of
the OpenZeppelin CLI.

The
[OpenZeppelin SDK documentation](https://docs.openzeppelin.com/sdk)
explains how to use the `openzeppelin` command-line interface to build a project, to
upgrade contracts and to share packages for other projects to reuse. It also
explains how to operate the project with the OpenZeppelin JavaScript libraries
instead of this `openzeppelin` command.

## Security

If you find a security issue, please contact us at security@openzeppelin.com. We
give rewards for reported issues, according to impact and severity.

## Maintainers

* [@spalladino](https://github.com/spalladino)
* [@jcarpanelli](https://github.com/jcarpanelli)
* [@ylv-io](https://github.com/ylv-io)

## Contribute

To contribute, join our
[community channel on Telegram](https://t.me/zeppelinos) where you can talk to
all the OpenZeppelin developers, contributors, partners and users.

You can also follow the recent developments of the project in our
[blog](https://blog.openzeppelin.com/) and
[Twitter account](https://twitter.com/openzeppelin).

## License

[MIT](LICENSE.md) © OpenZeppelin
npm package: @openzeppelin/contract-loader
Description: Load contract ABIs from built artifacts and return contract objects
Author: Nicolas Venturo
Latest version: 0.6.3

# OpenZeppelin Contract Loader

[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://docs.openzeppelin.com/contract-loader)
[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/contract-loader.svg)](https://www.npmjs.org/package/@openzeppelin/contract-loader)
[![Build Status](https://circleci.com/gh/OpenZeppelin/openzeppelin-contract-loader.svg?style=shield)](https://circleci.com/gh/OpenZeppelin/openzeppelin-contract-loader)

**Load contract objects from built artifacts or ABIs.** Includes support for both `web3-eth-contract` and `@truffle/contract` objects.

```javascript
const { setupLoader } = require('@openzeppelin/contract-loader');
const loader = setupLoader({ provider: new Web3('http://localhost:8545') }).web3;

const address = '0xCfEB869F69431e42cdB54A4F4f105C19C080A601';
const erc20 = loader.fromArtifact('ERC20', address);

const totalSupply = await token.methods.totalSupply().call();
```

## Overview

### Installation

```bash
npm install @openzeppelin/contract-loader
```

You may also need to install [`web3-eth-contract`](https://www.npmjs.com/package/web3-eth-contract) or [`@truffle/contract`](https://www.npmjs.com/package/@truffle/contract), depending on which abstractions you want to be able to load.

>Contract Loader requires access to the filesystem to read contract ABIs. Because of this, it will not work in a browser-based Dapp.

### Usage

Create a loader object:

```javascript
const { setupLoader } = require('@openzeppelin/contract-loader');

const loader = setupLoader({
  provider,      // either a web3 provider or a web3 instance
  defaultSender, // optional
  defaultGas,    // optional, defaults to 8 million
});
```

Load web3 contracts:

```javascript
const ERC20 = loader.web3.fromArtifact('ERC20');

// Deploy contract
const token = await ERC20.deploy().send();

// Send transactions and query state
const balance = await token.methods.balanceOf(sender).call();
await token.methods.transfer(receiver, balance).send({ from: sender });

```

Load Truffle contracts:

```javascript
const ERC20 = loader.truffle.fromArtifact('ERC20');

// Deploy contract
const token = await ERC20.new();

// Send transactions and query state
const balance = await token.balanceOf(sender);
await token.transfer(receiver, balance, { from: sender });
```

## Learn More

* For detailed usage information, take a look at the [API Reference](https://docs.openzeppelin.com/contract-loader/api).

## License

[MIT](LICENSE).
npm package: @openzeppelin/contracts-confidential
Description: [![Coverage Status](https://codecov.io/gh/OpenZeppelin/openzeppelin-confidential-contracts/graph/badge.svg?token=1OVLRTWTA9)](https://codecov.io/gh/OpenZeppelin/openzeppelin-confidential-contracts)
Author: OpenZeppelin Community
Latest version: 0.1.0
Deprecated: This package has been renamed to @openzeppelin/confidential-contracts. Install using @openzeppelin/confidential-contracts instead.
npm package: @openzeppelin/contracts-ui-builder-adapter-midnight
Description: Midnight Adapter for Contracts UI Builder
Author: Aleksandr Pasevin
Latest version: 0.9.0
Deprecated: This package has been renamed to @openzeppelin/ui-builder-adapter-midnight. Please migrate: https://www.npmjs.com/package/@openzeppelin/ui-builder-adapter-midnight

# Midnight Adapter (`@openzeppelin/contracts-ui-builder-adapter-midnight`)

This package provides the `ContractAdapter` implementation for the Midnight Network for the UI Builder.

## Current Status: Wallet Connection Implemented

This adapter has a fully implemented wallet connection feature, allowing users to connect to the Lace (Midnight) browser extension. The core contract interaction methods (`loadContract`, `formatTransactionData`, `signAndBroadcast`, etc.) are currently placeholder stubs and will be implemented in future phases.

### Key Implemented Features

- **Wallet Connection**: Supports connecting to the `mnLace` wallet instance injected into the `window` object.
- **Auto-reconnection**: Automatically reconnects to the user's wallet on page reload if they have not explicitly disconnected.
- **Robust Connection Logic**: Implements a state-polling mechanism to handle the wallet's unconventional API, which resolves before user approval and has internal race conditions.
- **Explicit Disconnect Handling**: Uses `localStorage` to respect user disconnections across sessions, which is the standard workaround for CIP-30 style wallets.
- **Custom UI Components**: Provides custom, theme-consistent `ConnectButton` and `AccountDisplay` components.

## Usage

The `MidnightAdapter` is consumed by the `builder` application's `WalletStateProvider`. It exposes a React context provider (`MidnightWalletProvider`) and a set of facade hooks that are automatically used by the main application UI.

```typescript
// In the builder application's adapter factory:
import {
  MidnightAdapter,
  midnightTestnet,
} from '@openzeppelin/contracts-ui-builder-adapter-midnight';

const networkConfig = midnightTestnet;
const midnightAdapter = new MidnightAdapter(networkConfig);
```

## Package Structure

```text
adapter-midnight/
├── src/
│   ├── config/                  # Adapter-specific configuration
│   ├── contract/                # Contract interaction utilities (placeholder)
│   ├── mapping/                 # Type mapping utilities (placeholder)
│   ├── networks/                # Midnight network configurations
│   ├── transaction/             # Transaction execution system (placeholder)
│   ├── validation/              # Validation utilities (placeholder)
│   ├── wallet/                  # Wallet integration (implemented)
│   ├── adapter.ts               # Main MidnightAdapter class implementation
│   └── index.ts                 # Public package exports
├── package.json
├── tsconfig.json
├── tsup.config.ts
├── vitest.config.ts
└── README.md
```

## Internal Structure

This adapter follows the standard module structure outlined in the main project [Adapter Architecture Guide](../../docs/ADAPTER_ARCHITECTURE.md). All wallet-related logic can be found in the `src/wallet/` directory.
npm package: @openzeppelin/contracts-ui-builder-utils
Description: Shared, framework-agnostic utility functions for the OpenZeppelin Contracts UI Builder.
Author: OpenZeppelin
Latest version: 0.9.0
Deprecated: This package has been renamed to @openzeppelin/ui-builder-utils. Please migrate: https://www.npmjs.com/package/@openzeppelin/ui-builder-utils

# @openzeppelin/contracts-ui-builder-utils

This package provides a set of shared, framework-agnostic utility functions used across the entire UI Builder ecosystem.

## Purpose

The goal of this package is to centralize common logic that is not tied to any specific blockchain adapter or UI framework (like React). This prevents code duplication and ensures that core functionalities like logging, configuration management, and ID generation are consistent everywhere.

## Key Exports

- **`AppConfigService`**: A singleton service responsible for loading and providing runtime configuration. It can load settings from Vite environment variables (for the builder app) or a `public/app.config.json` file (for exported apps), allowing for flexible configuration of RPC URLs, API keys, and other parameters.
- **`logger`**: A pre-configured singleton logger for consistent, leveled logging across all packages. It can be enabled, disabled, or have its level changed globally.
- **`generateId`**: A utility for generating unique IDs, used for form fields and other components.
- **`cn`**: A utility (a wrapper around `clsx` and `tailwind-merge`) for conditionally joining CSS class names, essential for building dynamic and themeable UI components with Tailwind CSS.
- **Type Guards and Helpers**: Various other small, reusable functions like `getDefaultValueForType`.

## Package Structure

```text
utils/
├── src/
│   ├── config/                 # Configuration management
│   ├── logger/                 # Logging utilities
│   ├── ui/                     # UI utility functions
│   ├── validation/             # Validation and type utilities
│   ├── constants/              # Shared constants
│   └── index.ts                # Main package exports
├── package.json                # Package configuration
├── tsconfig.json               # TypeScript configuration
├── tsup.config.ts              # Build configuration
├── vitest.config.ts            # Test configuration
└── README.md                   # This documentation
```

## Installation

This package is a core part of the monorepo and is automatically linked via `pnpm` workspaces. For external use, it would be installed from the project's package registry.

```bash
pnpm add @openzeppelin/contracts-ui-builder-utils
```
npm package: @openzeppelin/defender-account-client
Description: Defender Account acts as an interface to manage your account.
Author: Zeljko Markovic
Latest version: 1.54.6

# Defender Account Client

Defender Account acts as an interface to manage your account.

# End Of Support Notice

We will no longer be maintaining or supporting any additional releases for defender-client. Please migrate to defender-sdk as soon as possible to get all the benefits of defender 2.0 and more.

Please 

## Install

```bash
npm install @openzeppelin/defender-account-client
```

```bash
yarn add @openzeppelin/defender-account-client
```

## Usage

Start by creating a new _Team API Key_ in Defender, and granting it the capability to create new proposals. Use the newly created API key to initialize an instance of the Account client.

```js
const { AccountClient } = require('@openzeppelin/defender-account-client');
const client = new AccountClient({ apiKey: API_KEY, apiSecret: API_SECRET });
```

### Account Usage

To get account usages `getUsage` method can be used:

```js
await client.getUsage();
```

You can optionally set date to get usage for past period. When date is set only subset of quotas connected to the monthly usage is returned.

```js
await client.getUsage({
  date: '2023-10-01'
});
```

You can also optionally set quotas list to get usage only for desired quotas.

```js
await client.getUsage({
  quotas: ['relayers', 'relayerTxPerHour']
});
```

## FAQ

**Can I use this package in a browser?**

This package is not designed to be used in a browser environment. Using this package requires sensitive API KEYS that should not be exposed publicly.
npm package: @openzeppelin/defender-base-client
Description: OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 1.54.6
Deprecated: This package has been deprecated and will no longer be maintained, please use @openzeppelin/defender-sdk package instead.

# Defender Base Client

OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

Certain components of Defender, such as Admin or Relay, can be interacted with programmatically via an API. This library provides the base class for the clients.

# End Of Support Notice

We will no longer be maintaining or supporting any additional releases for defender-client. Please migrate to defender-sdk as soon as possible to get all the benefits of defender 2.0 and more.
npm package: @openzeppelin/defender-sdk
Description: ## ⚠️ Important Notice
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK

## ⚠️ Important Notice

> **OpenZeppelin Defender will sunset on July 1, 2026. As a result, this SDK will be deprecated and will no longer receive updates after that date.**
>
> Users are encouraged to migrate to OpenZeppelin's open source projects, including [OpenZeppelin Relayer](https://github.com/OpenZeppelin/openzeppelin-relayer) and [OpenZeppelin Monitor](https://github.com/OpenZeppelin/openzeppelin-monitor). For detailed migration instructions and guidance, please follow the [Defender Migration Guide](https://docs.openzeppelin.com/defender/migration).
>
> **Note on OZ Monitor:** While this defender-sdk includes a Defender Monitor client, OpenZeppelin Monitor (the open source version) is a standalone binary/CLI tool and does not ship with a client SDK.
>
> **OpenZeppelin Relayer SDK:** For relayer functionality, use the new [OpenZeppelin Relayer SDK](https://github.com/OpenZeppelin/openzeppelin-relayer-sdk).

---

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
npm package: @openzeppelin/defender-sdk-account-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Account Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to networks. See Examples for usage.
npm package: @openzeppelin/defender-sdk-action-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Actions Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to actions. See Examples for usage.

## Defender Actions CLI tool

In addition to the SDK APIs for managing actions, we provide a CLI tool for running, updating (code) and tail action executions logs.

### Setup

1. Install actions package globally:

`npm install -g @openzeppelin/defender-sdk-action-client`

2. Export environment variables:

```sh
# Defender API key and secret
$ export API_KEY=
$ export API_SECRET=
```

### Usage

#### Run action

```sh
$ defender-action execute-run $ACTION_ID
```

#### Update action code

```sh
$ defender-action update-code $ACTION_ID $PATH
```

#### Tail action run logs

```sh
$ defender-action tail-runs $ACTION_ID
```
npm package: @openzeppelin/defender-sdk-address-book-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Address Book Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to address book. See Examples for usage.
npm package: @openzeppelin/defender-sdk-approval-process-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Approval Process client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to Approval Processes. See Examples for usage.
npm package: @openzeppelin/defender-sdk-base-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender Base Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

Certain components of Defender, such as Monitors or Relay, can be interacted with programmatically via an API. This library provides the base class for the clients.
npm package: @openzeppelin/defender-sdk-monitor-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Monitor Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to monitoring. See Examples for usage.
npm package: @openzeppelin/defender-sdk-network-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Network Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to networks. See Examples for usage.
npm package: @openzeppelin/defender-sdk-notification-channel-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Notification Channel Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to notification channels. See Examples for usage.
npm package: @openzeppelin/defender-sdk-proposal-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Proposal Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to proposals. See Examples for usage.
npm package: @openzeppelin/defender-sdk-relay-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Relay Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to relayers. See Examples for usage.
npm package: @openzeppelin/defender-sdk-relay-group-client
Description: The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.
Author: OpenZeppelin Defender
Latest version: 2.7.1

# Defender SDK Relay Group Client

The OpenZeppelin Defender provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement Defender to ship faster and minimize security risks.

This library provides methods related to relayer groups. See Examples for usage.
npm package: @openzeppelin/docs-utils
Description: Utilities for setting up and previewing documentation across OpenZeppelin projects.
Author: Francisco Giordano
Latest version: 0.1.6

Utilities for setting up and previewing documentation across OpenZeppelin
projects.

> **This is an internal tool for OpenZeppelin projects.**
>
> If you are looking to generate documentation for your Solidity project, check
> out [`solidity-docgen`](https://github.com/OpenZeppelin/solidity-docgen).

### Initial setup (`oz-docs init`)

The `oz-docs init` command will create the necessary directories and files to
include a repo in the docs site, and to preview it with the steps in the next
section.

### Previewing the site locally (`oz-docs build`, `oz-docs watch`)

Add a dev dependency on this repo.

```
npm install --save-dev github:OpenZeppelin/docs-utils
# or yarn add --dev github:OpenZeppelin/docs-utils
```

Use the `oz-docs` executable in the package's scripts. You need to provide the
`-c` option with a path to the Antora component that you want to render (this
is the directory that contains the `antora.yml` file).

You should add two commands: `docs` and `docs:watch`. The latter should use the
`oz-docs watch [PATTERN...]` command. If some of the docs are generated by a
`prepare-docs` command, e.g., extracting them from Solidity or JavaScript
files, you should specifiy glob patterns that match the source files so that
the docs are regenerated automatically.

```diff
   "scripts": {
+    "docs": "oz-docs -c docs",
+    "docs:watch": "npm run docs watch contracts",
     "prepare-docs": "solidity-docgen -i contracts -o docs"
   },
```

### Setting up docs previews on pull requests

The above should enable local previews of the docs. It's also useful to set up
docs previews on pull requests. This is done using Netlify Deploy Previews.

Create a `netlify.toml` file at the root of the repo with the following contents.
(The command and the path may be slightly different for monorepos or repos using
yarn.)

```toml
[build]
command = "npm run docs"
publish = "build/site"
```

Then create a Netlify site connected to the repository. Deploy Previews for the
`master` branch are enabled by default.

You will want to disable the Netlify's checks on pull requests, since they are
only useful for production sites. In the site settings on Netlify, go to "Build
& Deploy", and at the bottom of the page go to "Deploy notifications". Delete
the three notifications that say "rich details".
npm package: @openzeppelin/fuzzy-solidity-import-parser
Description: This is an experiment in optimizing the parsing of Solidity files when the sole purpose is to get dependencies before sending it off to `solc` to compile. Thus, we rely on the compiler to detect any syntax errors, and in that case the library can return "
Author: OpenZeppelin
Latest version: 0.1.2

# Fuzzy Solidity Import Parser

This is an experiment in optimizing the parsing of Solidity files when the sole
purpose is to get dependencies before sending it off to `solc` to compile.
Thus, we rely on the compiler to detect any syntax errors, and in that case the
library can return "false positives". The user of this library is meant to
ignore errors when reading files from disk, and let the compiler report them.
npm package: @openzeppelin/gsn-helpers
Description: Test and development helper methods and scripts for GSN
Latest version: 0.2.4
Deprecated: This project is deprecated. We are no longer actively developing new features nor addressing issues. Head to the readme for more information.

:warning: This project is **deprecated**. All development on the GSN has been moved to the [OpenGSN](https://github.com/opengsn) organization. Please refer to the [OpenGSN localgsn implementation](https://github.com/opengsn/localgsn). We won't be developing new features nor addressing issues. Read [here](https://forum.openzeppelin.com/t/doubling-down-in-security/2712) for more info.

# OpenZeppelin GSN Helpers

[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/gsn-helpers.svg)](https://www.npmjs.org/package/@openzeppelin/gsn-helpers)

**Helper functions and scripts for using the Gas Station Network**. Develop and test your GSN application with minimal setup.

Provides methods for:

 * Deploying a `RelayHub` instance
 * Funding a recipient
 * Query a recipient's or relayer owner's GSN balance
 * Running and registering a relayer
 * Withdrawing a relayer's revenue

## Overview

### Installation

```console
$ npm install @openzeppelin/gsn-helpers
```

### Usage

The GSN Helpers come in two flavors: a command-line interface and a JavaScript library, providing high flexibility.

The following samples show how to use each to deploy the `RelayHub` contract, fund a recipient and then start a relayer server.

#### Using the CLI

```console
$ npx oz-gsn deploy-relay-hub --ethereumNodeURL http://localhost:8545
Deploying singleton RelayHub instance
RelayHub deployed at 0xd216153c06e857cd7f72665e0af1d7d82172f494

$ npx oz-gsn fund-recipient --recipient <address> --amount 50000000
Recipient <address> balance is now 50000000 wei

$ npx oz-gsn run-relayer --ethereumNodeURL http://localhost:8545 --quiet
Starting relayer
~/.cache/gsn-nodejs/gsn-relay-v0.2.1
 -EthereumNodeUrl http://localhost:8545
 -RelayHubAddress 0xd216153c06e857cd7f72665e0af1d7d82172f494
 -Port 8090
 -Url http://localhost:8090
Relay is funded and ready!
```

#### Using the JavaScript library

```javascript
const {
  deployRelayHub,
  runRelayer,
  fundRecipient,
} = require('@openzeppelin/gsn-helpers');

const web3 = new Web3('http://localhost:8545');

await deployRelayHub(web3);

await runRelayer(web3, { quiet: true });

await fundRecipient(web3, { recipient: <address>, amount: 50000000 });
```

NOTE: All of these actions require a [local blockchain](https://github.com/trufflesuite/ganache-cli/) to be running in the background on port 8545.

## Learn More

 * Head to [Preparing a Testing Environment](https://docs.openzeppelin.com/gsn-helpers/preparing-a-testing-environment) to quickstart your project with ready-to-use GSN setup scripts.
 * For detailed usage information, take a look at the [API Reference](https://docs.openzeppelin.com/gsn-helpers/api).

## License

The MIT License.
npm package: @openzeppelin/gsn-provider
Description: Web3 provider for GSN
Author: santiago@openzeppelin.com
Latest version: 0.1.11
Deprecated: This project is deprecated. We are no longer actively developing new features nor addressing issues. Head to the readme for more information.

:warning: This project is **deprecated**. All development on the GSN has been moved to the [OpenGSN](https://github.com/opengsn) organization. Please refer to the [OpenGSN provider implementation](https://github.com/opengsn/gsn/tree/master/src/relayclient) (GSNv1 version [here](https://github.com/opengsn/gsn/tree/GSNv1/src/js/relayclient)). We won't be developing new features nor addressing issues. Read [here](https://forum.openzeppelin.com/t/doubling-down-in-security/2712) for more info.

# OpenZeppelin GSN Provider

[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/gsn-provider.svg)](https://www.npmjs.org/package/@openzeppelin/gsn-provider)
[![Build Status](https://circleci.com/gh/OpenZeppelin/openzeppelin-gsn-provider.svg?style=shield)](https://circleci.com/gh/OpenZeppelin/openzeppelin-gsn-provider)

# GSN Provider

**A web3.js compatible provider for sending transactions via the Gas Station Network (GSN)**. This package wraps a modified version of the [`RelayClient`](https://github.com/tabookey/tabookey-gasless/blob/master/src/js/relayclient/RelayClient.js) from `tabookey-gasless` with a custom web3 Provider.

## Overview

### Installation

```console
$ npm install @openzeppelin/gsn-provider
```

### Usage

Create a `GSNProvider` and use it as the provider for your web3 instance:

```javascript
const Web3 = require("web3");
const { GSNProvider } = require("@openzeppelin/gsn-provider");

const web3 = new Web3(new GSNProvider("http://localhost:8545"));
```

Transactions sent to contracts will then be automatically routed through the GSN:

```javascript
const myContract = new web3.eth.Contract(abi, address);

// Sends the transaction via the GSN
await myContract.methods.myFunction().send({ from });

// Disable GSN for a specific transaction
await myContract.methods.myFunction().send({ from, useGSN: false });
```

## Learn More

* Check out [Getting Started](https://docs.openzeppelin.com/gsn-provider/getting-started) to use GSN Provider in a new project.
* The [Testing GSN Applications](https://docs.openzeppelin.com/gsn-provider/testing-gsn-applications) will teach you how to test your project locally.
* For detailed usage information, take a look at the [API Reference](https://docs.openzeppelin.com/gsn-provider/api).


## License

Released under the MIT License.
npm package: @openzeppelin/hardhat-upgrades
Description: [![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://docs.openzeppelin.com/upgrades-plugins/hardhat-upgrades) [![NPM Package](https://img.shields.io/npm/v/@openzeppelin/hardhat-upgrades.svg)](https://www.npmjs.org/package/@openzeppelin/h
Latest version: 3.9.1
npm package: @openzeppelin/platform-sdk
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
npm package: @openzeppelin/platform-sdk-action-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Actions Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to actions. See Examples for usage.
npm package: @openzeppelin/platform-sdk-base-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform Base Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

Certain components of the Platform, such as Monitors or Relay, can be interacted with programmatically via an API. This library provides the base class for the clients.
npm package: @openzeppelin/platform-sdk-monitor-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Monitor Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to monitoring. See Examples for usage.
npm package: @openzeppelin/platform-sdk-notification-channel-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Notification Channel Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to notification channels. See Examples for usage.
npm package: @openzeppelin/platform-sdk-proposal-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Proposal Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to proposals. See Examples for usage.
npm package: @openzeppelin/platform-sdk-relay-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Relay Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to relayers. See Examples for usage.
npm package: @openzeppelin/platform-sdk-relay-signer-client
Description: The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.
Author: OpenZeppelin Platform
Latest version: 0.4.0

# Platform SDK Relay Signer Client

The OpenZeppelin Platform provides a security operations (SecOps) platform for Ethereum with built-in best practices. Development teams implement the Platform to ship faster and minimize security risks.

This library provides methods related to relayers transactions. See Examples for usage.
npm package: @openzeppelin/psm-client
Description: TypeScript HTTP client for Private State Manager (PSM) server
Latest version: 0.13.1

# @openzeppelin/psm-client

TypeScript HTTP client for Private State Manager (PSM) server.

## Installation

```bash
npm install @openzeppelin/psm-client
```

## Setup

```typescript
import { PsmHttpClient } from '@openzeppelin/psm-client';

const client = new PsmHttpClient('http://localhost:3000');
```

## Usage

### Get Server Public Key (Unauthenticated)

```typescript
// Default (Falcon)
const { commitment, pubkey } = await client.getPubkey();

// ECDSA
const { commitment, pubkey } = await client.getPubkey('ecdsa');
```

### Set Signer for Authenticated Requests

All endpoints except `getPubkey()` require authentication. You must provide a signer that implements the `Signer` interface:

```typescript
import type { Signer, SignatureScheme } from '@openzeppelin/psm-client';

const signer: Signer = {
  commitment: '0x...',
  publicKey: '0x...',
  scheme: 'falcon' as SignatureScheme, // 'falcon' or 'ecdsa'
  signAccountIdWithTimestamp: async (accountId: string, timestamp: number) => '0x...',
  signCommitment: async (commitmentHex: string) => '0x...',
};

client.setSigner(signer);
```

### Configure an Account

```typescript
await client.configure({
  account_id: '0x...',
  auth: {
    MidenFalconRpo: {
      cosigner_commitments: ['0x...', '0x...'],
    },
  },
  initial_state: { data: '<base64-encoded-account>', account_id: '0x...' },
});
```

### Get Account State

```typescript
const state = await client.getState(accountId);
console.log('Commitment:', state.commitment);
console.log('State data:', state.state_json.data);
```

### Work with Delta Proposals

```typescript
// Get all proposals for an account
const proposals = await client.getDeltaProposals(accountId);

// Push a new proposal
const response = await client.pushDeltaProposal({
  account_id: accountId,
  nonce: 1,
  delta_payload: {
    tx_summary: { data: '<base64-tx-summary>' },
    signatures: [],
  },
});

// Sign a proposal
const delta = await client.signDeltaProposal({
  account_id: accountId,
  commitment: response.commitment,
  signature: { scheme: 'falcon', signature: '0x...' },
});

// Execute a proposal
const result = await client.pushDelta({
  account_id: accountId,
  nonce: 1,
  prev_commitment: '0x...',
  delta_payload: { data: '<base64-tx-summary>' },
  status: { status: 'pending', timestamp: '...', proposer_id: '0x...', cosigner_sigs: [] },
});
```

### Get Deltas

```typescript
// Get specific delta by nonce
const delta = await client.getDelta(accountId, 5);

// Get merged delta since a nonce
const merged = await client.getDeltaSince(accountId, 3);
```

## Error Handling

The client throws `PsmHttpError` for non-2xx responses:

```typescript
import { PsmHttpError } from '@openzeppelin/psm-client';

try {
  await client.getState(accountId);
} catch (error) {
  if (error instanceof PsmHttpError) {
    console.error(`HTTP ${error.status}: ${error.statusText}`);
    console.error('Body:', error.body);
  }
}
```

## Testing

```bash
npm test           # Run tests once
npm run test:watch # Run tests in watch mode
```
npm package: @openzeppelin/solidity-loader
Description: Webpack Solidity Hot Loader
Author: Igor Yalovoy
Latest version: 1.5.1

# solidity-loader

Works well with [OpenZeppelin SKD](https://openzeppelin.com/sdk/) and [Starter Kit](https://openzeppelin.com/start/).

#### Features

- Allows importing .sol files directly into source code.
- Allows to specify contract name for .sol files, like require("Contract.sol?contract=Counter").
- Tracks dependencies for contracts, so children are updated when parents are modified.
- Converts .sol files into .json using `compile oz`, `oz push`, and `oz update`.
- Uses only development network so won't run on any other networks.
- You can set the development network name using the loader's config.
- Handles race conditions at Webpack pipeline using a lock.
- Pulls build directory from truffle config.
- In case oz commands are not available, uses cached versions of .json files.
- Reports errors to console output and dev tools.
- Compilation can be disabled using the loader's disabled config.

#### Import example

```
Counter = require("../../contracts/Counter.sol");
Wallet = require("../../contracts/Wallet.sol");
```

#### Config sample

```
{
    test: /.sol$/,
    use: [
    { loader: 'json-loader' },
    {
        loader: '@openzeppelin/solidity-loader',
        options: {
            network: 'development',
            disabled: false,
            }
         },
      },
    ],
}
```
npm package: @openzeppelin/test-env
Description: One line smart contracts test environment.
Author: Francisco Giordano
Latest version: 0.2.1
Deprecated: @openzeppelin/test-env is an early alpha release and has been deprecated, use @openzeppelin/test-environment instead.

# OpenZeppelin Test Env

[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/test-env.svg)](https://www.npmjs.org/package/@openzeppelin/test-env)
[![Build Status](https://circleci.com/gh/OpenZeppelin/openzeppelin-test-env.svg?style=shield)](https://circleci.com/gh/OpenZeppelin/openzeppelin-test-env)

## License

Released under the MIT License.
npm package: @openzeppelin/uniswap-hooks
Description: Solidity library for secure and modular Uniswap hooks.
Author: OpenZeppelin
Latest version: 1.1.1

# <img src="logo.svg" alt="Uniswap Hooks" height="40px">

[![Coverage Status](https://codecov.io/gh/OpenZeppelin/uniswap-hooks/graph/badge.svg)](https://codecov.io/gh/OpenZeppelin/uniswap-hooks)
[![CI](https://github.com/OpenZeppelin/uniswap-hooks/actions/workflows/checks.yml/badge.svg)](https://github.com/OpenZeppelin/uniswap-hooks/actions/workflows/checks.yml)

Solidity library for secure and modular Uniswap hooks.

> [!WARNING]
> This is **experimental software** and is provided on an "as is" and "as available" basis. We **do not give any warranties** and **will not be liable for any losses** incurred through any use of this code base. Read the [disclaimer](#disclaimer) for more information.

## Overview

### Installation

#### Foundry

> [!WARNING]
> Foundry installs the latest version initially, but subsequent `forge update` commands will use the `master` branch.

```
$ forge install OpenZeppelin/uniswap-hooks
```

Add `@openzeppelin/uniswap-hooks/=lib/uniswap-hooks/src/` in `remappings.txt`.
#### Hardhat

Not currently supported given that Uniswap v4 core and periphery contracts are not yet npm packages.

## Contribute

There are many ways you can participate and help build high quality software. Check out the [contribution guide](CONTRIBUTING.md)!

## License

OpenZeppelin Uniswap Hooks is released under the [MIT License](LICENSE).

## Legal

Your use of this Project is governed by the terms found at www.openzeppelin.com/tos (the "Terms").

## Disclaimer

The hook code provided herein is offered on an “as-is” basis and has not been audited for security, reliability, or compliance with any specific standards or regulations. It may contain bugs, errors, or vulnerabilities that could lead to unintended consequences. By utilizing these hooks, you acknowledge and agree that:

- Assumption of Risk: You assume all responsibility and risks associated with its use.
- No Warranty: The authors and distributors of this code disclaim all warranties, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, and non-infringement.
- Limitation of Liability: In no event shall the authors or distributors be held liable for any damages or losses, including but not limited to direct, indirect, incidental, or consequential damages arising out of or in connection with the use or inability to use the code.

Recommendation: Users are strongly encouraged to review, test, and, if necessary, audit the hooks independently before deploying in any environment.

By proceeding to utilize these hooks, you indicate your understanding and acceptance of this disclaimer.