open-index/open-npm huggingface dataset:
npm package: @stltio/stealth
Description: Device fingerprinting library
Author: Stlt.io
Latest version: 0.8.0

# Stlt - Stealth

Device fingerprinting and browser information.

See the working [demo](https://stlt.io) in action.

## How to use

```
import stealth from '@stltio/stealth'
const result = await stealth()
const {
  local: {},
  remote: {},
  visitorId: 'abc...xyz',
  ms: 491
} = result
```

## Use in ReactJs

```
import stealth from '@stltio/stealth'

const [data, setData] = useState({ local: {}, remote: {}, visitorId: '', ms: 0 })

useEffect(() => {
  const init = async () => {
    const s = await stealth()
    setData(s)
  }
  init()
}, [])
```

## ApiKey

If `apiKey` is provided, send the payload to the server (more accurate results).
Want an API_KEY? Contact us at [hello@stlt.io](mailto:hello@stlt.io).

### Example with API_KEY

```
import stealth from '@stltio/stealth'
const result = await stealth({ apiKey: 'aaa...bbb'})
const {
  local: {},
  remote: {},
  visitorId: 'abc...xyz',
  ms: 491
} = result

```

## Ignore list

You can exclude some tests by providing an array of keys to ignore.

### Example with ignore list

```
import stealth from '@stltio/stealth'
const result = await stealth({ ignore: ['audio', 'webrtc']})
const {
  local: {},
  remote: {},
  visitorId: 'abc...xyz',
  ms: 491
} = result
```

## Debug

You can enable debug mode by setting `debug` to `true`.

It will print in the console the lolcal generated payload and the remote response.

### Example with debug

```
import stealth from '@stltio/stealth'
const result = await stealth({ debug: true })
const {
  local: {},
  remote: {},
  visitorId: 'abc...xyz',
  ms: 491
} = result
```
npm package: @stm-labs/essential-select
Description: STM Angular select component
Author: STM Labs
Latest version: 1.0.2

# STM Essential Select

STM Angular select component

 - AOT compatible
 - Works with NgForms
 - Select one/multi options with a lot of customizations
 - Angular 6+

## Installation

and then import EssentialSelectModule in your Angular `AppModule`:

```typescript
import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

import {EssentialSelectModule} from 'essential-select';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    EssentialSelectModule,
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }
```

Or you can force to use some language by default
`EssentialSelectModule.forRoot({forcedDefaultLanguage: "en-US"}),`

## Development

To generate all `*.js`, `*.d.ts` and `*.metadata.json` files:

```bash
$ npm run build
```

```bash
$ npm run build:watch
```

To lint all `*.ts` files:

```bash
$ npm run lint
```

## License

MIT © [STM Labs](http://stm-labs.ru)
npm package: @stm0n/vue-autocomplete
Description: Just a simple input with autocomplete. For usage/example take a look at [App.vue](src/App.vue)
Latest version: 0.5.0

# vue-autocomplete

Just a simple input with autocomplete. For usage/example take a look at [App.vue](src/App.vue)

Also available at  
<a href="https://www.npmjs.com/package/@stm0n/vue-autocomplete"><img src="https://img.shields.io/npm/v/@stm0n/vue-autocomplete.svg"/></a>
npm package: @stm32p103/ngrx-utility
Description: Provide efficient way to define actions and reducers for ngrx.
Latest version: 2.0.1

# ngrx-utility
Provide efficient way to define actions and reducers for ngrx.

# Example
```
npm run build
cd example\NgrxUtilitySample
npm install
ng serve
```

# Usage
## Define actions
Create static property using `ToAction<T>( actionName, payloader: (...arg:any[] ) => T ): ActionWithPayload<T>`.
```
export class CounterActions {
    static increment = ToAction( '[Counter] Increment', () => {} );
    static decrement = ToAction( '[Counter] Decrement', () => {} );
    static preset    = ToAction( '[Counter] Preset',    ( n: number ) => n );
}
```

## Define reducers
To define reducer, 
1. Instanciate `ReducerFactory<TypeOfState>`
1. Add reducer function by `add( action | actions[], reducer( state, payload ) => nextState )` per actions.
1. Create reducer by `create( initialValue )` and export it.

### Example
```
const factory = new ReducerFactory<number>();

factory.add( CounterActions.increment, ( count ) => count + 1 );
factory.add( CounterActions.decrement, ( count ) => count - 1 );
factory.add( CounterActions.preset,    ( count, preset ) => preset );

// create( initial value );
export const counterReducer = factory.create( 0 );
```
Note that, Typescript infers types of payload from specified actions. So if you specify wrong type in reducer, typescript warns you.
![Type inference](https://photos.app.goo.gl/KACRCpHuNwHavdHy6)
![Type inference error](https://photos.app.goo.gl/Sy9FYBNofB7A9ifMA)
![Type inference error](https://photos.app.goo.gl/2cN4GGFyBDCSQDNU9)

## Embed in ngrx
As usual...

```
@NgModule( {
  declarations: [
    AppComponent
  ],
  imports: [
    StoreModule.forRoot( { count: counterReducer } )
  ],
  providers: [],
  bootstrap: [ AppComponent ]
} )
export class AppModule { }
```

## Dispatch actions
Dispatch actions generated by static methods which applied `ToAction` decorator.

```
import { Component } from '@angular/core';
import { Store, select } from '@ngrx/store';
import { Observable } from 'rxjs';
import { CounterActions } from './counter';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
    count$: Observable<number>;
    constructor( private store: Store<any> ) {
        this.count$ = this.store.pipe( select('count') );
    }
    
    increment() {
        this.store.dispatch( CounterActions.increment() );
    }
    
    decrement() {
        this.store.dispatch( CounterActions.decrement() );
    }
    
    reset() {
        this.store.dispatch( CounterActions.preset( 10 ) );
    }
}
```

## Effects
Pipe `payloadOf` operator after `actions$` observable. 
```
@Injectable()
export class EffectTest {
    constructor(
        private actions$: Actions
    ) {}

    @Effect( { dispatch: false } ) increment$ = this.actions$.pipe(
        payloadOf( CounterActions.preset ),
        map( payload => console.log( JSON.stringify( payload ) ) )
    );
}
```
npm package: @stn-ui/table
Description: Short description of what this module does.
Author: Yaroslav Romanenko
Latest version: 5.0.0

# @stn-ui/table

Short description of what this module does.

## Installation

```
npm install @stn-ui/table
# or
yarn add @stn-ui/table
# or
pnpm install @stn-ui/table
```

## Usage

Brief explanation of how to use this module.

```
import { Table, TBody, Td, TFoot, THead, Tr } from '@stn-ui/table';
```
npm package: @stnew/ableton-parser
Description: Return MIDI or Locator data from Ablton .als files
Author: Something New
Latest version: 0.4.1

# @stnew/ableton-parser

## Install
```
npm i @stnew/ableton-parser
```

## Node.js
To use with Node.js, pass a file path or URL to the `.als` file in the `Ableton` constructor:
```js
import Ableton from '@stnew/ableton-parser'

const parser = new Ableton('/path/to/file.als')
```

### Methods
- `getMidiTrack` - Returns a promise containing MIDI note timecodes
- `getLocatorData` - Returns a promise containing Locator timecodes, names, and annotations
- `getDuration` - Returns a promise containing track duration

### Example
```js
const handler = async (req, res) => {
  const parser = new Ableton(req.url);

  const midi = await parser.getMidiTrack();
  const duration = await parser.getDuration();

  const data = {
    midi,
    duration,
  };

  res.setHeader('Content-Type', 'application/json');
  res.statusCode = 200;
  res.end(JSON.stringify(data));
};
```

## CLI
Install globally to process files via command-line:
```
npm i -g @stnew/ableton-parser
```
### Options
```
  -h, --help      Show help                                            [boolean]
  -v, --version   Show version number                                  [boolean]
  -m, --midi      Extract MIDI note timecodes                          [boolean]
  -l, --locators  Extract Locator timecodes, names, and annotations    [boolean]
  -d, --duration  Extract track duration                               [boolean]
```
### Examples
You must specify a flag and a file path or url to the `.als` file

```
  ableton --midi path/to/file.als
  ableton -mld https://example.com/path/to/file.als
```
npm package: @stnew/markdown
Description: A markdown parsing React component
Latest version: 0.0.13

# Markdown

A React component for parsing and rendering a markdown string, with support for custom tags that map to React components.

## Examples

```
// string
const exampleString = "## test";

// React
<Markdown content={exampleString} />

// renders
<h2>test</h2>
```

```
//string
const exampleString = `
## test
<ComponentA />
<ComponentB className="test">children</ComponentB>
`;

// React
import ComponentA from './ComponentA';
import ComponentB from './ComponentB';

<Markdown
  content={exampleString}
  customTags={{
    ComponentA,
    ComponentB,
  }}
/>

// renders
<h2>test</h2>
<ComponentA />
<ComponentB className="test">children</ComponentB>

```
npm package: @stnew/prismic
Description: Prismic components and utilities for React
Author: Something New
Latest version: 1.2.6

# @stnew/prismic

This package exports:

- `urlResolver` - A helper function to create link resolvers.

## urlResolver

The `urlResolver` function will help Prismic and (optionally) Next.js resolve the correct prismic documents when you wire up links.

Inside each function is a hash map. The key is the API ID of your Prismic "Single" or "Repeatable" type.

Each route contains up to three keys:

- `href`: The URL of the page that will resolve to when passed to our `Link` component
- `page`: (optional): The Next.js page to resolve to. Only neccessary if you're using `hrefResolver` or [`PrismicLink`](/packages/prismic-nextjs)
- `root`: (optional): The `uid` of the index page from Prismic

"Single" types, will resolve directly to `href`. "Repeatable" types resolve to a the `href` + the `uid` field, and you can use the `root` field in conjuction with that to filter out the root `uid`, so that your URLs are clean.

### resolvers

The `urlResolver` function will return two more functions.

- `linkResolver` will resolve the url as you would see it in the address bar, such as `/about-us` or `/blog/hello-world`.

- `hrefResolver` is for only for `next/link` components to resolve the correct route, such as `/[page]` or `/blog/[...post]`. If you're not using Next.js don't worry about it.

### Example

#### resolvers.js

```javascript
import { urlResolver } from '@sntew/prismic'

const routeMap = {
  home_page: {
    href: '/',
    page: '/',
  },
  about_page: {
    href: '/about',
    page: '/about',
  }
  privacy_page: {
    href: '/privacy',
    page: '/privacy/[[...uid]]',
    root: 'privacy-policy'
  }
}

export const { linkResolver, hrefResolver}  = urlResolver(routeMap)
```

#### NavLink.js

```jsx
import NextLink from 'next/link'
import { linkResolver, hrefResolver } from './resolvers.js'

function NavLink({ href, label }) {
  return (
    <NextLink as={linkResolver(href)} href={hrefResolver(href)}>
      <a>{label}</a>
    </NextLink>
  )
}
```

### Usage with React

The [@stnew/prismic-react](/packages/prismic-react) package has a Context/Provider pattern, as well as a hook for accessing the linkResolver in any component.
npm package: @stnew/prismic-apollo-link
Description: An ApolloLink to connect to Prismic's GraphQL API
Author: Something New
Latest version: 1.2.4

# @stnew/prismic-apollo-client

This package exports:

- `prismicApolloLink` - An ApolloLink to connect to Prismic's GraphQL API

## prismicApolloLink

Install dependencies:

```sh
npm install @stnew/prismic-apollo-link @apollo/client prismic-javascript
```

To connect the the GraphQL API, create a new ApolloClient and pass the link to the constructor:

```js
import { ApolloClient, InMemoryCache } from '@apollo/client'
import { prismicApolloLink } from ' @stnew/prismic-apollo-link'

export const prismicClient = new ApolloClient({
  cache: new InMemoryCache(),
  link: prismicApolloLink({
    repositoryName: 'your-repository-name',
    accessToken: 'YOUR_ACCESS_TOKEN',
  }),
})
```

Now you can use this client to query the API.

```js
import { prismicClient } from 'lib/prismic'

const { data } = await prismicClient.query({
  query: gql`
    query($lang: String!, $uid: String!) {
      blog(lang: $lang, uid: $uid) {
        title
      }
    }
  `,
  variables: {
    uid: 'hello-world',
    lang: 'en-us',
  },
})
```

### Handling Previews

The `prismicApolloLink` takes a second argument which handles preview refs from Prismic. You can handle
this case by making your client a function that accepts the preview data as an argument.

```js
export function prismicClient({ previewData }) {
  return new ApolloClient({
    cache: new InMemoryCache(),
    link: prismicApolloLink({
        repositoryName: 'your-repository-name',
        accessToken: 'YOUR_ACCESS_TOKEN',
      },
      previewData,
    ),
  })
}
```

And for example, in Next.js you would pass this data to the client.

```js
export async function getStaticProps({ params, preview = false, previewData }) {
  const response = await prismicClient({ previewData }).query({
    query: gql`
      query($lang: String!, $uid: String!) {
        blog(lang: $lang, uid: $uid) {
          title
        }
      }
    `,
    variables: {
      uid: params.uid,
      lang: 'en-us',
    },
  })

  const data = response.data.blog

  return {
    props: {
      data,
      preview,
    },
  }
}
```
npm package: @stnew/prismic-nextjs
Description: Prismic components and utilities for Next.js
Author: Something New
Latest version: 1.2.6

# @stnew/prismic-nextjs

`@stnew/prismic-nextjs` has peerDepenendencies of `react`, `react-dom`, and `next`. This package assumes you have a basic Next.js app running and have integrated the Prismic client.

This package exports:

- `PrismicLink` - A wrapper for `next/link` that handles link resolution.
- `urlResolver` from [@stnew/prismic](/packages/prismic) ([npm](https://www.npmjs.com/package/@stnew/prismic))
- `PrismicContext, PrismicProvider, SliceZone, usePrismic, useHtmlSerializer, serializeElements` from [@stnew/prismic-react](/packages/prismic-react) ([npm](https://www.npmjs.com/package/@stnew/prismic-react))

## PrismicLink

The `PrismicLink` component will take a Prismic link fragment and generate an anchor tag. It's using `linkResolver` and `hrefResolver` under the hood, so if you links are not working make sure that you have those set up correctly.

```jsx
import { PrismicLink } from '@stnew/prismic-nextjs'

function NavItem({ link, label }) {
  return (
    <li>
      <PrismicLink link={link}>{label}</PrismicLink>
    </li>
  )
}
```

Prop      | Required | Type                                                                         | Description
--------- | -------- | ---------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------
link      | Yes      | PrismicDoc fragment                                                          | Resolves urls for Prismic "Link" fields
as        | No       | React Component or string                                                    | Renders the `a` tag as another React component, useful for libraries like [styled-components](https://styled-components.com)
urlObject | No       | [UrlObject](https://nodejs.org/api/url.html#url_url_strings_and_url_objects) | Transforms URL object and appends it to the URL, useful for things like query strings. This won't work on external links.

### Styling PrismicLink

If you're using a css-in-js library like `styled-components`, you might be wondering how you can style a `PrismicLink`.

There are a few ways which we've outlined [in this doc](/docs/with-styled-components.md), for brevity.
npm package: @stoademo/common-utils
Description: Made with create-react-library
Author: EdgarGGamartgo
Latest version: 1.0.1

# common-utils

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/common-utils.svg)](https://www.npmjs.com/package/common-utils) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save common-utils
```

## Usage

```tsx
import React, { Component } from 'react'

import MyComponent from 'common-utils'
import 'common-utils/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [EdgarGGamartgo](https://github.com/EdgarGGamartgo)
npm package: @stoademo/ui-components
Description: Made with create-react-library
Author: EdgarGGamartgo
Latest version: 1.0.1

# ui-components

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/ui-components.svg)](https://www.npmjs.com/package/ui-components) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save ui-components
```

## Usage

```tsx
import React, { Component } from 'react'

import MyComponent from 'ui-components'
import 'ui-components/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [EdgarGGamartgo](https://github.com/EdgarGGamartgo)
npm package: @stoat-run/overlay
Description: Overlay helpers for stoat.run tunnels.
Author: sic-em
Latest version: 0.1.2

# @stoat-run/overlay

Overlay helpers for stoat.run tunnels.

## Install

```bash
npm i @stoat-run/overlay
```

## React

```tsx
import { StoatOverlay } from "@stoat-run/overlay";

export function Layout({ children }: { children: React.ReactNode }) {
  return (
    <>
      {children}
      <StoatOverlay slug="hidden-peek-2249" />
    </>
  );
}
```
npm package: @stoboxpswap/sdk
Description: 🛠 An SDK for building applications on top of StoboxSwap.
Latest version: 2.6.1

# StoboxSwap SDK

Forked from the [Uniswap SDK](https://github.com/Uniswap/uniswap-v2-sdk/commit/a88048e9c4198a5bdaea00883ca00c8c8e582605).

You can refer to the Uniswap SDK documentation [uniswap.org](https://docs.uniswap.org/sdk/2.0.0/).

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/StoboxTechnologies/stobox_pswap_sdk.gi
```

Move into the stobox-pswap-sdk working directory

```sh
cd stobox-pswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```

# Publish

```sh
npm publish --access public
```
npm package: @stochain/crypto-utils
Description: Cryptocurrency utility functions for formatting and conversion
Author: Stochain
Latest version: 1.0.0

# @stochain/crypto-utils

Essential cryptocurrency utility functions for Ethereum-compatible blockchains.

## Installation

```bash
npm install @stochain/crypto-utils
```

## Features

- Wei/Ether/Gwei conversion utilities
- Gas fee calculations
- Address validation
- BigNumber operations
- Zero-dependency ethers.js wrapper

## Usage

### Wei/Ether Conversion

```typescript
import { formatEther, parseEther, formatGwei, parseGwei } from '@stochain/crypto-utils';

// Convert Wei to Ether
const ether = formatEther('1000000000000000000'); // "1.0"

// Convert Ether to Wei
const wei = parseEther('1.5'); // BigNumber

// Gwei conversions
const gwei = formatGwei('1000000000'); // "1.0"
const weiFromGwei = parseGwei('50'); // BigNumber
```

### Gas Fee Calculations

```typescript
import { calculateGasFee, calculateGasFeeInEther } from '@stochain/crypto-utils';
import { ethers } from 'ethers';

const gasPrice = ethers.BigNumber.from('50000000000'); // 50 Gwei
const gasLimit = ethers.BigNumber.from('21000');

// Calculate gas fee in Wei
const feeWei = calculateGasFee(gasPrice, gasLimit);

// Calculate gas fee in Ether
const feeEther = calculateGasFeeInEther(gasPrice, gasLimit); // "0.00105"
```

### Address Validation

```typescript
import { isValidAddress } from '@stochain/crypto-utils';

const valid = isValidAddress('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'); // true
const invalid = isValidAddress('invalid-address'); // false
```

### Format Units

```typescript
import { formatUnits, parseUnits } from '@stochain/crypto-utils';

// Format custom decimal tokens
const usdt = formatUnits('1000000', 6); // "1.0" (USDT has 6 decimals)

// Parse custom decimal tokens
const amount = parseUnits('100', 6); // BigNumber for 100 USDT
```

## API Reference

### Conversion Functions

- `formatEther(value: BigNumberish): string` - Wei to Ether
- `parseEther(value: string): BigNumber` - Ether to Wei
- `formatGwei(value: BigNumberish): string` - Wei to Gwei
- `parseGwei(value: string): BigNumber` - Gwei to Wei
- `formatUnits(value: BigNumberish, decimals: number): string` - Wei to custom decimals
- `parseUnits(value: string, decimals: number): BigNumber` - Custom decimals to Wei

### Gas Functions

- `calculateGasFee(gasPrice: BigNumber, gasLimit: BigNumber): BigNumber` - Calculate fee in Wei
- `calculateGasFeeInEther(gasPrice: BigNumber, gasLimit: BigNumber): string` - Calculate fee in Ether

### Validation Functions

- `isValidAddress(address: string): boolean` - Validate Ethereum address

## TypeScript Support

Full TypeScript support with type definitions included.

```typescript
import type { BigNumber, BigNumberish } from 'ethers';
```

## License

MIT

## Repository

https://github.com/stochain/packages
npm package: @stochain/wallet-sdk
Description: Blockchain wallet SDK for BSC and Cosmos networks
Author: Stochain
Latest version: 1.0.3

# @stochain/wallet-sdk

Blockchain wallet SDK for BSC and Cosmos networks with React Native support.

## Installation

```bash
npm install @stochain/wallet-sdk ethers
```

## Features

- 🔐 Generate BSC wallets
- 🌌 Generate Cosmos wallets
- 🔑 Import from private key or mnemonic
- ✅ Address validation
- 💰 Balance queries
- 📤 Transaction handling
- 🔄 Provider management

## Usage

### BSC Wallet

```typescript
import { generateBscWallet, importBscWalletFromMnemonic } from '@stochain/wallet-sdk';

// Generate new wallet
const wallet = await generateBscWallet();
console.log(wallet.address);
console.log(wallet.privateKey);
console.log(wallet.mnemonic);

// Import from mnemonic
const importedWallet = importBscWalletFromMnemonic(
  'your twelve word mnemonic phrase here'
);
```

### Cosmos Wallet

```typescript
import { generateCosmosWallet } from '@stochain/wallet-sdk';

// Generate new wallet
const wallet = await generateCosmosWallet('cosmos');
console.log(wallet.address);
console.log(wallet.privateKey);
console.log(wallet.mnemonic);
```

### Transaction Management

```typescript
import {
  fromMnemonic,
  getBalance,
  sendTransaction
} from '@stochain/wallet-sdk';
import { ethers } from 'ethers';

const provider = new ethers.providers.JsonRpcProvider('YOUR_RPC_URL');
const wallet = await fromMnemonic(['your', 'mnemonic', 'words'], provider);

// Get balance
const balance = await getBalance(wallet);

// Send transaction
const tx = {
  to: '0x...',
  value: ethers.utils.parseEther('0.1'),
  gasLimit: 21000
};
const response = await sendTransaction(wallet, tx);
```

## API Reference

### BSC Functions

- `generateBscWallet()`: Generate new BSC wallet
- `importBscWalletFromPrivateKey(privateKey)`: Import from private key
- `importBscWalletFromMnemonic(mnemonic, path?)`: Import from mnemonic
- `isValidBscAddress(address)`: Validate BSC address

### Cosmos Functions

- `generateCosmosWallet(prefix?)`: Generate new Cosmos wallet
- `importCosmosWalletFromMnemonic(mnemonic, path?)`: Import from mnemonic
- `isValidCosmosAddress(address, prefix?)`: Validate Cosmos address

### Wallet Functions

- `generateMnemonics()`: Generate random mnemonic
- `fromMnemonic(mnemonics, provider)`: Create wallet from mnemonic
- `fromPrivateKey(privateKey, provider)`: Create wallet from private key
- `getBalance(wallet)`: Get wallet balance
- `sendTransaction(wallet, tx)`: Send transaction
- `getGasPrice(provider)`: Get current gas price
- `estimateGas(provider, tx)`: Estimate gas for transaction

## License

MIT