uni-v3-subgraph/generated/Factory/Pool.ts

// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.

import {
  ethereum,
  JSONValue,
  TypedMap,
  Entity,
  Bytes,
  Address,
  BigInt,
} from "@graphprotocol/graph-ts";

export class Burn extends ethereum.Event {
  get params(): Burn__Params {
    return new Burn__Params(this);
  }
}

export class Burn__Params {
  _event: Burn;

  constructor(event: Burn) {
    this._event = event;
  }

  get owner(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get tickLower(): i32 {
    return this._event.parameters[1].value.toI32();
  }

  get tickUpper(): i32 {
    return this._event.parameters[2].value.toI32();
  }

  get amount(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }

  get amount0(): BigInt {
    return this._event.parameters[4].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[5].value.toBigInt();
  }
}

export class Collect extends ethereum.Event {
  get params(): Collect__Params {
    return new Collect__Params(this);
  }
}

export class Collect__Params {
  _event: Collect;

  constructor(event: Collect) {
    this._event = event;
  }

  get owner(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get recipient(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get tickLower(): i32 {
    return this._event.parameters[2].value.toI32();
  }

  get tickUpper(): i32 {
    return this._event.parameters[3].value.toI32();
  }

  get amount0(): BigInt {
    return this._event.parameters[4].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[5].value.toBigInt();
  }
}

export class CollectProtocol extends ethereum.Event {
  get params(): CollectProtocol__Params {
    return new CollectProtocol__Params(this);
  }
}

export class CollectProtocol__Params {
  _event: CollectProtocol;

  constructor(event: CollectProtocol) {
    this._event = event;
  }

  get sender(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get recipient(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get amount0(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }
}

export class Flash extends ethereum.Event {
  get params(): Flash__Params {
    return new Flash__Params(this);
  }
}

export class Flash__Params {
  _event: Flash;

  constructor(event: Flash) {
    this._event = event;
  }

  get sender(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get recipient(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get amount0(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }

  get paid0(): BigInt {
    return this._event.parameters[4].value.toBigInt();
  }

  get paid1(): BigInt {
    return this._event.parameters[5].value.toBigInt();
  }
}

export class IncreaseObservationCardinalityNext extends ethereum.Event {
  get params(): IncreaseObservationCardinalityNext__Params {
    return new IncreaseObservationCardinalityNext__Params(this);
  }
}

export class IncreaseObservationCardinalityNext__Params {
  _event: IncreaseObservationCardinalityNext;

  constructor(event: IncreaseObservationCardinalityNext) {
    this._event = event;
  }

  get observationCardinalityNextOld(): i32 {
    return this._event.parameters[0].value.toI32();
  }

  get observationCardinalityNextNew(): i32 {
    return this._event.parameters[1].value.toI32();
  }
}

export class Initialize extends ethereum.Event {
  get params(): Initialize__Params {
    return new Initialize__Params(this);
  }
}

export class Initialize__Params {
  _event: Initialize;

  constructor(event: Initialize) {
    this._event = event;
  }

  get sqrtPriceX96(): BigInt {
    return this._event.parameters[0].value.toBigInt();
  }

  get tick(): i32 {
    return this._event.parameters[1].value.toI32();
  }
}

export class Mint extends ethereum.Event {
  get params(): Mint__Params {
    return new Mint__Params(this);
  }
}

export class Mint__Params {
  _event: Mint;

  constructor(event: Mint) {
    this._event = event;
  }

  get sender(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get owner(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get tickLower(): i32 {
    return this._event.parameters[2].value.toI32();
  }

  get tickUpper(): i32 {
    return this._event.parameters[3].value.toI32();
  }

  get amount(): BigInt {
    return this._event.parameters[4].value.toBigInt();
  }

  get amount0(): BigInt {
    return this._event.parameters[5].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[6].value.toBigInt();
  }
}

export class SetFeeProtocol extends ethereum.Event {
  get params(): SetFeeProtocol__Params {
    return new SetFeeProtocol__Params(this);
  }
}

export class SetFeeProtocol__Params {
  _event: SetFeeProtocol;

  constructor(event: SetFeeProtocol) {
    this._event = event;
  }

  get feeProtocol0Old(): i32 {
    return this._event.parameters[0].value.toI32();
  }

  get feeProtocol1Old(): i32 {
    return this._event.parameters[1].value.toI32();
  }

  get feeProtocol0New(): i32 {
    return this._event.parameters[2].value.toI32();
  }

  get feeProtocol1New(): i32 {
    return this._event.parameters[3].value.toI32();
  }
}

export class Swap extends ethereum.Event {
  get params(): Swap__Params {
    return new Swap__Params(this);
  }
}

export class Swap__Params {
  _event: Swap;

  constructor(event: Swap) {
    this._event = event;
  }

  get sender(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get recipient(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get amount0(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }

  get sqrtPriceX96(): BigInt {
    return this._event.parameters[4].value.toBigInt();
  }

  get liquidity(): BigInt {
    return this._event.parameters[5].value.toBigInt();
  }

  get tick(): i32 {
    return this._event.parameters[6].value.toI32();
  }
}

export class Pool__burnResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    return map;
  }

  getAmount0(): BigInt {
    return this.value0;
  }

  getAmount1(): BigInt {
    return this.value1;
  }
}

export class Pool__collectResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    return map;
  }

  getAmount0(): BigInt {
    return this.value0;
  }

  getAmount1(): BigInt {
    return this.value1;
  }
}

export class Pool__collectProtocolResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    return map;
  }

  getAmount0(): BigInt {
    return this.value0;
  }

  getAmount1(): BigInt {
    return this.value1;
  }
}

export class Pool__mintResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    return map;
  }

  getAmount0(): BigInt {
    return this.value0;
  }

  getAmount1(): BigInt {
    return this.value1;
  }
}

export class Pool__observationsResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;
  value3: boolean;

  constructor(value0: BigInt, value1: BigInt, value2: BigInt, value3: boolean) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
    this.value3 = value3;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromSignedBigInt(this.value1));
    map.set("value2", ethereum.Value.fromUnsignedBigInt(this.value2));
    map.set("value3", ethereum.Value.fromBoolean(this.value3));
    return map;
  }

  getBlockTimestamp(): BigInt {
    return this.value0;
  }

  getTickCumulative(): BigInt {
    return this.value1;
  }

  getSecondsPerLiquidityCumulativeX128(): BigInt {
    return this.value2;
  }

  getInitialized(): boolean {
    return this.value3;
  }
}

export class Pool__observeResult {
  value0: Array<BigInt>;
  value1: Array<BigInt>;

  constructor(value0: Array<BigInt>, value1: Array<BigInt>) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromSignedBigIntArray(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigIntArray(this.value1));
    return map;
  }

  getTickCumulatives(): Array<BigInt> {
    return this.value0;
  }

  getSecondsPerLiquidityCumulativeX128s(): Array<BigInt> {
    return this.value1;
  }
}

export class Pool__positionsResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;
  value3: BigInt;
  value4: BigInt;

  constructor(
    value0: BigInt,
    value1: BigInt,
    value2: BigInt,
    value3: BigInt,
    value4: BigInt,
  ) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
    this.value3 = value3;
    this.value4 = value4;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    map.set("value2", ethereum.Value.fromUnsignedBigInt(this.value2));
    map.set("value3", ethereum.Value.fromUnsignedBigInt(this.value3));
    map.set("value4", ethereum.Value.fromUnsignedBigInt(this.value4));
    return map;
  }

  get_liquidity(): BigInt {
    return this.value0;
  }

  getFeeGrowthInside0LastX128(): BigInt {
    return this.value1;
  }

  getFeeGrowthInside1LastX128(): BigInt {
    return this.value2;
  }

  getTokensOwed0(): BigInt {
    return this.value3;
  }

  getTokensOwed1(): BigInt {
    return this.value4;
  }
}

export class Pool__protocolFeesResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    return map;
  }

  getToken0(): BigInt {
    return this.value0;
  }

  getToken1(): BigInt {
    return this.value1;
  }
}

export class Pool__slot0Result {
  value0: BigInt;
  value1: i32;
  value2: i32;
  value3: i32;
  value4: i32;
  value5: i32;
  value6: boolean;

  constructor(
    value0: BigInt,
    value1: i32,
    value2: i32,
    value3: i32,
    value4: i32,
    value5: i32,
    value6: boolean,
  ) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
    this.value3 = value3;
    this.value4 = value4;
    this.value5 = value5;
    this.value6 = value6;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromI32(this.value1));
    map.set(
      "value2",
      ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(this.value2)),
    );
    map.set(
      "value3",
      ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(this.value3)),
    );
    map.set(
      "value4",
      ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(this.value4)),
    );
    map.set(
      "value5",
      ethereum.Value.fromUnsignedBigInt(BigInt.fromI32(this.value5)),
    );
    map.set("value6", ethereum.Value.fromBoolean(this.value6));
    return map;
  }

  getSqrtPriceX96(): BigInt {
    return this.value0;
  }

  getTick(): i32 {
    return this.value1;
  }

  getObservationIndex(): i32 {
    return this.value2;
  }

  getObservationCardinality(): i32 {
    return this.value3;
  }

  getObservationCardinalityNext(): i32 {
    return this.value4;
  }

  getFeeProtocol(): i32 {
    return this.value5;
  }

  getUnlocked(): boolean {
    return this.value6;
  }
}

export class Pool__snapshotCumulativesInsideResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;

  constructor(value0: BigInt, value1: BigInt, value2: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromSignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromUnsignedBigInt(this.value1));
    map.set("value2", ethereum.Value.fromUnsignedBigInt(this.value2));
    return map;
  }

  getTickCumulativeInside(): BigInt {
    return this.value0;
  }

  getSecondsPerLiquidityInsideX128(): BigInt {
    return this.value1;
  }

  getSecondsInside(): BigInt {
    return this.value2;
  }
}

export class Pool__swapResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromSignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromSignedBigInt(this.value1));
    return map;
  }

  getAmount0(): BigInt {
    return this.value0;
  }

  getAmount1(): BigInt {
    return this.value1;
  }
}

export class Pool__ticksResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;
  value3: BigInt;
  value4: BigInt;
  value5: BigInt;
  value6: BigInt;
  value7: boolean;

  constructor(
    value0: BigInt,
    value1: BigInt,
    value2: BigInt,
    value3: BigInt,
    value4: BigInt,
    value5: BigInt,
    value6: BigInt,
    value7: boolean,
  ) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
    this.value3 = value3;
    this.value4 = value4;
    this.value5 = value5;
    this.value6 = value6;
    this.value7 = value7;
  }

  toMap(): TypedMap<string, ethereum.Value> {
    let map = new TypedMap<string, ethereum.Value>();
    map.set("value0", ethereum.Value.fromUnsignedBigInt(this.value0));
    map.set("value1", ethereum.Value.fromSignedBigInt(this.value1));
    map.set("value2", ethereum.Value.fromUnsignedBigInt(this.value2));
    map.set("value3", ethereum.Value.fromUnsignedBigInt(this.value3));
    map.set("value4", ethereum.Value.fromSignedBigInt(this.value4));
    map.set("value5", ethereum.Value.fromUnsignedBigInt(this.value5));
    map.set("value6", ethereum.Value.fromUnsignedBigInt(this.value6));
    map.set("value7", ethereum.Value.fromBoolean(this.value7));
    return map;
  }

  getLiquidityGross(): BigInt {
    return this.value0;
  }

  getLiquidityNet(): BigInt {
    return this.value1;
  }

  getFeeGrowthOutside0X128(): BigInt {
    return this.value2;
  }

  getFeeGrowthOutside1X128(): BigInt {
    return this.value3;
  }

  getTickCumulativeOutside(): BigInt {
    return this.value4;
  }

  getSecondsPerLiquidityOutsideX128(): BigInt {
    return this.value5;
  }

  getSecondsOutside(): BigInt {
    return this.value6;
  }

  getInitialized(): boolean {
    return this.value7;
  }
}

export class Pool extends ethereum.SmartContract {
  static bind(address: Address): Pool {
    return new Pool("Pool", address);
  }

  burn(tickLower: i32, tickUpper: i32, amount: BigInt): Pool__burnResult {
    let result = super.call(
      "burn",
      "burn(int24,int24,uint128):(uint256,uint256)",
      [
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount),
      ],
    );

    return new Pool__burnResult(result[0].toBigInt(), result[1].toBigInt());
  }

  try_burn(
    tickLower: i32,
    tickUpper: i32,
    amount: BigInt,
  ): ethereum.CallResult<Pool__burnResult> {
    let result = super.tryCall(
      "burn",
      "burn(int24,int24,uint128):(uint256,uint256)",
      [
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount),
      ],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__burnResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  collect(
    recipient: Address,
    tickLower: i32,
    tickUpper: i32,
    amount0Requested: BigInt,
    amount1Requested: BigInt,
  ): Pool__collectResult {
    let result = super.call(
      "collect",
      "collect(address,int24,int24,uint128,uint128):(uint128,uint128)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount0Requested),
        ethereum.Value.fromUnsignedBigInt(amount1Requested),
      ],
    );

    return new Pool__collectResult(result[0].toBigInt(), result[1].toBigInt());
  }

  try_collect(
    recipient: Address,
    tickLower: i32,
    tickUpper: i32,
    amount0Requested: BigInt,
    amount1Requested: BigInt,
  ): ethereum.CallResult<Pool__collectResult> {
    let result = super.tryCall(
      "collect",
      "collect(address,int24,int24,uint128,uint128):(uint128,uint128)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount0Requested),
        ethereum.Value.fromUnsignedBigInt(amount1Requested),
      ],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__collectResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  collectProtocol(
    recipient: Address,
    amount0Requested: BigInt,
    amount1Requested: BigInt,
  ): Pool__collectProtocolResult {
    let result = super.call(
      "collectProtocol",
      "collectProtocol(address,uint128,uint128):(uint128,uint128)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromUnsignedBigInt(amount0Requested),
        ethereum.Value.fromUnsignedBigInt(amount1Requested),
      ],
    );

    return new Pool__collectProtocolResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
    );
  }

  try_collectProtocol(
    recipient: Address,
    amount0Requested: BigInt,
    amount1Requested: BigInt,
  ): ethereum.CallResult<Pool__collectProtocolResult> {
    let result = super.tryCall(
      "collectProtocol",
      "collectProtocol(address,uint128,uint128):(uint128,uint128)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromUnsignedBigInt(amount0Requested),
        ethereum.Value.fromUnsignedBigInt(amount1Requested),
      ],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__collectProtocolResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  factory(): Address {
    let result = super.call("factory", "factory():(address)", []);

    return result[0].toAddress();
  }

  try_factory(): ethereum.CallResult<Address> {
    let result = super.tryCall("factory", "factory():(address)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  fee(): i32 {
    let result = super.call("fee", "fee():(uint24)", []);

    return result[0].toI32();
  }

  try_fee(): ethereum.CallResult<i32> {
    let result = super.tryCall("fee", "fee():(uint24)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toI32());
  }

  feeGrowthGlobal0X128(): BigInt {
    let result = super.call(
      "feeGrowthGlobal0X128",
      "feeGrowthGlobal0X128():(uint256)",
      [],
    );

    return result[0].toBigInt();
  }

  try_feeGrowthGlobal0X128(): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "feeGrowthGlobal0X128",
      "feeGrowthGlobal0X128():(uint256)",
      [],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  feeGrowthGlobal1X128(): BigInt {
    let result = super.call(
      "feeGrowthGlobal1X128",
      "feeGrowthGlobal1X128():(uint256)",
      [],
    );

    return result[0].toBigInt();
  }

  try_feeGrowthGlobal1X128(): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "feeGrowthGlobal1X128",
      "feeGrowthGlobal1X128():(uint256)",
      [],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  liquidity(): BigInt {
    let result = super.call("liquidity", "liquidity():(uint128)", []);

    return result[0].toBigInt();
  }

  try_liquidity(): ethereum.CallResult<BigInt> {
    let result = super.tryCall("liquidity", "liquidity():(uint128)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  maxLiquidityPerTick(): BigInt {
    let result = super.call(
      "maxLiquidityPerTick",
      "maxLiquidityPerTick():(uint128)",
      [],
    );

    return result[0].toBigInt();
  }

  try_maxLiquidityPerTick(): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "maxLiquidityPerTick",
      "maxLiquidityPerTick():(uint128)",
      [],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  mint(
    recipient: Address,
    tickLower: i32,
    tickUpper: i32,
    amount: BigInt,
    data: Bytes,
  ): Pool__mintResult {
    let result = super.call(
      "mint",
      "mint(address,int24,int24,uint128,bytes):(uint256,uint256)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount),
        ethereum.Value.fromBytes(data),
      ],
    );

    return new Pool__mintResult(result[0].toBigInt(), result[1].toBigInt());
  }

  try_mint(
    recipient: Address,
    tickLower: i32,
    tickUpper: i32,
    amount: BigInt,
    data: Bytes,
  ): ethereum.CallResult<Pool__mintResult> {
    let result = super.tryCall(
      "mint",
      "mint(address,int24,int24,uint128,bytes):(uint256,uint256)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromI32(tickLower),
        ethereum.Value.fromI32(tickUpper),
        ethereum.Value.fromUnsignedBigInt(amount),
        ethereum.Value.fromBytes(data),
      ],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__mintResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  observations(index: BigInt): Pool__observationsResult {
    let result = super.call(
      "observations",
      "observations(uint256):(uint32,int56,uint160,bool)",
      [ethereum.Value.fromUnsignedBigInt(index)],
    );

    return new Pool__observationsResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt(),
      result[3].toBoolean(),
    );
  }

  try_observations(
    index: BigInt,
  ): ethereum.CallResult<Pool__observationsResult> {
    let result = super.tryCall(
      "observations",
      "observations(uint256):(uint32,int56,uint160,bool)",
      [ethereum.Value.fromUnsignedBigInt(index)],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__observationsResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt(),
        value[3].toBoolean(),
      ),
    );
  }

  observe(secondsAgos: Array<BigInt>): Pool__observeResult {
    let result = super.call(
      "observe",
      "observe(uint32[]):(int56[],uint160[])",
      [ethereum.Value.fromUnsignedBigIntArray(secondsAgos)],
    );

    return new Pool__observeResult(
      result[0].toBigIntArray(),
      result[1].toBigIntArray(),
    );
  }

  try_observe(
    secondsAgos: Array<BigInt>,
  ): ethereum.CallResult<Pool__observeResult> {
    let result = super.tryCall(
      "observe",
      "observe(uint32[]):(int56[],uint160[])",
      [ethereum.Value.fromUnsignedBigIntArray(secondsAgos)],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__observeResult(
        value[0].toBigIntArray(),
        value[1].toBigIntArray(),
      ),
    );
  }

  positions(key: Bytes): Pool__positionsResult {
    let result = super.call(
      "positions",
      "positions(bytes32):(uint128,uint256,uint256,uint128,uint128)",
      [ethereum.Value.fromFixedBytes(key)],
    );

    return new Pool__positionsResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt(),
      result[3].toBigInt(),
      result[4].toBigInt(),
    );
  }

  try_positions(key: Bytes): ethereum.CallResult<Pool__positionsResult> {
    let result = super.tryCall(
      "positions",
      "positions(bytes32):(uint128,uint256,uint256,uint128,uint128)",
      [ethereum.Value.fromFixedBytes(key)],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__positionsResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt(),
        value[3].toBigInt(),
        value[4].toBigInt(),
      ),
    );
  }

  protocolFees(): Pool__protocolFeesResult {
    let result = super.call(
      "protocolFees",
      "protocolFees():(uint128,uint128)",
      [],
    );

    return new Pool__protocolFeesResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
    );
  }

  try_protocolFees(): ethereum.CallResult<Pool__protocolFeesResult> {
    let result = super.tryCall(
      "protocolFees",
      "protocolFees():(uint128,uint128)",
      [],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__protocolFeesResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  slot0(): Pool__slot0Result {
    let result = super.call(
      "slot0",
      "slot0():(uint160,int24,uint16,uint16,uint16,uint8,bool)",
      [],
    );

    return new Pool__slot0Result(
      result[0].toBigInt(),
      result[1].toI32(),
      result[2].toI32(),
      result[3].toI32(),
      result[4].toI32(),
      result[5].toI32(),
      result[6].toBoolean(),
    );
  }

  try_slot0(): ethereum.CallResult<Pool__slot0Result> {
    let result = super.tryCall(
      "slot0",
      "slot0():(uint160,int24,uint16,uint16,uint16,uint8,bool)",
      [],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__slot0Result(
        value[0].toBigInt(),
        value[1].toI32(),
        value[2].toI32(),
        value[3].toI32(),
        value[4].toI32(),
        value[5].toI32(),
        value[6].toBoolean(),
      ),
    );
  }

  snapshotCumulativesInside(
    tickLower: i32,
    tickUpper: i32,
  ): Pool__snapshotCumulativesInsideResult {
    let result = super.call(
      "snapshotCumulativesInside",
      "snapshotCumulativesInside(int24,int24):(int56,uint160,uint32)",
      [ethereum.Value.fromI32(tickLower), ethereum.Value.fromI32(tickUpper)],
    );

    return new Pool__snapshotCumulativesInsideResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt(),
    );
  }

  try_snapshotCumulativesInside(
    tickLower: i32,
    tickUpper: i32,
  ): ethereum.CallResult<Pool__snapshotCumulativesInsideResult> {
    let result = super.tryCall(
      "snapshotCumulativesInside",
      "snapshotCumulativesInside(int24,int24):(int56,uint160,uint32)",
      [ethereum.Value.fromI32(tickLower), ethereum.Value.fromI32(tickUpper)],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__snapshotCumulativesInsideResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt(),
      ),
    );
  }

  swap(
    recipient: Address,
    zeroForOne: boolean,
    amountSpecified: BigInt,
    sqrtPriceLimitX96: BigInt,
    data: Bytes,
  ): Pool__swapResult {
    let result = super.call(
      "swap",
      "swap(address,bool,int256,uint160,bytes):(int256,int256)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromBoolean(zeroForOne),
        ethereum.Value.fromSignedBigInt(amountSpecified),
        ethereum.Value.fromUnsignedBigInt(sqrtPriceLimitX96),
        ethereum.Value.fromBytes(data),
      ],
    );

    return new Pool__swapResult(result[0].toBigInt(), result[1].toBigInt());
  }

  try_swap(
    recipient: Address,
    zeroForOne: boolean,
    amountSpecified: BigInt,
    sqrtPriceLimitX96: BigInt,
    data: Bytes,
  ): ethereum.CallResult<Pool__swapResult> {
    let result = super.tryCall(
      "swap",
      "swap(address,bool,int256,uint160,bytes):(int256,int256)",
      [
        ethereum.Value.fromAddress(recipient),
        ethereum.Value.fromBoolean(zeroForOne),
        ethereum.Value.fromSignedBigInt(amountSpecified),
        ethereum.Value.fromUnsignedBigInt(sqrtPriceLimitX96),
        ethereum.Value.fromBytes(data),
      ],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__swapResult(value[0].toBigInt(), value[1].toBigInt()),
    );
  }

  tickBitmap(wordPosition: i32): BigInt {
    let result = super.call("tickBitmap", "tickBitmap(int16):(uint256)", [
      ethereum.Value.fromI32(wordPosition),
    ]);

    return result[0].toBigInt();
  }

  try_tickBitmap(wordPosition: i32): ethereum.CallResult<BigInt> {
    let result = super.tryCall("tickBitmap", "tickBitmap(int16):(uint256)", [
      ethereum.Value.fromI32(wordPosition),
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  tickSpacing(): i32 {
    let result = super.call("tickSpacing", "tickSpacing():(int24)", []);

    return result[0].toI32();
  }

  try_tickSpacing(): ethereum.CallResult<i32> {
    let result = super.tryCall("tickSpacing", "tickSpacing():(int24)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toI32());
  }

  ticks(tick: i32): Pool__ticksResult {
    let result = super.call(
      "ticks",
      "ticks(int24):(uint128,int128,uint256,uint256,int56,uint160,uint32,bool)",
      [ethereum.Value.fromI32(tick)],
    );

    return new Pool__ticksResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt(),
      result[3].toBigInt(),
      result[4].toBigInt(),
      result[5].toBigInt(),
      result[6].toBigInt(),
      result[7].toBoolean(),
    );
  }

  try_ticks(tick: i32): ethereum.CallResult<Pool__ticksResult> {
    let result = super.tryCall(
      "ticks",
      "ticks(int24):(uint128,int128,uint256,uint256,int56,uint160,uint32,bool)",
      [ethereum.Value.fromI32(tick)],
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new Pool__ticksResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt(),
        value[3].toBigInt(),
        value[4].toBigInt(),
        value[5].toBigInt(),
        value[6].toBigInt(),
        value[7].toBoolean(),
      ),
    );
  }

  token0(): Address {
    let result = super.call("token0", "token0():(address)", []);

    return result[0].toAddress();
  }

  try_token0(): ethereum.CallResult<Address> {
    let result = super.tryCall("token0", "token0():(address)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  token1(): Address {
    let result = super.call("token1", "token1():(address)", []);

    return result[0].toAddress();
  }

  try_token1(): ethereum.CallResult<Address> {
    let result = super.tryCall("token1", "token1():(address)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }
}

export class ConstructorCall extends ethereum.Call {
  get inputs(): ConstructorCall__Inputs {
    return new ConstructorCall__Inputs(this);
  }

  get outputs(): ConstructorCall__Outputs {
    return new ConstructorCall__Outputs(this);
  }
}

export class ConstructorCall__Inputs {
  _call: ConstructorCall;

  constructor(call: ConstructorCall) {
    this._call = call;
  }
}

export class ConstructorCall__Outputs {
  _call: ConstructorCall;

  constructor(call: ConstructorCall) {
    this._call = call;
  }
}

export class BurnCall extends ethereum.Call {
  get inputs(): BurnCall__Inputs {
    return new BurnCall__Inputs(this);
  }

  get outputs(): BurnCall__Outputs {
    return new BurnCall__Outputs(this);
  }
}

export class BurnCall__Inputs {
  _call: BurnCall;

  constructor(call: BurnCall) {
    this._call = call;
  }

  get tickLower(): i32 {
    return this._call.inputValues[0].value.toI32();
  }

  get tickUpper(): i32 {
    return this._call.inputValues[1].value.toI32();
  }

  get amount(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class BurnCall__Outputs {
  _call: BurnCall;

  constructor(call: BurnCall) {
    this._call = call;
  }

  get amount0(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.outputValues[1].value.toBigInt();
  }
}

export class CollectCall extends ethereum.Call {
  get inputs(): CollectCall__Inputs {
    return new CollectCall__Inputs(this);
  }

  get outputs(): CollectCall__Outputs {
    return new CollectCall__Outputs(this);
  }
}

export class CollectCall__Inputs {
  _call: CollectCall;

  constructor(call: CollectCall) {
    this._call = call;
  }

  get recipient(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get tickLower(): i32 {
    return this._call.inputValues[1].value.toI32();
  }

  get tickUpper(): i32 {
    return this._call.inputValues[2].value.toI32();
  }

  get amount0Requested(): BigInt {
    return this._call.inputValues[3].value.toBigInt();
  }

  get amount1Requested(): BigInt {
    return this._call.inputValues[4].value.toBigInt();
  }
}

export class CollectCall__Outputs {
  _call: CollectCall;

  constructor(call: CollectCall) {
    this._call = call;
  }

  get amount0(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.outputValues[1].value.toBigInt();
  }
}

export class CollectProtocolCall extends ethereum.Call {
  get inputs(): CollectProtocolCall__Inputs {
    return new CollectProtocolCall__Inputs(this);
  }

  get outputs(): CollectProtocolCall__Outputs {
    return new CollectProtocolCall__Outputs(this);
  }
}

export class CollectProtocolCall__Inputs {
  _call: CollectProtocolCall;

  constructor(call: CollectProtocolCall) {
    this._call = call;
  }

  get recipient(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get amount0Requested(): BigInt {
    return this._call.inputValues[1].value.toBigInt();
  }

  get amount1Requested(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class CollectProtocolCall__Outputs {
  _call: CollectProtocolCall;

  constructor(call: CollectProtocolCall) {
    this._call = call;
  }

  get amount0(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.outputValues[1].value.toBigInt();
  }
}

export class FlashCall extends ethereum.Call {
  get inputs(): FlashCall__Inputs {
    return new FlashCall__Inputs(this);
  }

  get outputs(): FlashCall__Outputs {
    return new FlashCall__Outputs(this);
  }
}

export class FlashCall__Inputs {
  _call: FlashCall;

  constructor(call: FlashCall) {
    this._call = call;
  }

  get recipient(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get amount0(): BigInt {
    return this._call.inputValues[1].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }

  get data(): Bytes {
    return this._call.inputValues[3].value.toBytes();
  }
}

export class FlashCall__Outputs {
  _call: FlashCall;

  constructor(call: FlashCall) {
    this._call = call;
  }
}

export class IncreaseObservationCardinalityNextCall extends ethereum.Call {
  get inputs(): IncreaseObservationCardinalityNextCall__Inputs {
    return new IncreaseObservationCardinalityNextCall__Inputs(this);
  }

  get outputs(): IncreaseObservationCardinalityNextCall__Outputs {
    return new IncreaseObservationCardinalityNextCall__Outputs(this);
  }
}

export class IncreaseObservationCardinalityNextCall__Inputs {
  _call: IncreaseObservationCardinalityNextCall;

  constructor(call: IncreaseObservationCardinalityNextCall) {
    this._call = call;
  }

  get observationCardinalityNext(): i32 {
    return this._call.inputValues[0].value.toI32();
  }
}

export class IncreaseObservationCardinalityNextCall__Outputs {
  _call: IncreaseObservationCardinalityNextCall;

  constructor(call: IncreaseObservationCardinalityNextCall) {
    this._call = call;
  }
}

export class InitializeCall extends ethereum.Call {
  get inputs(): InitializeCall__Inputs {
    return new InitializeCall__Inputs(this);
  }

  get outputs(): InitializeCall__Outputs {
    return new InitializeCall__Outputs(this);
  }
}

export class InitializeCall__Inputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }

  get sqrtPriceX96(): BigInt {
    return this._call.inputValues[0].value.toBigInt();
  }
}

export class InitializeCall__Outputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }
}

export class MintCall extends ethereum.Call {
  get inputs(): MintCall__Inputs {
    return new MintCall__Inputs(this);
  }

  get outputs(): MintCall__Outputs {
    return new MintCall__Outputs(this);
  }
}

export class MintCall__Inputs {
  _call: MintCall;

  constructor(call: MintCall) {
    this._call = call;
  }

  get recipient(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get tickLower(): i32 {
    return this._call.inputValues[1].value.toI32();
  }

  get tickUpper(): i32 {
    return this._call.inputValues[2].value.toI32();
  }

  get amount(): BigInt {
    return this._call.inputValues[3].value.toBigInt();
  }

  get data(): Bytes {
    return this._call.inputValues[4].value.toBytes();
  }
}

export class MintCall__Outputs {
  _call: MintCall;

  constructor(call: MintCall) {
    this._call = call;
  }

  get amount0(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.outputValues[1].value.toBigInt();
  }
}

export class SetFeeProtocolCall extends ethereum.Call {
  get inputs(): SetFeeProtocolCall__Inputs {
    return new SetFeeProtocolCall__Inputs(this);
  }

  get outputs(): SetFeeProtocolCall__Outputs {
    return new SetFeeProtocolCall__Outputs(this);
  }
}

export class SetFeeProtocolCall__Inputs {
  _call: SetFeeProtocolCall;

  constructor(call: SetFeeProtocolCall) {
    this._call = call;
  }

  get feeProtocol0(): i32 {
    return this._call.inputValues[0].value.toI32();
  }

  get feeProtocol1(): i32 {
    return this._call.inputValues[1].value.toI32();
  }
}

export class SetFeeProtocolCall__Outputs {
  _call: SetFeeProtocolCall;

  constructor(call: SetFeeProtocolCall) {
    this._call = call;
  }
}

export class SwapCall extends ethereum.Call {
  get inputs(): SwapCall__Inputs {
    return new SwapCall__Inputs(this);
  }

  get outputs(): SwapCall__Outputs {
    return new SwapCall__Outputs(this);
  }
}

export class SwapCall__Inputs {
  _call: SwapCall;

  constructor(call: SwapCall) {
    this._call = call;
  }

  get recipient(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get zeroForOne(): boolean {
    return this._call.inputValues[1].value.toBoolean();
  }

  get amountSpecified(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }

  get sqrtPriceLimitX96(): BigInt {
    return this._call.inputValues[3].value.toBigInt();
  }

  get data(): Bytes {
    return this._call.inputValues[4].value.toBytes();
  }
}

export class SwapCall__Outputs {
  _call: SwapCall;

  constructor(call: SwapCall) {
    this._call = call;
  }

  get amount0(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }

  get amount1(): BigInt {
    return this._call.outputValues[1].value.toBigInt();
  }
}