opnet 1.7.34 → 1.8.0

package/README.md

@@ -1,126 +1,118 @@
-# OP_NET - Smart Contracts on Bitcoin L1
+# OPNet - Smart Contracts on Bitcoin L1
 
 ![Bitcoin](https://img.shields.io/badge/Bitcoin-000?style=for-the-badge&logo=bitcoin&logoColor=white)
 ![TypeScript](https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white)
 ![NodeJS](https://img.shields.io/badge/Node%20js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white)
 ![NPM](https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white)
-![Gulp](https://img.shields.io/badge/GULP-%23CF4647.svg?style=for-the-badge&logo=gulp&logoColor=white)
-![ESLint](https://img.shields.io/badge/ESLint-4B3263?style=for-the-badge&logo=eslint&logoColor=white)
 
 [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
 
-## Introduction
+The official client library for building Bitcoin-based applications on OPNet. Full TypeScript support with type-safe contract interactions.
 
-A complete, compact and simple library for the Bitcoin ecosystem, written in
-TypeScript. This library is designed to be easy to use and understand, while
-providing a comprehensive set of functions for creating, reading and
-manipulating Bitcoin transactions. This library is designed to be able to
-manipulate anything related to BSI (Bitcoin Smart Inscription), smart contracts,
-and other Bitcoin-related technologies.
+## Installation
 
-## Getting Started
-
-### Prerequisites
-
-- Node.js version 16.x or higher
-- npm (Node Package Manager)
-
-### Installation
-
-```shell
-npm i opnet
+```bash
+npm install opnet @btc-vision/transaction @btc-vision/bitcoin
 ```
 
-### Documentation
+## Documentation
 
-Documentation available at [https://dev.opnet.org](https://dev.opnet.org) or in
-the `docs/` directory of the repository.
+Check out the full documentation in [`/docs`](./docs)!
 
-#### Development
+- [Getting Started](./docs/getting-started/quick-start.md)
+- [Providers](./docs/providers/json-rpc-provider.md) - JSON-RPC & WebSocket connections
+- [Smart Contracts](./docs/contracts/overview.md) - Contract interactions & transactions
+- [UTXO Management](./docs/bitcoin/utxos.md) - Bitcoin UTXO handling
+- [Offline Signing](./docs/contracts/offline-signing.md) - Cold wallet support
+- [ABI Reference](./docs/abi-reference/abi-overview.md) - OP20, OP721, MotoSwap ABIs
+- [API Reference](./docs/api-reference/provider-api.md) - Full API documentation
 
-1. Clone the repository:
-    ```bash
-    git clone https://github.com/btc-vision/opnet.git
-    ```
-2. Navigate to the repository directory:
-    ```bash
-    cd opnet
-    ```
-3. Install the required dependencies:
-    ```bash
-    npm i
-    ```
+## RPC Endpoints
 
-## Example
+| Network | URL |
+|---------|-----|
+| Mainnet | `https://mainnet.opnet.org` |
+| Regtest | `https://regtest.opnet.org` |
 
-Calling a contract function from typescript/javascript is as simple as a few
-lines of code:
+## Quick Start
 
 ```typescript
-import {
-    getContract,
-    IOP20Contract,
-    JSONRpcProvider,
-    OP_20_ABI,
-    TransactionParameters,
-} from 'opnet';
-import { Configs } from '../configs/Configs.js';
-import { Address, Wallet } from '@btc-vision/transaction';
-import { Network } from '@btc-vision/bitcoin';
-
-const network: Network = Configs.NETWORK;
-const provider: JSONRpcProvider = new JSONRpcProvider('https://regtest.opnet.org', network);
-const wallet: Wallet = Configs.WALLET;
-const yourAddress: Address = new Address(wallet.keypair.publicKey);
-
-const example: IOP20Contract = getContract<IOP20Contract>(
-    'bcrt1plz0svv3wl05qrrv0dx8hvh5mgqc7jf3mhqgtw8jnj3l3d3cs6lzsfc3mxh',
+import { BitcoinUtils, getContract, IOP20Contract, JSONRpcProvider, OP_20_ABI } from 'opnet';
+import { AddressTypes, Mnemonic, MLDSASecurityLevel } from '@btc-vision/transaction';
+import { networks } from '@btc-vision/bitcoin';
+
+// Connect to OPNet
+const provider = new JSONRpcProvider('https://regtest.opnet.org', networks.regtest);
+
+// Create wallet from mnemonic
+const mnemonic = new Mnemonic(
+    'your twenty four word seed phrase goes here ...',
+    '',
+    networks.regtest,
+    MLDSASecurityLevel.LEVEL2,
+);
+const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+const myAddress = wallet.address;
+
+// Interact with a token contract
+const token = getContract<IOP20Contract>(
+    'op1...', // contract address
     OP_20_ABI,
     provider,
-    Configs.NETWORK,
-    yourAddress,
+    networks.regtest,
+    myAddress
 );
 
-const name = await example.name();
-const symbol = await example.symbol();
-const totalSupply = await example.totalSupply();
-const decimals = await example.decimals();
-const myBalance = await example.balanceOf(yourAddress);
-
-console.log('Name:', name.properties.name);
-console.log('Symbol:', symbol.properties.symbol);
-console.log('Total Supply:', totalSupply.properties.totalSupply);
-console.log('Decimals:', decimals.properties.decimals);
-console.log('My Balance:', myBalance.properties.balance);
-
-// You can also easily simulate & interact onchain!
-
-const transferSimulation = await example.transfer(yourAddress, 10000n);
-const params: TransactionParameters = {
-    signer: wallet.keypair, // The keypair that will sign the transaction
-    refundTo: wallet.p2tr, // Refund the rest of the funds to this address
-    maximumAllowedSatToSpend: 5000n, // The maximum we want to allocate to this transaction in satoshis
-    feeRate: 10, // We need to provide a fee rate
-    network: network, // The network we are operating on
-};
-
-const tx = await transferSimulation.sendTransaction(params);
-console.log('Transaction created!', tx);
+// Read token info
+const name = await token.name();
+const balance = await token.balanceOf(myAddress);
+
+console.log('Token:', name.properties.name);
+console.log('Balance:', balance.properties.balance);
+
+// Send a transaction (100 tokens with 8 decimals)
+const amount = BitcoinUtils.expandToDecimals(100, 8);
+const simulation = await token.transfer(recipientAddress, amount);
+
+if (simulation.revert) {
+    throw new Error(`Transfer would fail: ${simulation.revert}`);
+}
+
+const tx = await simulation.sendTransaction({
+    signer: wallet.keypair,
+    mldsaSigner: wallet.mldsaKeypair,
+    refundTo: wallet.p2tr,
+    maximumAllowedSatToSpend: 50000n,
+    feeRate: 10,
+    network: networks.regtest,
+});
+
+console.log('TX ID:', tx.transactionId);
 ```
 
-You can get the calldata generated by doing balanceExample.calldata and generate
-your transaction based on that. In scenarios where you are writing data
-on-chain, you must specify the sender in the getContract function. This is
-important for the simulation to pass.
+## Requirements
+
+- Node.js >= 24.0.0
+- TypeScript >= 5.9
+
+## Development
+
+```bash
+git clone https://github.com/btc-vision/opnet.git
+cd opnet
+npm install
+npm run build
+```
+
+## Links
+
+- [OPNet Website](https://opnet.org)
+- [GitHub](https://github.com/btc-vision/opnet)
 
-## Contribution
+## Contributing
 
-Contributions are welcome! Please read through the `CONTRIBUTING.md` file for
-guidelines on how to submit issues, feature requests, and pull requests. We
-appreciate your input and encourage you to help us improve OP_NET.
+Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 ## License
 
-This project is open source and available under the
-[Apache-2.0 License](LICENSE). If you have any suggestions or contributions,
-please feel free to submit a pull request.
+[Apache-2.0](LICENSE)

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.34";
+export declare const version = "1.8.0";

package/browser/abi/shared/interfaces/motoswap/IMotoChef.d.ts

@@ -144,6 +144,10 @@ export type SetMotoPerBlock = CallResult<{}, OPNetEvent<never>[]>;
 export type SetBonusEndBlock = CallResult<{}, OPNetEvent<never>[]>;
 export type SetBonusMultiplier = CallResult<{}, OPNetEvent<never>[]>;
 export type SetDev = CallResult<{}, OPNetEvent<never>[]>;
+export type OnOP20Received = CallResult<{
+    selector: Buffer;
+}, [
+]>;
 export interface IMotoChef extends IOwnable {
     initialize(motoAddress: Address, premineAmount: bigint, devAddress: Address, motoPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, treasuryAddress: string, BTCAllocPoint: bigint, MOTOAllocPoint: bigint): Promise<Initialize>;
     totalAllocPoint(): Promise<TotalAllocPoint>;
@@ -178,5 +182,6 @@ export interface IMotoChef extends IOwnable {
     setBonusEndBlock(bonusEndBlock: bigint): Promise<SetBonusEndBlock>;
     setBonusMultiplier(bonusMultiplier: bigint): Promise<SetBonusMultiplier>;
     setDev(devAddress: Address): Promise<SetDev>;
+    onOP20Received(operator: Address, from: Address, amount: bigint, data: Uint8Array): Promise<OnOP20Received>;
 }
 export {};

package/browser/abi/shared/interfaces/motoswap/IMotoChefFactory.d.ts

@@ -0,0 +1,98 @@
+import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
+import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
+export type TokenDeployedEvent = {
+    readonly deployer: Address;
+    readonly token: Address;
+    readonly name: string;
+    readonly symbol: string;
+};
+export type MotoChefDeployedEvent = {
+    readonly deployer: Address;
+    readonly token: Address;
+    readonly motoChef: Address;
+    readonly userBTCFeePercentage: bigint;
+    readonly farmName: string;
+};
+export type FactoryPausedEvent = {
+    readonly by: Address;
+};
+export type FactoryUnpausedEvent = {
+    readonly by: Address;
+};
+export type InitializeFactory = CallResult<{
+    success: boolean;
+}, []>;
+export type Owner = CallResult<{
+    owner: Address;
+}, []>;
+export type PauseFactory = CallResult<{
+    success: boolean;
+}, [OPNetEvent<FactoryPausedEvent>]>;
+export type UnpauseFactory = CallResult<{
+    success: boolean;
+}, [OPNetEvent<FactoryUnpausedEvent>]>;
+export type IsPaused = CallResult<{
+    isPaused: boolean;
+}, []>;
+export type GetTokenDeployer = CallResult<{
+    deployer: Address;
+}, []>;
+export type GetTokenOwner = CallResult<{
+    owner: Address;
+}, []>;
+export type DeployToken = CallResult<{
+    success: boolean;
+}, [OPNetEvent<TokenDeployedEvent>]>;
+export type DeployMotoChef = CallResult<{
+    success: boolean;
+}, [OPNetEvent<MotoChefDeployedEvent>]>;
+export type UpdateTokenOwner = CallResult<{
+    success: boolean;
+}, []>;
+export type GetUserTokens = CallResult<{
+    tokens: Buffer;
+}, []>;
+export type GetDeploymentInfo = CallResult<{
+    has: boolean;
+    token: Address;
+    motoChef: Address;
+    block: bigint;
+}, [
+]>;
+export type GetDeploymentsCount = CallResult<{
+    count: number;
+}, []>;
+export type GetDeploymentByIndex = CallResult<{
+    deployer: Address;
+    token: Address;
+    motoChef: Address;
+    block: bigint;
+}, [
+]>;
+export type GetTokenMotoChef = CallResult<{
+    motoChefAddress: Address;
+}, []>;
+export type OnOP20Received = CallResult<{
+    selector: Buffer;
+}, []>;
+export interface IMotoChefFactory extends IOP_NETContract {
+    owner(): Promise<Owner>;
+    initialize(motoTokenAddress: Address): Promise<InitializeFactory>;
+    pauseFactory(): Promise<PauseFactory>;
+    unpauseFactory(): Promise<UnpauseFactory>;
+    isPaused(): Promise<IsPaused>;
+    getTokenDeployer(tokenAddress: Address): Promise<GetTokenDeployer>;
+    getTokenOwner(tokenAddress: Address): Promise<GetTokenOwner>;
+    deployToken(maxSupply: bigint, decimals: number, name: string, symbol: string, initialMintTo: Address, initialMintAmount: bigint, freeMintSupply: bigint, freeMintPerTx: bigint, tokenOwner: Address): Promise<DeployToken>;
+    deployMotoChef(devAddress: Address, tokenPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, BTCAllocPoint: bigint, tokenAddress: Address, tokenAllocPoint: bigint, userBTCFeePercentage: bigint, userFeeRecipient: string, farmName: string, farmBanner: string, additionalPoolTokens: Address[], additionalPoolAllocPoints: bigint[]): Promise<DeployMotoChef>;
+    updateTokenOwner(tokenAddress: Address, newOwner: Address): Promise<UpdateTokenOwner>;
+    getUserTokens(deployer: Address): Promise<GetUserTokens>;
+    getDeploymentInfo(deployer: Address): Promise<GetDeploymentInfo>;
+    getDeploymentsCount(): Promise<GetDeploymentsCount>;
+    getDeploymentByIndex(index: number): Promise<GetDeploymentByIndex>;
+    getTokenMotoChef(tokenAddress: Address): Promise<GetTokenMotoChef>;
+    onOP20Received(operator: Address, from: Address, amount: bigint, data: Buffer): Promise<OnOP20Received>;
+}
+export default IMotoChefFactory;

package/browser/abi/shared/interfaces/motoswap/IOP20Factory.d.ts

@@ -0,0 +1,76 @@
+import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
+import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
+export type TokenDeployedEvent = {
+    readonly deployer: Address;
+    readonly token: Address;
+    readonly name: string;
+    readonly symbol: string;
+};
+export type FactoryPausedEvent = {
+    readonly by: Address;
+};
+export type FactoryUnpausedEvent = {
+    readonly by: Address;
+};
+export type Owner = CallResult<{
+    owner: Address;
+}, []>;
+export type PauseFactory = CallResult<{
+    success: boolean;
+}, [OPNetEvent<FactoryPausedEvent>]>;
+export type UnpauseFactory = CallResult<{
+    success: boolean;
+}, [OPNetEvent<FactoryUnpausedEvent>]>;
+export type IsPaused = CallResult<{
+    isPaused: boolean;
+}, []>;
+export type GetTokenDeployer = CallResult<{
+    deployer: Address;
+}, []>;
+export type GetTokenOwner = CallResult<{
+    owner: Address;
+}, []>;
+export type DeployToken = CallResult<{
+    success: boolean;
+}, [OPNetEvent<TokenDeployedEvent>]>;
+export type UpdateTokenOwner = CallResult<{
+    success: boolean;
+}, []>;
+export type GetUserTokens = CallResult<{
+    tokens: Buffer;
+}, []>;
+export type GetDeploymentInfo = CallResult<{
+    has: boolean;
+    token: Address;
+    block: bigint;
+}, []>;
+export type GetDeploymentsCount = CallResult<{
+    count: number;
+}, []>;
+export type GetDeploymentByIndex = CallResult<{
+    deployer: Address;
+    token: Address;
+    block: bigint;
+}, [
+]>;
+export type OnOP20Received = CallResult<{
+    selector: Buffer;
+}, []>;
+export interface IOP20Factory extends IOP_NETContract {
+    owner(): Promise<Owner>;
+    pauseFactory(): Promise<PauseFactory>;
+    unpauseFactory(): Promise<UnpauseFactory>;
+    isPaused(): Promise<IsPaused>;
+    getTokenDeployer(tokenAddress: Address): Promise<GetTokenDeployer>;
+    getTokenOwner(tokenAddress: Address): Promise<GetTokenOwner>;
+    deployToken(maxSupply: bigint, decimals: number, name: string, symbol: string, initialMintTo: Address, initialMintAmount: bigint, freeMintSupply: bigint, freeMintPerTx: bigint, tokenOwner: Address): Promise<DeployToken>;
+    updateTokenOwner(tokenAddress: Address, newOwner: Address): Promise<UpdateTokenOwner>;
+    getUserTokens(deployer: Address): Promise<GetUserTokens>;
+    getDeploymentInfo(deployer: Address): Promise<GetDeploymentInfo>;
+    getDeploymentsCount(): Promise<GetDeploymentsCount>;
+    getDeploymentByIndex(index: number): Promise<GetDeploymentByIndex>;
+    onOP20Received(operator: Address, from: Address, amount: bigint, data: Buffer): Promise<OnOP20Received>;
+}
+export default IOP20Factory;

package/browser/abi/shared/interfaces/motoswap/ITemplateMotoChef.d.ts

@@ -0,0 +1,49 @@
+import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
+import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { IMotoChef, InitializedEvent, PoolAddedEvent } from './IMotoChef.js';
+export type TemplateMotoChefInitializedEvent = {};
+export type TemplateMotoChefInitialize = CallResult<{}, OPNetEvent<PoolAddedEvent | InitializedEvent>[]>;
+export type GetFarmName = CallResult<{
+    name: string;
+}, OPNetEvent<never>[]>;
+export type GetFarmBanner = CallResult<{
+    banner: string;
+}, OPNetEvent<never>[]>;
+export type SetUserTokenAddress = CallResult<{}, OPNetEvent<never>[]>;
+export type TransferOwnershipToUser = CallResult<{}, OPNetEvent<never>[]>;
+export type UserFeeRecipient = CallResult<{
+    recipient: string;
+}, OPNetEvent<never>[]>;
+export type MotoSwapFeeRecipient = CallResult<{
+    recipient: string;
+}, OPNetEvent<never>[]>;
+export type OpnetFeeRecipient = CallResult<{
+    recipient: string;
+}, OPNetEvent<never>[]>;
+export type BtcFeePercentage = CallResult<{
+    percentage: bigint;
+}, OPNetEvent<never>[]>;
+export type GetFeeDistributionBps = CallResult<{
+    userFeeBps: bigint;
+    motoSwapFeeBps: bigint;
+    opnetFeeBps: bigint;
+    totalBps: bigint;
+}, OPNetEvent<never>[]>;
+export type TotalUserTokenStaked = CallResult<{
+    totalStaked: bigint;
+}, OPNetEvent<never>[]>;
+export interface ITemplateMotoChef extends Omit<IMotoChef, 'initialize'> {
+    initialize(userTokenAddress: Address, devAddress: Address, tokenPerBlock: bigint, bonusEndBlock: bigint, bonusMultiplier: bigint, BTCAllocPoint: bigint, lpTokenAddress: Address, tokenAllocPoint: bigint, userBTCFeePercentage: bigint, userFeeRecipient: string, motoSwapFeeRecipient: string, opnetFeeRecipient: string, farmName: string, farmBanner: string, additionalPoolTokens: Address[], additionalPoolAllocPoints: bigint[]): Promise<TemplateMotoChefInitialize>;
+    getFarmName(): Promise<GetFarmName>;
+    getFarmBanner(): Promise<GetFarmBanner>;
+    setUserTokenAddress(tokenAddress: Address): Promise<SetUserTokenAddress>;
+    transferOwnershipToUser(newOwner: Address): Promise<TransferOwnershipToUser>;
+    userFeeRecipient(): Promise<UserFeeRecipient>;
+    motoSwapFeeRecipient(): Promise<MotoSwapFeeRecipient>;
+    opnetFeeRecipient(): Promise<OpnetFeeRecipient>;
+    btcFeePercentage(): Promise<BtcFeePercentage>;
+    getFeeDistributionBps(): Promise<GetFeeDistributionBps>;
+    totalUserTokenStaked(): Promise<TotalUserTokenStaked>;
+}
+export default ITemplateMotoChef;

package/browser/abi/shared/interfaces/motoswap/ITemplateOP20.d.ts

@@ -0,0 +1,71 @@
+import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
+import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { IOP20Contract } from '../opnet/IOP20Contract.js';
+export type MintedEvent = {
+    readonly to: Address;
+    readonly amount: bigint;
+};
+export type FreeMintConfiguredEvent = {
+    readonly token: Address;
+    readonly supply: bigint;
+    readonly perTxLimit: bigint;
+};
+export type FreeMintClaimedEvent = {
+    readonly user: Address;
+    readonly token: Address;
+    readonly amount: bigint;
+};
+export type TokenOwnerTransferredEvent = {
+    readonly previousOwner: Address;
+    readonly newOwner: Address;
+};
+export type TemplateOP20Initialize = CallResult<{}, OPNetEvent<MintedEvent | FreeMintConfiguredEvent>[]>;
+export type TemplateOP20Mint = CallResult<{}, [OPNetEvent<MintedEvent>]>;
+export type GrantMinterRole = CallResult<{
+    success: boolean;
+}, []>;
+export type RevokeMinterRole = CallResult<{
+    success: boolean;
+}, []>;
+export type IsMinter = CallResult<{
+    isMinter: boolean;
+}, []>;
+export type TokenOwner = CallResult<{
+    owner: Address;
+}, []>;
+export type FactoryAddress = CallResult<{
+    factory: Address;
+}, []>;
+export type TemplateOP20Deployer = CallResult<{
+    deployer: Address;
+}, []>;
+export type TransferTokenOwner = CallResult<{
+    success: boolean;
+}, [
+    OPNetEvent<TokenOwnerTransferredEvent>
+]>;
+export type FreeMint = CallResult<{
+    success: boolean;
+}, [OPNetEvent<MintedEvent>]>;
+export type FreeMintInfo = CallResult<{
+    info: Buffer;
+}, []>;
+export type OnOP20Received = CallResult<{
+    selector: Buffer;
+}, []>;
+export interface ITemplateOP20 extends IOP20Contract {
+    initialize(maxSupply: bigint, decimals: number, name: string, symbol: string, initialMintTo: Address, initialMintAmount: bigint, freeMintSupply: bigint, freeMintPerTx: bigint, tokenOwner: Address): Promise<TemplateOP20Initialize>;
+    mint(to: Address, amount: bigint): Promise<TemplateOP20Mint>;
+    grantMinterRole(minter: Address): Promise<GrantMinterRole>;
+    revokeMinterRole(minter: Address): Promise<RevokeMinterRole>;
+    isMinter(account: Address): Promise<IsMinter>;
+    getTokenOwner(): Promise<TokenOwner>;
+    getFactoryAddress(): Promise<FactoryAddress>;
+    deployer(): Promise<TemplateOP20Deployer>;
+    transferTokenOwner(newOwner: Address): Promise<TransferTokenOwner>;
+    freeMint(amount: bigint): Promise<FreeMint>;
+    getFreeMintInfo(): Promise<FreeMintInfo>;
+    onOP20Received(operator: Address, from: Address, amount: bigint, data: Buffer): Promise<OnOP20Received>;
+}
+export default ITemplateOP20;

package/browser/abi/shared/interfaces/opnet/IExtendedOP721Contract.d.ts

@@ -1,7 +1,7 @@
 import { Address } from '../../../../../node_modules/@btc-vision/transaction/build/index.js';
 import { CallResult } from '../../../../contracts/CallResult.js';
 import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
-import { IOP721, TransferredEventNFT, URIEventNFT } from './IOP721Contract.js';
+import { IOP721Contract, TransferredEventNFT, URIEventNFT } from './IOP721Contract.js';
 export type MintStatusChangedEventNFT = {
     readonly enabled: boolean;
 };
@@ -20,16 +20,22 @@ export type ReservationExpiredEventNFT = {
     readonly block: bigint;
     readonly amountRecovered: bigint;
 };
-export type SetMintEnabled = CallResult<{}, OPNetEvent<MintStatusChangedEventNFT>[]>;
+export type SetMintEnabled = CallResult<{}, [OPNetEvent<MintStatusChangedEventNFT>]>;
 export type IsMintEnabled = CallResult<{
     enabled: boolean;
-}, OPNetEvent<never>[]>;
+}, [
+]>;
 export type ReserveNFT = CallResult<{
     readonly remainingPayment: bigint;
     readonly reservationBlock: bigint;
-}, OPNetEvent<ReservationCreatedEventNFT>[]>;
-export type ClaimNFT = CallResult<{}, OPNetEvent<ReservationClaimedEventNFT | TransferredEventNFT>[]>;
-export type PurgeExpiredNFT = CallResult<{}, OPNetEvent<ReservationExpiredEventNFT>[]>;
+}, [
+    OPNetEvent<ReservationCreatedEventNFT>
+]>;
+export type ClaimNFT = CallResult<{}, [
+    OPNetEvent<ReservationClaimedEventNFT>,
+    ...OPNetEvent<TransferredEventNFT>[]
+]>;
+export type PurgeExpiredNFT = CallResult<{}, [...OPNetEvent<ReservationExpiredEventNFT>[]]>;
 export type GetStatus = CallResult<{
     minted: bigint;
     reserved: bigint;
@@ -39,10 +45,11 @@ export type GetStatus = CallResult<{
     pricePerToken: bigint;
     reservationFeePercent: bigint;
     minReservationFee: bigint;
-}, OPNetEvent<never>[]>;
-export type AirdropNFT = CallResult<{}, OPNetEvent<TransferredEventNFT>[]>;
-export type SetTokenURI = CallResult<{}, OPNetEvent<URIEventNFT>[]>;
-export interface IExtendedOP721 extends IOP721 {
+}, [
+]>;
+export type AirdropNFT = CallResult<{}, [...OPNetEvent<TransferredEventNFT>[]]>;
+export type SetTokenURI = CallResult<{}, [OPNetEvent<URIEventNFT>]>;
+export interface IExtendedOP721Contract extends IOP721Contract {
     setMintEnabled(enabled: boolean): Promise<SetMintEnabled>;
     isMintEnabled(): Promise<IsMintEnabled>;
     airdrop(addresses: Address[], amounts: number[]): Promise<AirdropNFT>;
@@ -52,3 +59,4 @@ export interface IExtendedOP721 extends IOP721 {
     getStatus(): Promise<GetStatus>;
     setTokenURI(tokenId: bigint, uri: string): Promise<SetTokenURI>;
 }
+export type IExtendedOP721 = IExtendedOP721Contract;