open-index/open-npm huggingface dataset:
npm package: @gitmoji-changelog/cli
Description: Gitmoji Changelog CLI
Author: Yvonnick FRIN
Latest version: 1.0.1

# @gitmoji-changelog/cli

> Generate changelog for repositories using [gitmoji](https://gitmoji.carloscuesta.me/) commits convention.

**DEPRECATED**: now use [gitmoji-changelog](https://www.npmjs.com/package/gitmoji-changelog)
npm package: @gitmoji/commit-types
Description: gitmoji styles commit types
Author: arvinxx
Latest version: 1.1.5

# @gitmoji/commit-types

[![NPM version][type-image]][type-url] [![NPM downloads][download-image]][download-url] [![semantic-release][semantic-release]][semantic-release-repo] ![][license-url]

Gitmoji styles Commit Types

## Signature

```typescript
type CommitTypes =
  | 'feat'           // Introducing new features
  | 'fix'            // Fixing a bug
  | 'refactor'       // Refactoring code (Not Introducing features or fix)
  | 'docs'           // add documents
  | 'test'           // Adding unit tests or e2e test
  | 'perf'           // Improving performance
  | 'revert'         // Reverting changes or commits
  | 'style'          // Updating the UI and style files
  | 'build'          // build artifacts
  | 'ci'             // working about CI build system
  | 'wip'            // Work in progress
  | 'chore';         // Work with configuration or other stuff
```

[license-url]: https://img.shields.io/github/license/arvinxx/commit-gitmoji

<!-- npm url -->

[type-image]: http://img.shields.io/npm/v/@gitmoji/commit-types.svg?style=flat-square&color=deepgreen&label=latest
[type-url]: http://npmjs.org/package/@gitmoji/commit-types
[download-image]: https://img.shields.io/npm/dm/html2sketch.svg?style=flat-square
[download-url]: https://npmjs.org/package/html2sketch

<!-- semantic-release -->

[semantic-release]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
[semantic-release-repo]: https://github.com/semantic-release/semantic-release

## License

[MIT](../../LICENSE) ® Arvin Xu
npm package: @gitmoji/template
Description: a template for gitmoji commit workflow
Author: Arvin Xu
Latest version: 4.2.3

# Gitmoji Commit Workflow Template

[![Gitmoji][gitmoji]][gitmoji-url] [![semantic-release][semantic-release]][semantic-release-repo] ![][license-url]

[![Release CI][release-ci]][deploy-ci-url]

<!-- badge -->

[gitmoji]: https://img.shields.io/badge/gitmoji-%20😜%20😍-FFDD67.svg
[gitmoji-url]: https://gitmoji.carloscuesta.me/
[semantic-release]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg
[semantic-release-repo]: https://github.com/semantic-release/semantic-release
[license-url]: https://img.shields.io/github/license/arvinxx/gitmoji-commit-workflow-template

<!-- Github CI -->

[release-ci]: https://github.com/arvinxx/gitmoji-commit-workflow-template/workflows/Release%20CI/badge.svg
[deploy-ci-url]: https://github.com/arvinxx/gitmoji-commit-workflow-template/actions?query=workflow%3A%22Release+CI%22

## 模板说明

### 主分支

版本号: [![NPM version][version-image]][version-url]

master 分支作为随时可发布分支,对应 npm 包相应的版本

### alpha 分支

版本号: [![NPM version][alpha-version-image]][version-url]

alpha 版本一般为内部预览版

### beta 分支

版本号: [![NPM version][beta-version-image]][version-url]

beta 版本一般为外部预览版 即常说的公测版本

### next 分支

版本号: [![NPM version][next-version-image]][version-url]

next 分支会抢占主分支版本号, 因此默认情况下需要带上 `.rc` 后缀

在 next 分支下任何 `feat` 和 `fix` 都只会增加 `.rc.x` 位数,不会增加前面位次的版本号

当合并到 master 分支时, 将会自动发布当前版本号的正式版本

## License

[MIT](./LICENSE) ® Arvin Xu

[version-image]: http://img.shields.io/npm/v/@gitmoji/template.svg?color=deepgreen&label=latest
[next-version-image]: https://img.shields.io/npm/v/@gitmoji/template/next?color=deepgreen&label=next
[alpha-version-image]: https://img.shields.io/npm/v/@gitmoji/template/alpha?color=deepgreen&label=alpha
[beta-version-image]: https://img.shields.io/npm/v/@gitmoji/template/beta?color=deepgreen&label=beta
[version-url]: http://npmjs.org/package/@gitmoji/template
npm package: @gitmyabi-stg/circle--usdc
Description: Auto-generated TypeScript type bindings for usdc (build etherscan-usdc-1775818856300, commit 2e72cdd, branch etherscan)
Latest version: 0.0.1

# @gitmyabi-stg/circle--usdc

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

- **Build ID**: `etherscan-usdc-1775818856300`
- **Build Number**: 1
- **Commit**: `2e72cdd`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/circle--usdc@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/circle--usdc';

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/circle--usdc';

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/circle--usdc';

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/gabrielbrs-team-02096643--hardhat-test
Description: Auto-generated TypeScript type bindings for hardhat-test (build a7dbbd74-d8ef-43f4-afc7-eeb5e59f12f3, commit 71cba5e, branch main)
Latest version: 0.0.3

# @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test

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

- **Build ID**: `a7dbbd74-d8ef-43f4-afc7-eeb5e59f12f3`
- **Build Number**: 3
- **Commit**: `71cba5e`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test@0.0.3
```

## Usage

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

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/gabrielbrs-team-02096643--hardhat-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-stg/gabrielbrs-team-02096643--hardhat-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-stg/gabrielbrs-team-02096643--hardhat-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 4 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test
Description: Auto-generated TypeScript type bindings for hardhat-test-test (build 321784b3-9706-4ffa-add9-c0562b1b3daf, commit 71cba5e, branch main)
Latest version: 0.0.1

# @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test

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

- **Build ID**: `321784b3-9706-4ffa-add9-c0562b1b3daf`
- **Build Number**: 1
- **Commit**: `71cba5e`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test@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/gabrielbrs-team-02096643--hardhat-test-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-stg/gabrielbrs-team-02096643--hardhat-test-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-stg/gabrielbrs-team-02096643--hardhat-test-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 4 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test-test
Description: Auto-generated TypeScript type bindings for hardhat-test-test-test (build 9c7c2dce-0f15-4545-bb90-a6bb664a2ecf, commit 71cba5e, branch main)
Latest version: 0.0.1

# @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test-test

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

- **Build ID**: `9c7c2dce-0f15-4545-bb90-a6bb664a2ecf`
- **Build Number**: 1
- **Commit**: `71cba5e`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/gabrielbrs-team-02096643--hardhat-test-test-test@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/gabrielbrs-team-02096643--hardhat-test-test-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-stg/gabrielbrs-team-02096643--hardhat-test-test-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-stg/gabrielbrs-team-02096643--hardhat-test-test-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 4 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/merl111s-team--bridge-evm-test-gma
Description: Auto-generated TypeScript type bindings for bridge-evm-test-gma (build 7f59b738-1e6c-4cd6-b9e0-a64eefb17b2c, commit 0fd71d1, branch main)
Latest version: 0.0.3

# @gitmyabi-stg/merl111s-team--bridge-evm-test-gma

Auto-generated TypeScript type bindings for **bridge-evm-test-gma**

- **Build ID**: `7f59b738-1e6c-4cd6-b9e0-a64eefb17b2c`
- **Build Number**: 3
- **Commit**: `0fd71d1`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 57

## Installation

```bash
npm install @gitmyabi-stg/merl111s-team--bridge-evm-test-gma@0.0.3
```

## Usage

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

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/merl111s-team--bridge-evm-test-gma';

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/merl111s-team--bridge-evm-test-gma';

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/merl111s-team--bridge-evm-test-gma';

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-stg/merl111s-team--gitmyabi-test
Description: Auto-generated TypeScript type bindings for gitmyabi-test (build 04fd9df0-a25a-4a36-ab4b-eeea13b68ff9, commit 8c069c6, branch main)
Latest version: 0.0.19

# @gitmyabi-stg/merl111s-team--gitmyabi-test

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

- **Build ID**: `04fd9df0-a25a-4a36-ab4b-eeea13b68ff9`
- **Build Number**: 19
- **Commit**: `8c069c6`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/merl111s-team--gitmyabi-test@0.0.19
```

## Usage

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

```typescript
import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { YourContract } from '@gitmyabi-stg/merl111s-team--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-stg/merl111s-team--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-stg/merl111s-team--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: @gitmyabi-stg/merl111s-team--gitmyabi-test-3
Description: Auto-generated TypeScript type bindings for gitmyabi-test-3 (build 0bf464b7-340a-4320-8951-8062ca4788e4, commit 8c069c6, branch main)
Latest version: 0.0.25

# @gitmyabi-stg/merl111s-team--gitmyabi-test-3

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

- **Build ID**: `0bf464b7-340a-4320-8951-8062ca4788e4`
- **Build Number**: 25
- **Commit**: `8c069c6`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/merl111s-team--gitmyabi-test-3@0.0.25
```

## Usage

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

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

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/merl111s-team--gitmyabi-test-3';

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/merl111s-team--gitmyabi-test-3';

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/merl111s-team-04e1c75c--bridge-evm-test-gma
Description: Auto-generated TypeScript type bindings for bridge-evm-test-gma (build e9557c83-18d8-410b-a3b6-0b09b76c5abd, commit 0fd71d1, branch main)
Latest version: 0.0.2

# @gitmyabi-stg/merl111s-team-04e1c75c--bridge-evm-test-gma

Auto-generated TypeScript type bindings for **bridge-evm-test-gma**

- **Build ID**: `e9557c83-18d8-410b-a3b6-0b09b76c5abd`
- **Build Number**: 2
- **Commit**: `0fd71d1`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 57

## Installation

```bash
npm install @gitmyabi-stg/merl111s-team-04e1c75c--bridge-evm-test-gma@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/merl111s-team-04e1c75c--bridge-evm-test-gma';

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/merl111s-team-04e1c75c--bridge-evm-test-gma';

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/merl111s-team-04e1c75c--bridge-evm-test-gma';

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-stg/mialbus-team-22a8d62b--bridge-evm-contracts
Description: Auto-generated TypeScript type bindings for bridge-evm-contracts (build 772a5b4c-c763-471a-ac96-89fa9f66f2f1, commit a70b698, branch main)
Latest version: 0.0.2

# @gitmyabi-stg/mialbus-team-22a8d62b--bridge-evm-contracts

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

- **Build ID**: `772a5b4c-c763-471a-ac96-89fa9f66f2f1`
- **Build Number**: 2
- **Commit**: `a70b698`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 57

## Installation

```bash
npm install @gitmyabi-stg/mialbus-team-22a8d62b--bridge-evm-contracts@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/mialbus-team-22a8d62b--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-stg/mialbus-team-22a8d62b--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-stg/mialbus-team-22a8d62b--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-stg/team-alpha--gitmyabi-hardhat-test-tour-demo
Description: Auto-generated TypeScript type bindings for gitmyabi-hardhat-test-tour-demo (build b290afd1-70cb-4a54-a956-bbfb5d32a2d7, commit 55895fe, branch main)
Latest version: 0.0.1

# @gitmyabi-stg/team-alpha--gitmyabi-hardhat-test-tour-demo

Auto-generated TypeScript type bindings for **gitmyabi-hardhat-test-tour-demo**

- **Build ID**: `b290afd1-70cb-4a54-a956-bbfb5d32a2d7`
- **Build Number**: 1
- **Commit**: `55895fe`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/team-alpha--gitmyabi-hardhat-test-tour-demo@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/team-alpha--gitmyabi-hardhat-test-tour-demo';

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/team-alpha--gitmyabi-hardhat-test-tour-demo';

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/team-alpha--gitmyabi-hardhat-test-tour-demo';

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/tether--contracts
Description: Auto-generated TypeScript type bindings for contracts (build etherscan-contracts-1775706715236, commit 701dfd7, branch etherscan)
Latest version: 0.0.4

# @gitmyabi-stg/tether--contracts

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

- **Build ID**: `etherscan-contracts-1775706715236`
- **Build Number**: 1
- **Commit**: `701dfd7`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/tether--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-stg/tether--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/tether--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/tether--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/tether--usdt
Description: Auto-generated TypeScript type bindings for usdt (build etherscan-usdt-1775818700344, commit e539ffd, branch etherscan)
Latest version: 0.0.1

# @gitmyabi-stg/tether--usdt

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

- **Build ID**: `etherscan-usdt-1775818700344`
- **Build Number**: 1
- **Commit**: `e539ffd`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 1

## Installation

```bash
npm install @gitmyabi-stg/tether--usdt@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/tether--usdt';

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/tether--usdt';

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/tether--usdt';

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/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour
Description: Auto-generated TypeScript type bindings for gitmyabi-hardhat-test-tour (build ab2d338b-2d57-4517-89d9-2e896b9c58dd, commit 55895fe, branch main)
Latest version: 0.0.2

# @gitmyabi-stg/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour

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

- **Build ID**: `ab2d338b-2d57-4517-89d9-2e896b9c58dd`
- **Build Number**: 2
- **Commit**: `55895fe`
- **Branch**: `main`
- **Target**: `ethers-v6`
- **Contracts**: 4

## Installation

```bash
npm install @gitmyabi-stg/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour@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/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour';

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/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour';

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/thedanielmarks-team-10fb70f4--gitmyabi-hardhat-test-tour';

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--l2-contracts
Description: Auto-generated TypeScript type bindings for l2-contracts (build etherscan-l2-contracts-1775710816893, commit b4c5bb1, branch etherscan)
Latest version: 0.0.1

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

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

- **Build ID**: `etherscan-l2-contracts-1775710816893`
- **Build Number**: 1
- **Commit**: `b4c5bb1`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 2

## Installation

```bash
npm install @gitmyabi-stg/uniswap--l2-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--l2-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--l2-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--l2-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 2 contract(s) generated from ABI artifacts.

## License

MIT
npm package: @gitmyabi-stg/uniswap--protocol-fee
Description: Auto-generated TypeScript type bindings for protocol-fee (build etherscan-protocol-fee-1775817418441, commit bde784b, branch etherscan)
Latest version: 0.0.1

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

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

- **Build ID**: `etherscan-protocol-fee-1775817418441`
- **Build Number**: 1
- **Commit**: `bde784b`
- **Branch**: `etherscan`
- **Target**: `ethers-v6`
- **Contracts**: 5

## Installation

```bash
npm install @gitmyabi-stg/uniswap--protocol-fee@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--protocol-fee';

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--protocol-fee';

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--protocol-fee';

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 5 contract(s) generated from ABI artifacts.

## License

MIT