open-index/open-npm huggingface dataset:
npm package: @rifcoin/toolkit
Description: 🎚 toolkit smart contracts for interacting with Rifcoin swap
Latest version: 1.0.2

# rifcoin toolkit

[![Tests](https://github.com/rifcoin/toolkit/workflows/Tests/badge.svg)](https://github.com/rifcoin/toolkit/actions?query=workflow%3ATests)
[![Lint](https://github.com/rifcoin/toolkit/workflows/Lint/badge.svg)](https://github.com/rifcoin/toolkit/actions?query=workflow%3ALint)

This repository contains the periphery smart contracts for the Rifcoin Swap Protocol.
For the lower level core contracts, see the [swap](https://github.com/rifcoin/swap)
repository.

## Local deployment

In order to deploy this code to a local testnet, you should install the npm package
`@rifcoin/toolkit`
and import bytecode imported from artifacts located at
`@rifcoin/toolkit/artifacts/contracts/*/*.json`.
For example:

```typescript
import {
  abi as SWAP_ROUTER_ABI,
  bytecode as SWAP_ROUTER_BYTECODE,
} from '@rifcoin/toolkit/artifacts/contracts/SwapRouter.sol/SwapRouter.json'

// deploy the bytecode
```

This will ensure that you are testing against the same bytecode that is deployed to
mainnet and public testnets, and all Uniswap code will correctly interoperate with
your local deployment.

## Using solidity interfaces

The rifcoin toolkit interfaces are available for import into solidity smart contracts
via the npm artifact `@rifcoin/toolkit`, e.g.:

```solidity
import '@rifcoin/toolkit/contracts/interfaces/ISwapRouter.sol';

contract MyContract {
  ISwapRouter router;

  function doSomethingWithSwapRouter() {
    // router.exactInput(...);
  }
}

```
npm package: @rifflearning/attachmediastream
Description: cross-browser way to attach a media stream to a video element.
Author: Henrik Joreteg
Latest version: 3.0.0

# attachMediaStream

## What is this?

A tiny browser module for attaching a media stream to a video (or audio) element with some options. It handles the differences between browsers via [adapter.js](https://github.com/webrtc/adapter).

Suitable for use with browserify/CommonJS on the client. 

If you're not using browserify or you want AMD support use `attachmediastream.bundle.js`.


## Installing

```
npm install attachmediastream
```

## How to use it


Makes it easy to attach video streams to video tags.

```js
var getUserMedia = require('getusermedia');
var attachMediaStream = require('attachmediastream');

// get user media
getUserMedia(function (err, stream) {
    // if the browser doesn't support user media
    // or the user says "no" the error gets passed
    // as the first argument.
    if (err) {
      console.log('failed');
    } else {
      console.log('got a stream', stream);  
       
      // attaches a stream to an element (it returns the element)
      var videoEl = attachMediaStream(stream, document.getElementById('myVideo'));

      // if you don't pass an element it will create a video tag
      var generatedVideoEl = attachMediaStream(stream);

      // you can also pass options
      var videoEl = attachMediaStream(stream, someEl, {
        // this will set the autoplay attribute on the video tag
        // this is true by default but you can turn it off with this option.
        autoplay: true, 
        
        // let's you mirror the video. It's false by default, but it's common 
        // to mirror video when showing a user their own video feed.
        // This makes that easy.
        mirror: true,

        // muted is false, by default
        // this will mute the video. Again, this is a good idea when showing
        // a user their own video. Or there will be feedback issues.
        muted: true,

        // attach as an audio element instead of video
        audio: false
      });

    }
});
```

## Why? 

Browsers used to to this very differently. This is now less true than it used to be.

It's still handy to be able to control mirroring, muting, autoplay in one shot with sane defaults.

## License

MIT


## Created By

If you like this, follow [@HenrikJoreteg](http://twitter.com/henrikjoreteg) on twitter.
npm package: @rifflearning/sibilant
Description: detect speaking events from webRTC audio
Author: Dan Calacci
Latest version: 0.1.7

# sibilant

detect speaking events from web audio

## installation

```sh
npm install @rifflearning/sibilant
```

## usage

Sibilant emits three different kinds of events after it's been hooked
up to a web audio stream:

- `speaking`: emitted continuously while voiced speech is detected
- `stoppedSpeaking`: emitted at the end of an utterance, with the start and end time of speech
- `volumeChanged`: emitted any time the volume of the audio stream changes

```javascript
import Sibilant from '@rifflearning/sibilant';

var speakingEvents = new Sibilant(stream)
speakingEvents.bind('speaking', function () {
    console.log('speaking!')
})
speakingEvents.bind('stoppedSpeaking', function (data) {
    console.log('Spoke!', 'start:', data.start, 'end:', data.end)
})
speakingEvents.bind('volumeChanged', function (data) {
    console.log('volume changed!', 'value:', data)
})
```

## license
MIT
npm package: @rifflix/rifflix-sdk
Description: This SDK allows developers to easily mint SPL tokens on the Solana blockchain with full metadata support, making it ideal for token launches, NFT infrastructure, DAOs, and Web3 apps.
Author: Ashish Sapkota | Raghib Islam
Latest version: 0.1.0

# Rifflix Contract SDK

This SDK allows developers to easily mint SPL tokens on the Solana blockchain with full metadata support, making it ideal for token launches, NFT infrastructure, DAOs, and Web3 apps.

---

## 🚀 Features

- Mint SPL tokens with name, symbol, and metadata URI
- Supports creation of associated token accounts
- Adds token metadata using Metaplex's Token Metadata program
- Optionally revokes mint and freeze authorities for security
- Built for Anchor-compatible environments but flexible for general use

---

## 📦 Installation & Dependencies

This SDK depends on:

- `@solana/web3.js`
- `@solana/spl-token`
- `@metaplex-foundation/mpl-token-metadata`

You’ll also need:

- A Solana wallet (e.g. from CLI or keypair JSON)
- Funded account on devnet or mainnet
- Node.js and TypeScript environment

---

## 🛠 Usage Overview

To use this SDK:

- Initialize your connection and wallet
- Create a provider using `createAnchorProvider`
- Instantiate the `TokenService` with the provider and network
- Call the `createToken` method with token name, symbol, URI, decimals, mint amount, and optional mint/freeze authority revoke flags
- Execute the transaction using the returned payload

All instructions (account creation, minting, metadata) are automatically handled inside the SDK.

---

## 🧪 Testing

A working ts-mocha test file is available under the `test/` directory. It demonstrates how to mint a token with metadata on devnet and logs the resulting transaction link.

To run tests:

- Ensure your wallet is funded on devnet
- Provide RPC and wallet setup using utility functions (`getWallet`, `getConnection`)
- Execute with `ts-mocha` runner

---

## 📁 Project Structure

- `src/`: Contains the `TokenService` logic
- `test/`: Mocha test case that runs a full mint operation
- `utils/`: Helper methods for wallet and connection setup

---

## 📄 Metadata Hosting

Ensure your metadata URI points to a valid JSON file (hosted on Arweave, IPFS, or a secure HTTPS endpoint) containing token details like name, symbol, image, and description.
npm package: @rifft-dev/rifft
Description: Cross-framework debugger SDK for multi-agent AI systems
Latest version: 0.1.0

# rifft

TypeScript SDK for Rifft, the cross-framework debugger for multi-agent AI systems.

## Install

```bash
npm install @rifft-dev/rifft
```

## Quickstart

```ts
import { init, trace, withSpan } from "rifft";

init({
  project_id: "my-project",
  endpoint: "http://localhost:4318",
});

const runResearch = trace({
  agent_id: "researcher",
  framework: "custom",
  span_name: "agent.research",
})(async (query: string) => {
  await withSpan("tool.call", { agent_id: "researcher", framework: "custom" }, async (span) => {
    span.setAttribute("tool.name", "search_docs");
    span.setAttribute("tool.input", { query });
  });

  return { ok: true };
});
```
npm package: @rifo/angular-library-generator
Description: Angular Library Generator
Author: Ofir Fridman
Latest version: 1.2.0

# Angular-library-generator
CLI tool for generating high standard Angular libraries.

## Features 
- Creates An angular workspace 
- Creates Angular library
- Creates an Angular example application
- Configures git hooks using Husky
- Adds MIT LICENSE file
- Adds prettier
- Adds README.md and CONTRIBUTE.md templates

And more!

 
## Installation
```sh
npm i -g @rifo/angular-library-generator 
```

## Usage
Just type 
```sh
genAngularLib 
```
And start generating!

## License

MIT &copy; [Ofir Fridman](https://github.com/ofirrifo)
npm package: @rifo/get-ts-imports
Description: Get typescript imports from file or directory
Author: Ofir Fridman
Latest version: 1.0.11

# Library for get typescript imports from file or directory 

## Installation 
```
npm i @rifo/get-ts-imports -D
```

## Usage 
```ts
import { extractImports } from '@rifo/get-ts-imports';

extractImports('./src/**/*.ts', (imports: string[]) => {
  imports = [...new Set(imports)].filter((imp) => {
    return imp.includes('scope');
  });
  console.log(imports);
  return imports;
});
```