opnet 1.6.5 → 1.6.7

package/README.md

@@ -59,7 +59,7 @@ lines of code:
 ```typescript
 import {
     getContract,
-    IOP_20Contract,
+    IOP20Contract,
     JSONRpcProvider,
     OP_20_ABI,
     TransactionParameters,
@@ -73,7 +73,7 @@ const provider: JSONRpcProvider = new JSONRpcProvider('https://regtest.opnet.org
 const wallet: Wallet = Configs.WALLET;
 const yourAddress: Address = new Address(wallet.keypair.publicKey);
 
-const example: IOP_20Contract = getContract<IOP_20Contract>(
+const example: IOP20Contract = getContract<IOP20Contract>(
     'bcrt1plz0svv3wl05qrrv0dx8hvh5mgqc7jf3mhqgtw8jnj3l3d3cs6lzsfc3mxh',
     OP_20_ABI,
     provider,

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.6.5";
+export declare const version = "1.6.7";

package/browser/abi/shared/interfaces/generic/IStackingContract.d.ts

@@ -1,21 +1,15 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
 export interface IStackingContract {
-    stake(amount: bigint): Promise<CallResult<{
-        success: boolean;
-    }>>;
-    unstake(): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    stake(amount: bigint): Promise<CallResult>;
+    unstake(): Promise<CallResult>;
     stakedAmount(address: Address): Promise<CallResult<{
         amount: bigint;
     }>>;
     stakedReward(address: Address): Promise<CallResult<{
         amount: bigint;
     }>>;
-    claim(): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    claim(): Promise<CallResult>;
     rewardPool(): Promise<CallResult<{
         reward: bigint;
     }>>;

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

@@ -1,13 +1,9 @@
 import { Address } from '@btc-vision/transaction';
 import { Admin, CallResult, ChangeAdmin } from '../../../../opnet.js';
-import { IOP_20Contract } from '../opnet/IOP_20Contract.js';
-export type AdminMint = CallResult<{
-    success: boolean;
-}>;
-export type AdminBurn = CallResult<{
-    success: boolean;
-}>;
-export interface IMoto extends IOP_20Contract {
+import { IOP20Contract } from '../opnet/IOP20Contract.js';
+export type AdminMint = CallResult;
+export type AdminBurn = CallResult;
+export interface IMoto extends IOP20Contract {
     admin(): Promise<Admin>;
     changeAdmin(newAdmin: Address): Promise<ChangeAdmin>;
     adminMint(to: Address, amount: bigint): Promise<AdminMint>;

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

@@ -8,81 +8,70 @@ export type OwnershipTransferredEvent = {
 export type Owner = CallResult<{
     owner: Address;
 }, OPNetEvent<never>[]>;
-export type RenounceOwnership = CallResult<{
-    success: boolean;
-}, OPNetEvent<OwnershipTransferredEvent>[]>;
-export type TransferOwnership = CallResult<{
-    success: boolean;
-}, OPNetEvent<OwnershipTransferredEvent>[]>;
+export type RenounceOwnership = CallResult<{}, OPNetEvent<OwnershipTransferredEvent>[]>;
+export type TransferOwnership = CallResult<{}, OPNetEvent<OwnershipTransferredEvent>[]>;
 interface IOwnable extends IOP_NETContract {
     owner(): Promise<Owner>;
     renounceOwnership(): Promise<RenounceOwnership>;
     transferOwnership(newOwner: Address): Promise<TransferOwnership>;
 }
-export type LogPoolAdditionEvent = {
+export type PoolAddedEvent = {
     readonly poolId: number;
     readonly allocPoint: bigint;
     readonly lpToken: Address;
 };
-export type LogInitEvent = {};
-export type LogUpdatePoolEvent = {
+export type InitializedEvent = {};
+export type PoolUpdatedEvent = {
     readonly poolId: number;
     readonly lastRewardBlock: bigint;
     readonly lpSupply: bigint;
     readonly accMotoPerShare: bigint;
 };
-export type StakedBTCEvent = {
+export type BTCStakedEvent = {
     readonly user: Address;
     readonly netAmount: bigint;
     readonly stakeTxId: bigint;
     readonly stakeIndex: bigint;
 };
-export type UserOverwriteBTCStakeEvent = {
-    readonly user: Address;
-    readonly storedTxId: bigint;
-    readonly storedIndex: bigint;
-};
-export type UnstakedBTCEvent = {
+export type BTCUnstakedEvent = {
     readonly user: Address;
     readonly pendingMoto: bigint;
     readonly storedTxId: bigint;
     readonly storedIndex: bigint;
 };
-export type RemovedBTCStakeEvent = {
+export type BTCStakeRemovedEvent = {
     readonly user: Address;
     readonly storedTxId: bigint;
     readonly storedIndex: bigint;
 };
-export type LogSetPoolEvent = {
+export type PoolSetEvent = {
     readonly poolId: number;
     readonly allocPoint: bigint;
 };
-export type DepositEvent = {
+export type DepositedEvent = {
     readonly user: Address;
     readonly poolId: number;
     readonly amount: bigint;
     readonly to: Address;
 };
-export type WithdrawEvent = {
+export type WithdrawnEvent = {
     readonly user: Address;
     readonly poolId: number;
     readonly amount: bigint;
     readonly to: Address;
 };
-export type HarvestEvent = {
+export type HarvestedEvent = {
     readonly user: Address;
     readonly poolId: number;
     readonly amount: bigint;
 };
-export type EmergencyWithdrawEvent = {
+export type EmergencyWithdrawnEvent = {
     readonly user: Address;
     readonly poolId: number;
     readonly amount: bigint;
     readonly to: Address;
 };
-export type Initialize = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogPoolAdditionEvent | LogInitEvent>[]>;
+export type Initialize = CallResult<{}, OPNetEvent<PoolAddedEvent | InitializedEvent>[]>;
 export type TotalAllocPoint = CallResult<{
     totalAllocPoint: bigint;
 }, OPNetEvent<never>[]>;
@@ -134,56 +123,26 @@ export type GetStakingIndex = CallResult<{
 export type TotalBTCStaked = CallResult<{
     totalBTCStaked: bigint;
 }, OPNetEvent<never>[]>;
-export type StakeBTC = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | StakedBTCEvent | UserOverwriteBTCStakeEvent>[]>;
-export type UnstakeBTC = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | UnstakedBTCEvent>[]>;
-export type RemoveBTCStake = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | RemovedBTCStakeEvent>[]>;
-export type Add = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogPoolAdditionEvent>[]>;
-export type Set = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogSetPoolEvent>[]>;
+export type StakeBTC = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCStakedEvent | BTCStakeRemovedEvent>[]>;
+export type UnstakeBTC = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCUnstakedEvent>[]>;
+export type RemoveBTCStake = CallResult<{}, OPNetEvent<PoolUpdatedEvent | BTCStakeRemovedEvent>[]>;
+export type Add = CallResult<{}, OPNetEvent<PoolAddedEvent>[]>;
+export type Set = CallResult<{}, OPNetEvent<PoolSetEvent>[]>;
 export type UpdatePool = CallResult<{
     accMotoPerShare: bigint;
     lastRewardBlock: bigint;
     allocPoint: bigint;
-}, OPNetEvent<LogUpdatePoolEvent>[]>;
-export type MassUpdatePools = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent>[]>;
-export type Deposit = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | DepositEvent>[]>;
-export type Withdraw = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | WithdrawEvent>[]>;
-export type Harvest = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | HarvestEvent>[]>;
-export type WithdrawAndHarvest = CallResult<{
-    success: boolean;
-}, OPNetEvent<LogUpdatePoolEvent | WithdrawEvent | HarvestEvent>[]>;
-export type EmergencyWithdraw = CallResult<{
-    success: boolean;
-}, OPNetEvent<EmergencyWithdrawEvent>[]>;
-export type SetMotoPerBlock = CallResult<{
-    success: boolean;
-}, OPNetEvent<never>[]>;
-export type SetBonusEndBlock = CallResult<{
-    success: boolean;
-}, OPNetEvent<never>[]>;
-export type SetBonusMultiplier = CallResult<{
-    success: boolean;
-}, OPNetEvent<never>[]>;
-export type SetDev = CallResult<{
-    success: boolean;
-}, OPNetEvent<never>[]>;
+}, OPNetEvent<PoolUpdatedEvent>[]>;
+export type MassUpdatePools = CallResult<{}, OPNetEvent<PoolUpdatedEvent>[]>;
+export type Deposit = CallResult<{}, OPNetEvent<PoolUpdatedEvent | DepositedEvent>[]>;
+export type Withdraw = CallResult<{}, OPNetEvent<PoolUpdatedEvent | WithdrawnEvent>[]>;
+export type Harvest = CallResult<{}, OPNetEvent<PoolUpdatedEvent | HarvestedEvent>[]>;
+export type WithdrawAndHarvest = CallResult<{}, OPNetEvent<PoolUpdatedEvent | WithdrawnEvent | HarvestedEvent>[]>;
+export type EmergencyWithdraw = CallResult<{}, OPNetEvent<EmergencyWithdrawnEvent>[]>;
+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 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>;

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

@@ -14,9 +14,7 @@ export interface IMotoswapFactoryContract extends IOP_NETContract {
     createPool(token0: Address, token1: Address): Promise<CallResult<{
         address: Address;
     }, [OPNetEvent<PoolCreatedEvent>]>>;
-    setStakingContractAddress(stakingContractAddress: Address): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    setStakingContractAddress(stakingContractAddress: Address): Promise<CallResult>;
     getStakingContractAddress(): Promise<CallResult<{
         stakingContractAddress: Address;
     }>>;

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

@@ -1,23 +1,24 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
 import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
-import { IOP_20Contract } from '../opnet/IOP_20Contract.js';
+import { IOP20Contract } from '../opnet/IOP20Contract.js';
 export type Reserves = {
     readonly reserve0: bigint;
     readonly reserve1: bigint;
     readonly blockTimestampLast: bigint;
 };
-export type PoolBurnEvent = {
+export type LiquidityRemovedEvent = {
     readonly sender: Address;
     readonly amount0: bigint;
     readonly amount1: bigint;
+    readonly to: Address;
 };
-export type PoolMintEvent = {
+export type LiquidityAddedEvent = {
     readonly sender: Address;
     readonly amount0: bigint;
     readonly amount1: bigint;
 };
-export type SwapEvent = {
+export type SwappedEvent = {
     readonly sender: Address;
     readonly amount0In: bigint;
     readonly amount1In: bigint;
@@ -25,7 +26,7 @@ export type SwapEvent = {
     readonly amount1Out: bigint;
     readonly to: Address;
 };
-export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mint'> {
+export interface IMotoswapPoolContract extends Omit<IOP20Contract, 'burn' | 'mint'> {
     token0(): Promise<CallResult<{
         token0: Address;
     }>>;
@@ -33,27 +34,19 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
         token1: Address;
     }>>;
     getReserves(): Promise<CallResult<Reserves>>;
-    swap(amount0Out: bigint, amount1Out: bigint, to: string, data: Uint8Array): Promise<CallResult<{
-        success: boolean;
-    }, [
-        OPNetEvent<SwapEvent>
-    ]>>;
-    skim(): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    swap(amount0Out: bigint, amount1Out: bigint, to: string, data: Uint8Array): Promise<CallResult<{}, [OPNetEvent<SwappedEvent>]>>;
+    skim(): Promise<CallResult>;
     kLast(): Promise<CallResult<{
         kLast: bigint;
     }>>;
     burn(to: Address): Promise<CallResult<{
         amount0: bigint;
         amount1: bigint;
-    }, [OPNetEvent<PoolBurnEvent>]>>;
+    }, [OPNetEvent<LiquidityRemovedEvent>]>>;
     blockTimestampLast(): Promise<CallResult<{
         blockTimestampLast: bigint;
     }>>;
-    sync(): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    sync(): Promise<CallResult>;
     price0CumulativeLast(): Promise<CallResult<{
         price0CumulativeLast: bigint;
     }>>;
@@ -65,8 +58,6 @@ export interface IMotoswapPoolContract extends Omit<IOP_20Contract, 'burn' | 'mi
     }>>;
     mint(to: Address): Promise<CallResult<{
         liquidity: bigint;
-    }, [OPNetEvent<PoolMintEvent>]>>;
-    initialize(token0: Address, token1: Address): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    }, [OPNetEvent<LiquidityAddedEvent>]>>;
+    initialize(token0: Address, token1: Address): Promise<CallResult>;
 }

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

@@ -26,9 +26,7 @@ export interface IMotoswapRouterContract extends IOP_NETContract {
     getAmountsIn(amountOut: bigint, path: Address[]): Promise<CallResult<{
         amountsIn: bigint[];
     }>>;
-    swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: bigint, amountOutMin: bigint, path: Address[], to: Address, deadline: bigint): Promise<CallResult<{
-        success: boolean;
-    }>>;
+    swapExactTokensForTokensSupportingFeeOnTransferTokens(amountIn: bigint, amountOutMin: bigint, path: Address[], to: Address, deadline: bigint): Promise<CallResult>;
     factory(): Promise<CallResult<{
         factory: Address;
     }>>;

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

@@ -1,6 +1,6 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
-import { BalanceOf, TotalSupply } from '../opnet/IOP_20Contract.js';
+import { BalanceOf, TotalSupply } from '../opnet/IOP20Contract.js';
 import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
 export type Status = CallResult<{
     status: bigint;
@@ -11,9 +11,7 @@ interface IMotoswapReentrancyGuard extends IOP_NETContract {
 export type Admin = CallResult<{
     adminAddress: Address;
 }>;
-export type ChangeAdmin = CallResult<{
-    success: boolean;
-}>;
+export type ChangeAdmin = CallResult;
 interface IMotoswapOwnableReentrancyGuard extends IMotoswapReentrancyGuard {
     admin(): Promise<Admin>;
     changeAdmin(newAdmin: Address): Promise<ChangeAdmin>;
@@ -42,30 +40,14 @@ export type CalculateSlashingFee = CallResult<{
 export type EnabledRewardTokens = CallResult<{
     enabledRewardTokens: Address[];
 }>;
-export type Stake = CallResult<{
-    success: boolean;
-}>;
-export type Unstake = CallResult<{
-    success: boolean;
-}>;
-export type ClaimRewards = CallResult<{
-    success: boolean;
-}>;
-export type AdminAddRewardToken = CallResult<{
-    success: boolean;
-}>;
-export type AdminRemoveRewardToken = CallResult<{
-    success: boolean;
-}>;
-export type AdminChangeMotoAddress = CallResult<{
-    success: boolean;
-}>;
-export type AdminChangeLockupParameters = CallResult<{
-    success: boolean;
-}>;
-export type AdminEnableEmergencyWithdrawals = CallResult<{
-    success: boolean;
-}>;
+export type Stake = CallResult;
+export type Unstake = CallResult;
+export type ClaimRewards = CallResult;
+export type AdminAddRewardToken = CallResult;
+export type AdminRemoveRewardToken = CallResult;
+export type AdminChangeMotoAddress = CallResult;
+export type AdminChangeLockupParameters = CallResult;
+export type AdminEnableEmergencyWithdrawals = CallResult;
 export type RewardTokenAddedEvent = {
     readonly token: Address;
 };

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

@@ -1,9 +1,9 @@
 import { Address } from '@btc-vision/transaction';
 import { CallResult } from '../../../../contracts/CallResult.js';
 import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
-import { TransferEvent } from '../opnet/IOP_20Contract.js';
+import { TransferredEvent } from '../opnet/IOP20Contract.js';
 import { IOP_NETContract } from '../opnet/IOP_NETContract.js';
-export type LiquidityAddedEvent = {
+export type LiquidityAddedNativeEvent = {
     readonly totalTokensContributed: bigint;
     readonly virtualTokenExchanged: bigint;
     readonly totalSatoshisSpent: bigint;
@@ -12,7 +12,7 @@ export type LiquidityListedEvent = {
     readonly totalLiquidity: bigint;
     readonly provider: string;
 };
-export type LiquidityRemovedEvent = {
+export type LiquidityRemovedNativeEvent = {
     readonly providerId: bigint;
     readonly btcOwed: bigint;
     readonly tokenAmount: bigint;
@@ -57,34 +57,18 @@ export type FulfilledProviderEvent = {
     readonly canceled: boolean;
     readonly removalCompleted: boolean;
 };
-export type ReserveNativeSwap = CallResult<{
-    ok: boolean;
-}, OPNetEvent<LiquidityReservedEvent | ReservationCreatedEvent | TransferEvent | FulfilledProviderEvent>[]>;
-export type AddLiquidity = CallResult<{
-    ok: boolean;
-}, OPNetEvent<LiquidityAddedEvent | TransferEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
-export type RemoveLiquidity = CallResult<{
-    ok: boolean;
-}, OPNetEvent<LiquidityRemovedEvent | TransferEvent | FulfilledProviderEvent>[]>;
-export type ListLiquidity = CallResult<{
-    ok: boolean;
-}, OPNetEvent<LiquidityListedEvent>[]>;
-export type CancelListing = CallResult<{
-    ok: boolean;
-}, OPNetEvent<ListingCanceledEvent | TransferEvent | FulfilledProviderEvent>[]>;
-export type CreatePool = CallResult<{
-    ok: boolean;
-}, OPNetEvent<TransferEvent | LiquidityAddedEvent>[]>;
-export type SetFees = CallResult<{
-    ok: boolean;
-}, []>;
+export type ReserveNativeSwap = CallResult<{}, OPNetEvent<LiquidityReservedEvent | ReservationCreatedEvent | TransferredEvent | FulfilledProviderEvent>[]>;
+export type AddLiquidity = CallResult<{}, OPNetEvent<LiquidityAddedNativeEvent | TransferredEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
+export type RemoveLiquidity = CallResult<{}, OPNetEvent<LiquidityRemovedNativeEvent | TransferredEvent | FulfilledProviderEvent>[]>;
+export type ListLiquidity = CallResult<{}, OPNetEvent<LiquidityListedEvent>[]>;
+export type CancelListing = CallResult<{}, OPNetEvent<ListingCanceledEvent | TransferredEvent | FulfilledProviderEvent>[]>;
+export type CreatePool = CallResult<{}, OPNetEvent<TransferredEvent | LiquidityAddedNativeEvent>[]>;
+export type SetFees = CallResult;
 export type GetFees = CallResult<{
     reservationBaseFee: bigint;
     priorityQueueBaseFee: bigint;
 }, []>;
-export type Swap = CallResult<{
-    ok: boolean;
-}, OPNetEvent<SwapExecutedEvent | TransferEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
+export type Swap = CallResult<{}, OPNetEvent<SwapExecutedEvent | TransferredEvent | ActivateProviderEvent | FulfilledProviderEvent>[]>;
 export type GetReserve = CallResult<{
     liquidity: bigint;
     reservedLiquidity: bigint;
@@ -154,8 +138,6 @@ export interface INativeSwapContract extends IOP_NETContract {
     getQueueDetails(token: Address): Promise<QueueDetails>;
     getPriorityQueueCost(token: Address): Promise<GetPriorityQueueCost>;
     getAntibotSettings(token: Address): Promise<AntiBotSettings>;
-    setStakingContractAddress(stakingContractAddress: Address): Promise<CallResult<{
-        ok: boolean;
-    }, []>>;
+    setStakingContractAddress(stakingContractAddress: Address): Promise<CallResult>;
     getStakingContractAddress(): Promise<StakingAddressResult>;
 }

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

@@ -0,0 +1,95 @@
+import { Address, AddressMap } from '@btc-vision/transaction';
+import { CallResult } from '../../../../contracts/CallResult.js';
+import { OPNetEvent } from '../../../../contracts/OPNetEvent.js';
+import { IOP_NETContract } from './IOP_NETContract.js';
+export type MintedEvent = {
+    to: Address;
+    amount: bigint;
+};
+export type TransferredEvent = {
+    from: Address;
+    to: Address;
+    amount: bigint;
+};
+export type BurnedEvent = {
+    from: Address;
+    amount: bigint;
+};
+export type ApprovedEvent = {
+    owner: Address;
+    spender: Address;
+    value: bigint;
+};
+export type Name = CallResult<{
+    name: string;
+}, []>;
+export type BalanceOf = CallResult<{
+    balance: bigint;
+}, []>;
+export type SymbolOf = CallResult<{
+    symbol: string;
+}, []>;
+export type TotalSupply = CallResult<{
+    totalSupply: bigint;
+}, []>;
+export type MaxSupply = CallResult<{
+    maximumSupply: bigint;
+}, []>;
+export type Decimals = CallResult<{
+    decimals: number;
+}, []>;
+export type TokenIcon = CallResult<{
+    icon: string;
+}, []>;
+export type DomainSeparator = CallResult<{
+    domainSeparator: Uint8Array;
+}, []>;
+export type NonceOf = CallResult<{
+    nonce: bigint;
+}, []>;
+export type TokenMetadata = CallResult<{
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: bigint;
+    maximumSupply: bigint;
+    icon: string;
+    domainSeparator: Uint8Array;
+}, [
+]>;
+export type SafeTransfer = CallResult<{}, [OPNetEvent<TransferredEvent>]>;
+export type SafeTransferFrom = CallResult<{}, [OPNetEvent<TransferredEvent>]>;
+export type IncreaseAllowance = CallResult<{}, [OPNetEvent<ApprovedEvent>]>;
+export type DecreaseAllowance = CallResult<{}, [OPNetEvent<ApprovedEvent>]>;
+export type IncreaseAllowanceBySignature = CallResult<{}, [OPNetEvent<ApprovedEvent>]>;
+export type DecreaseAllowanceBySignature = CallResult<{}, [OPNetEvent<ApprovedEvent>]>;
+export type Allowance = CallResult<{
+    remaining: bigint;
+}, []>;
+export type Burn = CallResult<{}, [OPNetEvent<BurnedEvent>]>;
+export type Mint = CallResult<{}, [OPNetEvent<MintedEvent>]>;
+export type Airdrop = CallResult<{}, OPNetEvent<MintedEvent>[]>;
+export type AirdropWithAmount = CallResult<{}, OPNetEvent<MintedEvent>[]>;
+export interface IOP20Contract extends IOP_NETContract {
+    balanceOf(account: Address): Promise<BalanceOf>;
+    name(): Promise<Name>;
+    symbol(): Promise<SymbolOf>;
+    totalSupply(): Promise<TotalSupply>;
+    maximumSupply(): Promise<MaxSupply>;
+    domainSeparator(): Promise<DomainSeparator>;
+    nonceOf(owner: Address): Promise<NonceOf>;
+    decimals(): Promise<Decimals>;
+    icon(): Promise<TokenIcon>;
+    safeTransfer(to: Address, amount: bigint, data: Uint8Array): Promise<SafeTransfer>;
+    safeTransferFrom(from: Address, to: Address, amount: bigint, data: Uint8Array): Promise<SafeTransferFrom>;
+    increaseAllowance(spender: Address, amount: bigint): Promise<IncreaseAllowance>;
+    decreaseAllowance(spender: Address, amount: bigint): Promise<DecreaseAllowance>;
+    metadata(): Promise<TokenMetadata>;
+    increaseAllowanceBySignature(owner: Address, spender: Address, amount: bigint, deadline: bigint, signature: Uint8Array): Promise<IncreaseAllowanceBySignature>;
+    decreaseAllowanceBySignature(owner: Address, spender: Address, amount: bigint, deadline: bigint, signature: Uint8Array): Promise<DecreaseAllowanceBySignature>;
+    allowance(owner: Address, spender: Address): Promise<Allowance>;
+    burn(value: bigint): Promise<Burn>;
+    mint(address: Address, value: bigint): Promise<Mint>;
+    airdrop(map: AddressMap<bigint>): Promise<Airdrop>;
+    airdropWithAmount(amount: bigint, addresses: Address[]): Promise<AirdropWithAmount>;
+}