open-index/open-npm huggingface dataset:
npm package: @namespacesdk/indexer-manager
Description: Library for interacting with namespace indexer-manager
Latest version: 1.0.1

# @namespacesdk/indexer-manager

This library provides an `IndexerClient` for interacting with indexed data from Namespace smart contracts. It is built on top of Axios and provides a convenient API for gathering subnames data from Namespace.

---

## Methods

Below is a list of available methods in the `IndexerClient`:

- `getL2Subnames(query: GetL2SubnamesQuery): Promise<L2SubnamePagedResponse>`
- `getL2Subname(network: L2Network, namehash: string): Promise<L2SubnameResponse>`
- `getL2Stats(includeTestnet: boolean): Promise<L2SubnameStats>`
- `getL1Subnames(query: GetL1SubnamesQuery): Promise<L1SubnameResponse[]>`
- `getL1Subname(network: L1Network, namehash: string): Promise<L1SubnameResponse>`

---

## Installation

Install the library using npm or yarn:

```bash
npm install @namespacesdk/indexer-manager
```

---

## Configuration

The client can be initialized with a configuration object:

```typescript
import { createIndexerClient } from "@namespacesdk/indexer-manager";

const client = createIndexerClient({});
```

---
npm package: @namesty/ethereum-plugin-js
Description: Polywrap Ethereum Javascript Plugin
Latest version: 0.10.0-pre.7

# @polywrap/ethereum-plugin-js

The Ethereum plugin wrapper allows the Polywrap JS Client to interact with any [EVM based blockchain](https://ethereum.org/).

## Usage

``` typescript
import {
  ethereumPlugin,
  Connections,
  Connection
} from "@polywrap/ethereum-plugin-js";

export async function main() {

  const uri = "wrap://ens/ethereum.polywrap.eth"

  // initialize Ethereum Connections store
  const connections: Connections = new Connections({
    networks: {
      mainnet: new Connection({
        provider: "..."
      }),
      matic: new Connection({
        provider: window.ethereum
      })
    },
    defaultNetwork: "matic"
  });

  // initialize the client with the ethereum plugin
  client = new PolywrapClient({
    plugins: [
      {
        uri: uri,
        plugin: ethereumPlugin({ connections })
      }
    ]
  });

  // now you can invoke the ethereum plugin by its URI
  // NOTE: uses default network "matic"
  const getSignerAddress = await client.invoke<string>({
    uri,
    method: "getSignerAddress",
  });

  if (!getSignerAddress.ok) throw getSignerAddress.error;

  const address = getSignerAddress.value;

  // Get a balance from mainnet, by passing in the optional
  // "connection" argument.
  const getBalance = await client.invoke<string>({
    uri,
    method: "getBalance",
    args: {
      address: "0x...",
      connection: {
        networkNameOrChainId: "mainnet"
      }
    },
  });

  if (!getBalance.ok) throw getBalance.error;

  const balance = getBalance.value;

  console.log("Matic Signer: ", address);
  console.log("Mainnet Balance: ", balance);
}
```

For more usage examples see `src/__tests__`.

## API

Full API in `src/schema.graphql`
npm package: @namestyorg/http-plugin-js
Description: HTTP plugin enabling invocating http methods through web3api
Latest version: 1.0.1-alpha.0

# HTTP Plugin

Http plugin curently supports two different methods `GET` and `POST`. Similar to calling axios, when defining request you need to specify a response type. Headers and query parameters may also be defined.

## Response Types

`TEXT` - The server will respond with text, the HTTP plugin will return the text as-is.

`BINARY` - The server will respond with binary data (_ArrayBuffer_), the HTTP plugin will encode as a **base64** string and return it.

## GET request

Below is sample invocation of the `GET` request with custom request headers and query parameters (`urlParams`).

```ts
const response = await web3ApiClient.query<{ get: Response }>({
uri: new Uri("w3://ens/http.web3api.eth"),
  query: `
    query {
      get(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
        }
      )
    }
  `
})
```

## POST request

Below is sample invocation of the `POST` request with custom request headers and query parameters (`urlParams`). It is also possible to set request body as shown below.

```ts
const response = await web3ApiClient.query<{ get: Response }>({
  uri: new Uri("w3://ens/http.web3api.eth"),
  query: `
    mutation {
      post(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
          body: "{data: 'test-request'}"
        }
      )
    }
  `
})
```
npm package: @namestyorg/schema-bind
Description: Generates Web3API schema bindings for supported guest languages.
Latest version: 1.0.0-alpha.0

# Web3API Binding
Generates Web3API schema bindings for supported guest languages.

## Details
Web3API uses MessagePack as a common data interchange format between languages. This allows Web3API WASM modules, authored in different langues, to be run within a single host language (JS, Rust, Python, Go, C#, C++).

MessagePack encoded data is sent between module boundaries. Decoding of the message will happen in the destination environment, using generated binding code, created by this package.

## Supported Schema Types

| GraphQL Schema Type | [MessagePack Type](https://github.com/msgpack/msgpack/blob/master/spec.md#extension-types) | Description |
|---------------------|------------------|-------------|
| UInt | uint 32 | 32-bit unsigned integer. |
| UInt8 | uint 8 | 8-bit unsigned integer. |
| UInt16 | uint 16 | 16-bit unsigned integer. |
| UInt32 | uint 32 | 32-bit unsigned integer. |
| UInt64 | uint 64 | 64-bit unsigned integer. |
| Int | int 32 | 32-bit signed integer. |
| Int8 | int 8 | 8-bit signed integer. |
| Int16 | int 16 | 16-bit signed integer. |
| Int32 | int 32 | 32-bit signed integer. |
| Int64 | int 64 | 64-bit signed integer. |
| String | fixstr or str 8/16/32 | UTF-8 string. |
| Boolean | bool | true or false stored as 1 byte. |

## Usage
TODO
npm package: @namestys/http-plugin-js
Description: HTTP plugin enabling invocating http methods through web3api
Latest version: 2.0.0-alpha.0

# HTTP Plugin

Http plugin curently supports two different methods `GET` and `POST`. Similar to calling axios, when defining request you need to specify a response type. Headers and query parameters may also be defined.

## Response Types

`TEXT` - The server will respond with text, the HTTP plugin will return the text as-is.

`BINARY` - The server will respond with binary data (_ArrayBuffer_), the HTTP plugin will encode as a **base64** string and return it.

## GET request

Below is sample invocation of the `GET` request with custom request headers and query parameters (`urlParams`).

```ts
const response = await web3ApiClient.query<{ get: Response }>({
uri: new Uri("w3://ens/http.web3api.eth"),
  query: `
    query {
      get(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
        }
      )
    }
  `
})
```

## POST request

Below is sample invocation of the `POST` request with custom request headers and query parameters (`urlParams`). It is also possible to set request body as shown below.

```ts
const response = await web3ApiClient.query<{ get: Response }>({
  uri: new Uri("w3://ens/http.web3api.eth"),
  query: `
    mutation {
      post(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
          body: "{data: 'test-request'}"
        }
      )
    }
  `
})
```
npm package: @namestys/schema-bind
Description: Polywrap Schema Binding
Latest version: 0.11.4

# @polywrap/schema-bind

Bind WRAP ABIs to a variety of supported languages through codegen.

## Usage

``` typescript
import { BindOptions, BindOutput, bindSchema } from "@polywrap/schema-bind";
import { parseSchema } from "@polywrap/schema-parse";

const schema = fetch("schema.graphql");
const abi = parseSchema(schema);

const input: BindOptions = {
  projectName: "Test",
  bindLanguage: "wasm-as",
  abi,
  schema,
  outputDirAbs: "/path/to/output/dir"
};

const output: BindOutput = bindSchema(input);
```

## Details

Polywrap uses MessagePack as a common data interchange format between languages. This allows Polywrap WASM modules, authored in different languages, to be run within a single host language (JS, Rust, Python, Go, C#, C++).

MessagePack encoded data is sent between module boundaries. Decoding of the message will happen in the destination environment, using generated binding code, created by this package.

## Supported Schema Types

| GraphQL Schema Type | [MessagePack Type](https://github.com/msgpack/msgpack/blob/master/spec.md#formats) | Description |
|-|-|-|
| UInt | uint 32 | 32-bit unsigned integer. |
| UInt8 | uint 8 | 8-bit unsigned integer. |
| UInt16 | uint 16 | 16-bit unsigned integer. |
| UInt32 | uint 32 | 32-bit unsigned integer. |
| Int | int 32 | 32-bit signed integer. |
| Int8 | int 8 | 8-bit signed integer. |
| Int16 | int 16 | 16-bit signed integer. |
| Int32 | int 32 | 32-bit signed integer. |
| String | fixstr or str 8/16/32 | UTF-8 string. |
| Boolean | bool | true or false stored as 1 byte. |
| Bytes | bin 8/16/32 | array of 8-bit unsigned integer. |
| BigInt | fixstr or str 8/16/32 | UTF-8 string. |
| BigNumber | fixstr or str 8/16/32 | UTF-8 string. |
| JSON | fixstr or str 8/16/32 | UTF-8 string. |
| [Type] | fixarray or array 16/32 | Array of elements. |
| Map | Msgpack extention type | Map of key-value pairs. |
| type CustomObject {<br/>&nbsp;&nbsp;prop: Type<br/>} | fixmap or map 16/32 | Structured object. |