open-index/open-npm huggingface dataset:
npm package: @nftearth/sdk
Description: Reservoir Protocol SDK
Latest version: 0.0.329

Reservoir Universal NFT SDK:

- [Typescript SDK](https://github.com/reservoirprotocol/core/tree/main/packages/sdk/src) > Interact with 15+ NFT protocols through a normalized interface
- [Router Contract](https://github.com/reservoirprotocol/core/tree/main/packages/contracts/contracts/router) > Batch purchases NFTs + more advanced functionality

Docs coming soon!
npm package: @nftearth/uniswap-multicall
Description: A React  ̶+̶ ̶R̶e̶d̶u̶x̶ lib for fetching and caching chain state via the MultiCall contract
Latest version: 1.2.2

# MultiCall

A React   ̶+̶ ̶R̶e̶d̶u̶x̶ library for fetching, batching, and caching chain state via the MultiCall contract.

## Setup

`yarn add @nftearth/uniswap-multicall` or `npm install @nftearth/uniswap-multicall`

## Usage

The usage of this library is similar to [RTK Query](https://redux-toolkit.js.org/rtk-query/overview#create-an-api-slice).

```jsx
import { MulticallProvider } from '@nftearth/uniswap-multicall'

reactDOM.render(
  <MulticallProvider />
)
```

To use the provider, you'll need an instance of the Uniswap Multicall2 contract:

```js
import { abi as MulticallABI } from '@uniswap/v3-periphery/artifacts/contracts/lens/UniswapInterfaceMulticall.sol/UniswapInterfaceMulticall.json'
import { Contract } from '@ethersproject/contracts'
import { UniswapInterfaceMulticall } from './abi/types'

const multicall2Contract = new Contract(address, MulticallABI, provider) as UniswapInterfaceMulticall
```

For a more detailed example, see basic example app in `./integration-tests`

## Alpha software

The latest version of the SDK is used in production in the Uniswap Interface,
but it is considered Alpha software and may contain bugs or change significantly between patch versions.
If you have questions about how to use the SDK, please reach out in the `#dev-chat` channel of the Discord.
Pull requests welcome!
npm package: @nftechie/smart-rpc
Description: Intelligent transport layer for Solana RPCs.
Latest version: 1.0.15

[![npm][npm-image]][npm-url]
[![npm-downloads][npm-downloads-image]][npm-url]
<br />
[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]

[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
[code-style-prettier-url]: https://github.com/prettier/prettier
[npm-downloads-image]: https://img.shields.io/npm/dm/@nftechie/smart-rpc.svg?style=flat
[npm-image]: https://img.shields.io/npm/v/@nftechie/smart-rpc.svg?style=flat
[npm-url]: https://www.npmjs.com/package/@nftechie/smart-rpc

# Solana Smart RPC

Intelligent transport layer for Solana RPCs that handles load balancing, rate limit throttling, failover, fanouts, and retries. Built on top of [@solana/web3.js](https://www.npmjs.com/package/@solana/web3.js).

# Example Usage

```tsx
import { TransportManager, TransportConfig } from '@nftechie/smart-rpc';

let transports: TransportConfig[] = [
    {
        rate_limit: 50,
        weight: 50,
        blacklist: [],
        url: 'https://bold-winter-brook.solana-mainnet.quiknode.pro/039710b0695699c8b2849d5903a9735260339476/',
        enable_smart_disable: false,
        enable_failover: false,
        max_retries: 0,
    },
    {
        rate_limit: 50,
        weight: 50,
        blacklist: ['getTokenLargestAccounts'],
        url: 'https://api.mainnet-beta.solana.com',
        enable_smart_disable: true,
        enable_failover: true,
        max_retries: 0,
    }
];

const transportManager = new TransportManager(transports);
const smartConnection = transportManager.smartConnection;

const resp = await smartConnection.getLatestBlockhash();
console.log(resp.blockhash.toString());
```
npm package: @nfteyez/sol-rayz-react
Description: React hooks to fetch NFTs on Solana.
Author: NftEyez Team
Latest version: 0.10.2

# @nfteyez/sol-rayz-react

React hooks to fetch NFTs on Solana.

## Install

You need install `@solana/web3.js` in your project, since it is used as peer dependency.

```
npm i @solana/web3.js
npm i @nfteyez/sol-rayz-react

```

## How to use

`useWalletNfts` - returns parsed list of NFTs (SPL Tokens) for given wallet public address. Each item in array have all data specified on the blockchain. The NFT metadata stored separately, you need to pick `uri` property for each token and fetch data youself.

```javascript
import { useWalletNfts } from "@nfteyez/sol-rayz-react";
import type { Options } from "@nfteyez/sol-rayz";

const MyAwesomeGallery = () => {
  const { nfts, isLoading, error } = useWalletNfts({
    publicAddress: walletPublicKey,
    // pass your connection object to use specific RPC node
    connection,
  }: Options);

  if (error) return <div>Have some error</div>
  if (isLoading) return <div>Loading...</div>
  
  return (
    <div>Wallet have {nfts?.length} NFTs</div>
  ))
}

```

`Options` is the same type used used in `"@nfteyez/sol-rayz"` for `getParsedNftAccountsByOwner` method:

```javascript
// only `publicAddress` is required
export type Options = {
  /**
   * Wallet public address
   */
  publicAddress: StringPublicKey,
  /**
   * Optionally provide your own connection object.
   * Otherwise createConnectionConfig() will be used
   */
  connection?: Connection,
  /**
   * Remove possible rust's empty string symbols `\x00` from the values,
   * which is very common issue.
   * Default is true
   */
  sanitize?: boolean,
  /**
   * TODO: Add description within README and link here
   * Default is false - slow method
   * true - is fast method
   */
  strictNftStandard?: boolean,
  /**
   * Convert all PublicKey objects to string versions.
   * Default is true
   */
  stringifyPubKeys?: boolean,
  /**
   * Sort tokens by Update Authority (read by Collection)
   * Default is true
   */
  sort?: boolean,
};
```
npm package: @nftfyorg/antd-theme-vars
Description: Since Ant Design does not have a way to handle theme switch. This package will scan your theme folder and generate css and theme vars to override your less variables.
Author: welliton gervickas
Latest version: 0.3.3

# Antd Theme Vars

Since Ant Design does not have a way to handle theme switch.
This package will scan your theme folder and generate css and theme vars to override your less variables.

## How it works:

### Theme files
dark.less
```less
@primary-color: #000000;
```

light.less
```less
@primary-color: #AAAAAA;
```

Output theme.css:
```css
.light {
  --primary-color: #AAAAAA;
}

.dark {
  --primary-color: #000000;
}
```

Output theme.vars:
```js
{
  ['primary-color']: 'var(--primary-color);'
}
```

## How to use
### Create your theme files .less with only variables
- src/themes/dark.less
- src/themes/light.less


**example**: src/themes/dark.less
```less
@primary-color: red; // primary color for all components
@gray-1: #ffffff;
@gray-2: #fafafa;
@gray-3: #f5f5f5;
@gray-4: #f0f0f0;
@gray-5: #d9d9d9;
@gray-6: #bfbfbf;
@gray-7: #8c8c8c;
@gray-8: #595959;
@gray-9: #434343;
@gray-10: #262626;
```

## Create your theme.config.json on root folder
```
{
  "themesPath": "src/themes"
}
```

## Update your next.config.js
```js
const withLess = require('next-with-less')

// only server side
const { theme } = require('antd-theme-vars')

// ...

const nextConfig = {
  // ...
  publicRuntimeConfig: {
    theme: theme.vars // optionally only if you want to use available vars on client-side.
  },
  // ....
}

// ...

module.exports = withLess({
  ...nextConfig,
  lessLoaderOptions: {
    // it will add your themes by context, eg: .dark { --primary-color: red; } .light { --primary-color: yellow; }
    additionalData: theme.css,
    lessOptions: {
      // it will modify less vars, eg: { ['primary-color']: '--var(--primary-color)' }
      modifyVars: theme.vars,
      javascriptEnabled: true,
    }
  }
})

...
```

## Create your theme switcher with Styled Components
**example**: src/themes/Theme.tsx
```jsx
import getConfig from 'next/config';
import { ReactNode, useState } from 'react';
import { ThemeProvider as StyledThemeProvider } from 'styled-components';

export interface ThemeProviderProps {
  children: ReactNode
}

export function ThemeProvider({ children }: ThemeProviderProps) {
  const { publicRuntimeConfig } = getConfig()
  const [dark, setIsDark] = useState(false)

  return (
    <StyledThemeProvider theme={publicRuntimeConfig.theme || {}}>
      <div className={dark ? 'dark': 'light'}>
        <button onClick={() => setIsDark(!dark)}>Toggle theme</button>
        {children}
      </div>
    </StyledThemeProvider>
  )
}
```
npm package: @nftfyorg/design-system
Description: DEPRECATED NFTfy Design System, DONT USE
Author: Arthur Ribeiro
Latest version: 0.4.4

# Nftfy Design System

Components and theme definitions for Nftfy products' Design System

## Commands

```bash
npm start # or yarn start
```

This builds to `/dist` and runs the project in watch mode so any edits you save inside `src` causes a rebuild to `/dist`.

Then run either Storybook or the example playground:

### Storybook

Run inside another terminal:

```bash
yarn storybook
```

This loads the stories from `./stories`.

> NOTE: Stories should reference the components as if using the library, similar to the example playground. This means importing from the root project directory. This has been aliased in the tsconfig and the storybook webpack config as a helper.

### Example

Then run the example inside another:

```bash
cd example
npm i # or yarn to install dependencies
npm start # or yarn start
```

To do a one-off build, use `npm run build` or `yarn build`.

To run tests, use `npm test` or `yarn test`.

## Configuration

Code quality is set up for you with `prettier`, `husky`, and `lint-staged`. Adjust the respective fields in `package.json` accordingly.

### Jest

Jest tests are set up to run with `npm test` or `yarn test`.

#### Setup Files

This is the folder structure we set up for you:

```txt
/example
  index.html
  index.tsx       # test your component here in a demo app
  package.json
  tsconfig.json
/src
  index.tsx       # EDIT THIS
/test
  blah.test.tsx   # EDIT THIS
/stories
  Thing.stories.tsx # EDIT THIS
/.storybook
  main.js
  preview.js
.gitignore
package.json
README.md         # EDIT THIS
tsconfig.json
```

### Rollup

The lib uses [Rollup](https://rollupjs.org) as a bundler and generates multiple rollup configs for various module formats and build settings. See [Optimizations](#optimizations) for details.

### TypeScript

`tsconfig.json` is set up to interpret `dom` and `esnext` types, as well as `react` for `jsx`. Adjust according to your needs.

## Continuous Integration

### GitHub Actions

- `main` which installs deps w/ cache, lints, tests, and builds on all pushes against a Node and OS matrix

## Optimizations

Please see the main `tsdx` [optimizations docs](https://github.com/palmerhq/tsdx#optimizations). In particular, know that you can take advantage of development-only optimizations:

```js
// ./types/index.d.ts
declare var __DEV__: boolean;

// inside your code...
if (__DEV__) {
  console.log('foo');
}
```

You can also choose to install and use [invariant](https://github.com/palmerhq/tsdx#invariant) and [warning](https://github.com/palmerhq/tsdx#warning) functions.

## Module Formats

CJS, ESModules, and UMD module formats are supported.

The appropriate paths are configured in `package.json` and `dist/index.js` accordingly. Please report if any issues are found.

## Named Exports

Per Palmer Group guidelines, [always use named exports.](https://github.com/palmerhq/typescript#exports) Code split inside your React app instead of your React library.
npm package: @nftgo/data-partner
Description: NFTGo Data Partner widgets library build your nft data analytics website
Latest version: 0.1.3

# README

## CI and CD

### Configuration

#### Env

None

### Init

None

### Dependency

None

### Run

```bash
# install packages
yarn install
# build
yarn build
# build docker image
sudo docker build -t data-partner .

# run data-partner
docker run \
-p 80:80 \
--name data-partner data-partner
```
npm package: @nftgo/mcp-nftgo-api
Description: NFTGo API MCP Server
Author: NFTGo
Latest version: 0.1.2

# NFTGoAPI

A Model Context Protocol server that provides HTTP request to NFTGo Developer API based on NFTGo API documentation.

## Components

## Usage with Claude Desktop

To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:

### NPX

```json
{
  "mcpServers": {
    "nftgoapi": {
      "command": "npx",
      "args": ["-y", "@nftgo/mcp-nftgo-api", "NFTGO-API-KEY"]
    }
  }
}
```

Replace `NFTGO-API-KEY` with your API key.

## Building

```sh
pnpm install
pnpm build
```

## License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.