open-index/open-npm huggingface dataset:
npm package: @gitmyabi-stg/uniswap--smart-wallet
Description: Auto-generated TypeScript type bindings for smart-wallet (build etherscan-smart-wallet-1775817556038, commit c6cbc40, branch etherscan)
Latest version: 0.0.1

# @gitmyabi-stg/uniswap--smart-wallet

Auto-generated TypeScript type bindings for **smart-wallet**

- **Build ID**: `etherscan-smart-wallet-1775817556038`
- **Build Number**: 1
- **Commit**: `c6cbc40`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/uniswap--smart-wallet@0.0.1
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/uniswap--smart-wallet';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--smart-wallet';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--smart-wallet';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 1 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/uniswap--uniswapx
Description: Auto-generated TypeScript type bindings for uniswapx (build etherscan-uniswapx-1775817650314, commit 5e34421, branch etherscan)
Latest version: 0.0.1

# @gitmyabi-stg/uniswap--uniswapx

Auto-generated TypeScript type bindings for **uniswapx**

- **Build ID**: `etherscan-uniswapx-1775817650314`
- **Build Number**: 1
- **Commit**: `5e34421`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/uniswap--uniswapx@0.0.1
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/uniswap--uniswapx';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--uniswapx';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--uniswapx';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 4 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/uniswap--v2-contracts
Description: Auto-generated TypeScript type bindings for v2-contracts (build etherscan-v2-contracts-1775714400115, commit 8669895, branch etherscan)
Latest version: 0.0.1

# @gitmyabi-stg/uniswap--v2-contracts

Auto-generated TypeScript type bindings for **v2-contracts**

- **Build ID**: `etherscan-v2-contracts-1775714400115`
- **Build Number**: 1
- **Commit**: `8669895`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/uniswap--v2-contracts@0.0.1
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/uniswap--v2-contracts';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--v2-contracts';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--v2-contracts';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 1 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/uniswap--v4-protocol
Description: Auto-generated TypeScript type bindings for v4-protocol (build etherscan-v4-protocol-1775816901229, commit 5419796, branch etherscan)
Latest version: 0.0.2

# @gitmyabi-stg/uniswap--v4-protocol

Auto-generated TypeScript type bindings for **v4-protocol**

- **Build ID**: `etherscan-v4-protocol-1775816901229`
- **Build Number**: 1
- **Commit**: `5419796`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 7

## Installation

```bash
npm install @gitmyabi-stg/uniswap--v4-protocol@0.0.2
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/uniswap--v4-protocol';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--v4-protocol';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi-stg/uniswap--v4-protocol';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 7 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi/axlabs--bridge-evm-contracts
Description: Auto-generated TypeScript type bindings for bridge-evm-contracts (build 1fe2a999-9c0d-4c4d-88b9-e41d470daab7, commit a70b698, branch main)
Latest version: 0.0.4

# @gitmyabi/axlabs--bridge-evm-contracts

Auto-generated TypeScript type bindings for **bridge-evm-contracts**

- **Build ID**: `1fe2a999-9c0d-4c4d-88b9-e41d470daab7`
- **Build Number**: 4
- **Commit**: `a70b698`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 57

## Installation

```bash
npm install @gitmyabi/axlabs--bridge-evm-contracts@0.0.4
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi/axlabs--bridge-evm-contracts';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi/axlabs--bridge-evm-contracts';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi/axlabs--bridge-evm-contracts';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 57 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test
Description: Auto-generated TypeScript type bindings for gitmyabi-test (build fd1f6acb-c7b0-47fe-8d60-ee4d4de0438e, commit 8c069c6, branch main)
Latest version: 0.0.4

# @gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test

Auto-generated TypeScript type bindings for **gitmyabi-test**

- **Build ID**: `fd1f6acb-c7b0-47fe-8d60-ee4d4de0438e`
- **Build Number**: 4
- **Commit**: `8c069c6`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test@0.0.4
```

## Usage

### Class-based API (TypeChain-like)

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test';

const publicClient = createPublicClient({ chain: mainnet, transport: http() });
const walletClient = createWalletClient({ chain: mainnet, transport: http() });

// Create contract instance
const contract = new YourContract('0x...', { publicClient, walletClient });

// Read functions - call directly like TypeChain!
const result = await contract.yourMethod(param1, param2);

// Write functions - also call directly!
const hash = await contract.transfer('0x...', 1000n);
```

### With viem directly

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContractAbi } from '@gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Fully typed contract read
const result = await client.readContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});

// Fully typed contract write
const hash = await client.writeContract({
  address: '0x...',
  abi: YourContractAbi,
  functionName: 'yourMethod',
  args: [param1, param2],
});
```

### With wagmi

```typescript
import { useReadContract, useWriteContract } from 'wagmi';
import { YourContractAbi } from '@gitmyabi/merl111s-team-1e7ac93c--gitmyabi-test';

function MyComponent() {
  const { data } = useReadContract({
    address: '0x...',
    abi: YourContractAbi,
    functionName: 'yourMethod',
    args: [param1, param2],
  });

  const { writeContract } = useWriteContract();
  
  const handleWrite = () => {
    writeContract({
      address: '0x...',
      abi: YourContractAbi,
      functionName: 'yourMethod',
      args: [param1, param2],
    });
  };

  return <button onClick={handleWrite}>Call Contract</button>;
}
```

## Type Safety

This package provides full TypeScript type safety for all contract methods, events, and parameters using viem's type system. All ABIs are exported as `const` assertions for maximum type inference.

## Generated Contracts

This package includes type bindings for 1 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitobi/gitobi-shopify-context
Description: Provide EC feature for gitobi shopify store
Author: deraru
Latest version: 1.3.0

# gitobi-shopify-context

# Install

## npm

`npm install --save @gitobi/gitobi-shopify-context`

# Publish

- `git commit -am 'Bump version to vX.X.X'`
- `npm version [major|minor|patch]`
- `npm run build`
- `npm publish --access publish`
npm package: @gitobi/react-blank-component
Description: Blank Component for React App. This is useful for mock, wireframing and creating a skeleton page.
Author: deraru, TakuroOnoda
Latest version: 1.0.4

# react-blank-component

Blank Component for React App. This is useful for mock, wireframing and creating a skeleton page.

# How to use

## Install

### yarn

`yarn add @gitobi/react-blank-component`

### npm

`npm install @gitobi/react-blank-component --save`

## Sample code

```javascript
import React, { Component } from 'react';
import BlankComponent from '@gitobi/react-blank-component';

class Home extends Component {
  render() {
    return (
      <BlankComponent />
    );
  }
}

export default Home;
```

# Publish

1. `yarn build`
1. `git add .`
1. `git commit -m`
1. `git tag -a v1.0.0 -m 'v1.0.0 release'`
1. `git push origin v1.0.0`
1. `npm publish --access=public`

# License

MIT
npm package: @gitopia/git-remote-gitopia
Description: git-remote-helper for Gitopia
Author: gitopia@thetechtrap.com
Latest version: 0.1.7
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# git-remote-gitopia

[![](https://img.shields.io/npm/v/@gitopia/git-remote-gitopia?color=)](https://www.npmjs.com/package/@gitopia/git-remote-gitopia)  
git remote helper for [Gitopia](https://gitopia.org)  
PST Fee of 0.01 AR is applicable on git push.

## Steps to Build

- `npm install`
- `npm link`

## Usage

Set the following environment variable with the path of your Arweave wallet file.  
`export GITOPIA_WALLET_PATH=/path/to/wallet`

You don't need to run `git-remote-gitopia` directly, it will be called automatically by `git` when it encounters remote of the form `gitopia://`