open-index/open-npm huggingface dataset:
npm package: @rebarxyz/calculations
Description: Calculation management framework for Rebar on-chain computations
Author: Rebar
Latest version: 0.0.28

# @rebarxyz/calculations

Calculation management framework for Rebar on-chain computations.

## Overview

This package provides a simple, type-safe way to define and deploy on-chain calculations that automatically update when their inputs change.

**Key Features:**
- Named variable mapping (no more inline string interpolation)
- Automatic dependency resolution
- Separate code files (.star) for better syntax highlighting
- Type-safe registry with TypeScript autocomplete

## Installation

```bash
pnpm add @rebarxyz/calculations
```

## Usage

### 1. Create Calculation Files

Create `.star` files with your calculation logic using friendly variable names:

```python
# calculations/starlark/nouns/average.star
auctions = last_seven_auctions

if len(auctions) == 0:
    return 0

return sum(auctions) / len(auctions)
```

### 2. Define Registry

Create a registry that maps variable names to node addresses:

```typescript
// calculations/registry.ts
import type { CalculationRegistry } from '@rebarxyz/calculations';

export const CALCULATIONS: CalculationRegistry = {
  'nouns/average': {
    name: 'Average of Last Seven Nouns Auctions',
    file: './starlark/nouns/average.star',
    language: 'starlark',
    inputs: (inv) => ({
      last_seven_auctions: inv['nouns/history'].address
    }),
    valueType: 'float',
    unit: 'wei'
  }
};
```

### 3. Deploy Calculations

```typescript
import { createAllCalculations } from '@rebarxyz/calculations';
import { CALCULATIONS } from './calculations/registry';

// After pipeline creates data nodes
const inventory = await createAllCalculations(
  client,
  CALCULATIONS,
  inventory,
  owner,
  './calculations/registry.ts'
);
```

## How It Works

1. **Load**: Reads `.star` file
2. **Transform**: Replaces variable names with actual node addresses
3. **Order**: Topologically sorts calculations by dependencies
4. **Deploy**: Creates calculations on Rebar in correct order

## Example

```typescript
// Registry
'nouns/average': {
  inputs: (inv) => ({
    last_seven: inv['nouns/history'].address  // node123abc...
  })
}

// File: average.star
return sum(last_seven) / len(last_seven)

// After transformation (sent to Rebar):
return sum(node123abc...) / len(node123abc...)
```

## API

### `createAllCalculations(client, registry, inventory, owner, registryPath?)`

Creates all calculations in dependency order.

**Returns:** Updated inventory with calculation nodes

### `getCreationOrder(registry, inventory)`

Returns calculation keys in topological order.

**Returns:** `string[]` - Array of calculation keys

### `loadCalculation(filePath, def, inventory, registryPath?)`

Loads a calculation file and performs variable substitution.

**Returns:** `Promise<string>` - Transformed calculation code

## License

MIT
npm package: @rebarxyz/cli
Description: Terminal UI for browsing, editing, and monitoring Rebar chain nodes
Latest version: 0.0.28

# Rebar CLI

A terminal UI for the Rebar chain. Browse on-chain data, inspect calculation logic, push updates, and watch values change in real time — without touching a block explorer or writing a single curl command.

```bash
npm install -g @rebarxyz/cli
rebar
```

![Rebar CLI](screenshots/rebar-cli-screenshot.png)

## See Everything About a Data Source

Select any entry and see the full picture: current value, owner, description, calculation logic, input dependencies, and available actions. No more piecing together state from raw RPC queries.

![Node details](screenshots/rebar-cli-view-data.png)

## Edit and Sign In Place

Update values, preview the transaction, and sign — all without leaving the terminal. Supports stored wallets or one-time mnemonic entry.

![Edit and sign](screenshots/rebar-cli-edit-data.png)

## Live Monitoring

Watch any data source for real-time value changes over WebSocket. Scrolling update history with timestamps, pause/resume, and clear on the fly.

## Scriptable Too

Everything you can do interactively also works as one-off commands for scripting and CI:

```bash
rebar view --list --json                       # Dump everything as JSON
rebar view --address <addr>                    # Query a single data source
rebar view --search "price" --json             # Search and pipe to jq
rebar edit <addr> --value "42"                 # Update a value
rebar monitor <addr> --duration 300 --quiet    # Watch for 5 minutes
```

## Keyboard Shortcuts

Vim-style navigation throughout. `j`/`k` or arrow keys to move, `Enter` to select, `/` to search, `e` to edit, `m` to monitor, `r` to refresh, `q` to go back.

## Configuration

```bash
rebar config --show            # See current settings
rebar config --set-signer      # Store a signing wallet
rebar config --rpc <url>       # Set default RPC endpoint
```

Or set environment variables:

```bash
export REBAR_RPC_URL=https://rpc.rebar.xyz
export REBAR_CHAIN_ID=rebar-1
```

## Development

```bash
pnpm install
bun run dev
```
npm package: @rebase-agency/cra-template
Description: The base template for Create React App.
Author: rebase
Latest version: 1.2.0

# @rebase-agency/cra-template

![version](https://img.shields.io/npm/v/@rebase-agency/cra-template) [![License](https://img.shields.io/npm/l/express.svg)](https://github.com/rebase-agency/cra-template/blob/master/LICENSE)

A custom [create-react-app](https://github.com/facebook/create-react-app) template with sensible default code already done for you!

## Installation

When creating a new react-project, run the following command:

```shell
yarn create react-app %PROJECT_NAME% --template @rebase-agency
```

Or

```shell
npx create-react-app %PROJECT_NAME% --template @rebase-agency
```

Then

```shell
cd %PROJECT_NAME%
yarn start
```

## Features
- Starting module architecture
- Typescript
- Eslint & Prettier
- Support of runtime environment variables with dynamic values
- Normalize.css and shared reset css file
- All necessary meta tags for SEO in public/index.html
- Axios instance
- React Helmet & classnames

## License

@rebase-agency/cra-template is an open source software licensed as [MIT](https://github.com/rebase-agency/cra-template/blob/main/LICENSE).
npm package: @rebase-agency/cra-template-ui
Description: The UI library with Storybook and Rollup template for Create React App.
Author: rebase
Latest version: 1.1.0

# @rebase-agency/cra-template-ui

![version](https://img.shields.io/npm/v/@rebase-agency/cra-template-ui) [![License](https://img.shields.io/npm/l/express.svg)](https://github.com/rebase-agency/cra-template-ui/blob/master/LICENSE)

The UI library with Storybook and Rollup template for Create React App.

## Installation

When creating a new react-project, run the following command:

```shell
yarn create react-app %PROJECT_NAME% --template @rebase-agency/ui
```

Or

```shell
npx create-react-app %PROJECT_NAME% --template @rebase-agency/ui
```

Then

```shell
cd %PROJECT_NAME%
yarn storybook
```

For build your UI package run

```shell
yarn rollup-build
```

Your package will build in `dist` folder.

## Features
- Storybook with autodocs and start config theme
- Rollup with ready configuration

## License

@rebase-agency/cra-template-ui is an open source software licensed as [MIT](https://github.com/rebase-agency/cra-template-ui/blob/main/LICENSE).
npm package: @rebase-agency/nodemailer-mailgun-transport-ts
Description: Mailgun transport for the nodemailer library
Latest version: 1.0.0

## Installation

To use nodemailer-mailgun-transport, all you need to do is install the
`@rebase-agency/nodemailer-mailgun-transport-ts` package

```sh
$ yarn add @rebase-agency/nodemailer-mailgun-transport-ts

# or

$ npm i @rebase-agency/nodemailer-mailgun-transport-ts
```

## Usage

```ts
import nodemailer from 'nodemailer';
import { MailgunTransport } from '@rebase-agency/nodemailer-mailgun-transport-ts';

// This is your options that you retrieve from www.mailgun.com
const options = {
    auth: {
        domain: 'domain-name',
        api_key: '123456789',
    },
    host: 'api.mailgun.net',
};

const nodemailerMailgun = nodemailer.createTransport(new MailgunTransport(options));

nodemailerMailgun.sendMail({
    from: 'myemail@example.com',
    to: 'recipient@domain.com', // An array if you have multiple recipients.
    cc:'second@domain.com',
    bcc:'secretagent@company.gov',
    subject: 'Hey you, awesome!',
    'replyTo': 'reply2this@company.com',
    //You can use "html:" to send HTML email content. It's magic!
    html: '<b>Wow Big powerful letters</b>',
    //You can use "text:" to send plain-text content. It's oldschool!
    text: 'Mailgun rocks, pow pow!'
}, (err, info) => {
    if (err) {
        console.log(`Error: ${err}`);
    }
    else {
        console.log(`Response: ${info}`);
    }
});
```
The "from", "to", "cc", and "bcc" fields support an address object or array of address objects. Each "name" and 
"address" are converted to ```"name <address>"``` format. "name" is optional, "address" is required. Missing or null 
address in object is skipped.

Example:
```ts
 from: {name: 'Sales', address: 'sales@example.com'},
 to: [{name:'Mary', address:'mary@differentexample.com'}, {address:'john@anotherexample.com'}]
```
Is converted to:
```ts
 from: 'Sales <sales@example.com>',
 to: 'Mary <mary@differentexample.com>,john@anotherexample.com'
```
To use consolidate.js templates locally, give the template key an object instead that contains a name key, an 
engine key and, optionally, a context object. For example, you can use Handlebars templates to generate the 
HTML for your message like so:
```ts
const contextObject = {
  variable1: 'value1',
  variable2: 'value2'
};

nodemailerMailgun.sendMail({
  from: 'myemail@example.com',
  to: 'recipient@domain.com', // An array if you have multiple recipients.
  subject: 'Hey you, awesome!',
  template: {
    name: 'email.hbs',
    engine: 'handlebars',
    context: contextObject
  }
}, (err, info) => {
  if (err) {
    console.log(`Error: ${err}`);
  }
  else {
    console.log(`Response: ${info}`);
  }
});
```
npm package: @rebase-agency/react-polkadot-connect
Description: Polkadot API provider and hooks with account for React dApp
Author: @rebase-agency
Latest version: 0.2.0

# @rebase-agency/react-polkadot-connect

## Install

Install package:

```shell
npm i @rebase-agency/react-polkadot-connect
```

or

```shell
yarn add @rebase-agency/react-polkadot-connect
```

## Usage

Set up provider:

```tsx
import {PolkadotProvider} from "@rebase-agency/react-polkadot-connect";

const root = createRoot(document.getElementById("root")!);

root.render(
  <PolkadotProvider config={{
    rpcLink: "..."
    appName: "..."
  }}>
    <App />
  </PolkadotProvider>
);
```

Then you can use hook for connect, account etc.:

```tsx
import {usePolkadot} from "@rebase-agency/react-polkadot-connect";

const { address, connect, addresses, selectAddress } = usePolkadot()
```
npm package: @rebase-energy/timedatamodel-skill
Description: Claude Code plugin for the TimeDataModel Python library
Latest version: 1.0.0

# TimeDataModel Claude Code Plugin

A Claude Code plugin that teaches Claude how to work with the [TimeDataModel](https://github.com/davide/timedatamodel) Python library.

## What it does

Provides Claude with expert knowledge of `TimeSeries` and `TimeSeriesTable` objects, including:
- Choosing the right `DataShape` (SIMPLE, VERSIONED, CORRECTED, AUDIT)
- Creating and converting time series from pandas, Polars, NumPy, PyArrow
- Using `Frequency`, `DataType`, and `TimeSeriesType` enums correctly
- Geospatial filtering, unit conversion, and validation workflows

## Installation

```
/plugin install timedatamodel@<your-github-user>/TimeDataModel#claude-plugin
```

Or, if published to a marketplace:

```
/plugin install timedatamodel
```

## Structure

```
claude-plugin/
├── .claude-plugin/
│   └── plugin.json          # Plugin manifest
└── skills/
    └── timedatamodel/
        ├── SKILL.md          # Main skill (auto-invoked by Claude)
        └── references/
            ├── enums.md      # Frequency, DataType, TimeSeriesType values
            └── workflows.md  # Import/export, slicing, geo filtering patterns
```