@uniswap/client-liquidity 1.3.2 → 1.3.4

package/dist/uniswap/liquidity/v1/auction_pb.d.ts

@@ -704,6 +704,13 @@ export declare class PoolConfig extends Message<PoolConfig> {
      * @generated from field: string pool_owner = 7;
      */
     poolOwner: string;
+    /**
+     * Optional. When present, the migrated LP positions are owned by a per-launch
+     * position-recipient contract instead of pool_owner. Absent = no lock.
+     *
+     * @generated from field: uniswap.liquidity.v1.LiquidityLockConfig liquidity_lock = 8;
+     */
+    liquidityLock?: LiquidityLockConfig;
     constructor(data?: PartialMessage<PoolConfig>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "uniswap.liquidity.v1.PoolConfig";
@@ -713,6 +720,111 @@ export declare class PoolConfig extends Message<PoolConfig> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PoolConfig;
     static equals(a: PoolConfig | PlainMessage<PoolConfig> | undefined, b: PoolConfig | PlainMessage<PoolConfig> | undefined): boolean;
 }
+/**
+ * Locks the migrated LP positions in a per-launch position-recipient contract. The `mode`
+ * oneof selects the recipient type; each variant carries only the fields that apply to it,
+ * so a parameter can never be set for the wrong mode.
+ *
+ * @generated from message uniswap.liquidity.v1.LiquidityLockConfig
+ */
+export declare class LiquidityLockConfig extends Message<LiquidityLockConfig> {
+    /**
+     * Absolute unix seconds when the lock expires; the backend converts this to a block number.
+     * Applies to every mode — all recipients hold the LP until this block.
+     *
+     * @generated from field: uint64 unlock_time_unix = 1;
+     */
+    unlockTimeUnix: bigint;
+    /**
+     * @generated from oneof uniswap.liquidity.v1.LiquidityLockConfig.mode
+     */
+    mode: {
+        /**
+         * @generated from field: uniswap.liquidity.v1.TimelockLock timelock = 2;
+         */
+        value: TimelockLock;
+        case: "timelock";
+    } | {
+        /**
+         * @generated from field: uniswap.liquidity.v1.FeesForwarderLock fees_forwarder = 3;
+         */
+        value: FeesForwarderLock;
+        case: "feesForwarder";
+    } | {
+        /**
+         * @generated from field: uniswap.liquidity.v1.BuybackBurnLock buyback_burn = 4;
+         */
+        value: BuybackBurnLock;
+        case: "buybackBurn";
+    } | {
+        case: undefined;
+        value?: undefined;
+    };
+    constructor(data?: PartialMessage<LiquidityLockConfig>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "uniswap.liquidity.v1.LiquidityLockConfig";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): LiquidityLockConfig;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): LiquidityLockConfig;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): LiquidityLockConfig;
+    static equals(a: LiquidityLockConfig | PlainMessage<LiquidityLockConfig> | undefined, b: LiquidityLockConfig | PlainMessage<LiquidityLockConfig> | undefined): boolean;
+}
+/**
+ * Holds the LP until unlock_time_unix, then lets the configured operator withdraw it.
+ *
+ * @generated from message uniswap.liquidity.v1.TimelockLock
+ */
+export declare class TimelockLock extends Message<TimelockLock> {
+    constructor(data?: PartialMessage<TimelockLock>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "uniswap.liquidity.v1.TimelockLock";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TimelockLock;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TimelockLock;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TimelockLock;
+    static equals(a: TimelockLock | PlainMessage<TimelockLock> | undefined, b: TimelockLock | PlainMessage<TimelockLock> | undefined): boolean;
+}
+/**
+ * Holds the LP like TimelockLock, and forwards the position's collected fees to fee_recipient.
+ *
+ * @generated from message uniswap.liquidity.v1.FeesForwarderLock
+ */
+export declare class FeesForwarderLock extends Message<FeesForwarderLock> {
+    /**
+     * @generated from field: string fee_recipient = 1;
+     */
+    feeRecipient: string;
+    constructor(data?: PartialMessage<FeesForwarderLock>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "uniswap.liquidity.v1.FeesForwarderLock";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FeesForwarderLock;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FeesForwarderLock;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FeesForwarderLock;
+    static equals(a: FeesForwarderLock | PlainMessage<FeesForwarderLock> | undefined, b: FeesForwarderLock | PlainMessage<FeesForwarderLock> | undefined): boolean;
+}
+/**
+ * Holds the LP like TimelockLock; a caller may burn the token-side fees (taking the currency
+ * side as a keeper reward) once at least min_token_burn_amount of token would be burned.
+ *
+ * @generated from message uniswap.liquidity.v1.BuybackBurnLock
+ */
+export declare class BuybackBurnLock extends Message<BuybackBurnLock> {
+    /**
+     * Raw token amount (BigInt string).
+     *
+     * @generated from field: string min_token_burn_amount = 1;
+     */
+    minTokenBurnAmount: string;
+    constructor(data?: PartialMessage<BuybackBurnLock>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "uniswap.liquidity.v1.BuybackBurnLock";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): BuybackBurnLock;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): BuybackBurnLock;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BuybackBurnLock;
+    static equals(a: BuybackBurnLock | PlainMessage<BuybackBurnLock> | undefined, b: BuybackBurnLock | PlainMessage<BuybackBurnLock> | undefined): boolean;
+}
 /**
  * @generated from message uniswap.liquidity.v1.CustomPriceRange
  */

package/dist/uniswap/liquidity/v1/auction_pb.js

@@ -969,6 +969,144 @@ PoolConfig.fields = proto3.util.newFieldList(() => [
     { no: 5, name: "reserved_supply_for_lp", kind: "scalar", T: 9 /* ScalarType.STRING */ },
     { no: 6, name: "lp_allocation", kind: "message", T: PostAuctionLiquidityAllocation },
     { no: 7, name: "pool_owner", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    { no: 8, name: "liquidity_lock", kind: "message", T: LiquidityLockConfig },
+]);
+/**
+ * Locks the migrated LP positions in a per-launch position-recipient contract. The `mode`
+ * oneof selects the recipient type; each variant carries only the fields that apply to it,
+ * so a parameter can never be set for the wrong mode.
+ *
+ * @generated from message uniswap.liquidity.v1.LiquidityLockConfig
+ */
+export class LiquidityLockConfig extends Message {
+    constructor(data) {
+        super();
+        /**
+         * Absolute unix seconds when the lock expires; the backend converts this to a block number.
+         * Applies to every mode — all recipients hold the LP until this block.
+         *
+         * @generated from field: uint64 unlock_time_unix = 1;
+         */
+        this.unlockTimeUnix = protoInt64.zero;
+        /**
+         * @generated from oneof uniswap.liquidity.v1.LiquidityLockConfig.mode
+         */
+        this.mode = { case: undefined };
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new LiquidityLockConfig().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new LiquidityLockConfig().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new LiquidityLockConfig().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(LiquidityLockConfig, a, b);
+    }
+}
+LiquidityLockConfig.runtime = proto3;
+LiquidityLockConfig.typeName = "uniswap.liquidity.v1.LiquidityLockConfig";
+LiquidityLockConfig.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "unlock_time_unix", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+    { no: 2, name: "timelock", kind: "message", T: TimelockLock, oneof: "mode" },
+    { no: 3, name: "fees_forwarder", kind: "message", T: FeesForwarderLock, oneof: "mode" },
+    { no: 4, name: "buyback_burn", kind: "message", T: BuybackBurnLock, oneof: "mode" },
+]);
+/**
+ * Holds the LP until unlock_time_unix, then lets the configured operator withdraw it.
+ *
+ * @generated from message uniswap.liquidity.v1.TimelockLock
+ */
+export class TimelockLock extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new TimelockLock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new TimelockLock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new TimelockLock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(TimelockLock, a, b);
+    }
+}
+TimelockLock.runtime = proto3;
+TimelockLock.typeName = "uniswap.liquidity.v1.TimelockLock";
+TimelockLock.fields = proto3.util.newFieldList(() => []);
+/**
+ * Holds the LP like TimelockLock, and forwards the position's collected fees to fee_recipient.
+ *
+ * @generated from message uniswap.liquidity.v1.FeesForwarderLock
+ */
+export class FeesForwarderLock extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: string fee_recipient = 1;
+         */
+        this.feeRecipient = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new FeesForwarderLock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new FeesForwarderLock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new FeesForwarderLock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(FeesForwarderLock, a, b);
+    }
+}
+FeesForwarderLock.runtime = proto3;
+FeesForwarderLock.typeName = "uniswap.liquidity.v1.FeesForwarderLock";
+FeesForwarderLock.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "fee_recipient", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+]);
+/**
+ * Holds the LP like TimelockLock; a caller may burn the token-side fees (taking the currency
+ * side as a keeper reward) once at least min_token_burn_amount of token would be burned.
+ *
+ * @generated from message uniswap.liquidity.v1.BuybackBurnLock
+ */
+export class BuybackBurnLock extends Message {
+    constructor(data) {
+        super();
+        /**
+         * Raw token amount (BigInt string).
+         *
+         * @generated from field: string min_token_burn_amount = 1;
+         */
+        this.minTokenBurnAmount = "";
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new BuybackBurnLock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new BuybackBurnLock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new BuybackBurnLock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(BuybackBurnLock, a, b);
+    }
+}
+BuybackBurnLock.runtime = proto3;
+BuybackBurnLock.typeName = "uniswap.liquidity.v1.BuybackBurnLock";
+BuybackBurnLock.fields = proto3.util.newFieldList(() => [
+    { no: 1, name: "min_token_burn_amount", kind: "scalar", T: 9 /* ScalarType.STRING */ },
 ]);
 /**
  * @generated from message uniswap.liquidity.v1.CustomPriceRange

package/dist/uniswap/liquidity/v1/types_pb.d.ts

@@ -126,7 +126,11 @@ export declare enum ChainId {
     /**
      * @generated from enum value: ARC = 5042;
      */
-    ARC = 5042
+    ARC = 5042,
+    /**
+     * @generated from enum value: INK = 57073;
+     */
+    INK = 57073
 }
 /**
  * @generated from enum uniswap.liquidity.v1.Distributor

package/dist/uniswap/liquidity/v1/types_pb.js

@@ -138,6 +138,10 @@ export var ChainId;
      * @generated from enum value: ARC = 5042;
      */
     ChainId[ChainId["ARC"] = 5042] = "ARC";
+    /**
+     * @generated from enum value: INK = 57073;
+     */
+    ChainId[ChainId["INK"] = 57073] = "INK";
 })(ChainId || (ChainId = {}));
 // Retrieve enum metadata with: proto3.getEnumType(ChainId)
 proto3.util.setEnumType(ChainId, "uniswap.liquidity.v1.ChainId", [
@@ -167,6 +171,7 @@ proto3.util.setEnumType(ChainId, "uniswap.liquidity.v1.ChainId", [
     { no: 4217, name: "TEMPO" },
     { no: 4663, name: "ROBINHOOD" },
     { no: 5042, name: "ARC" },
+    { no: 57073, name: "INK" },
 ]);
 /**
  * @generated from enum uniswap.liquidity.v1.Distributor

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uniswap/client-liquidity",
-    "version": "1.3.2",
+    "version": "1.3.4",
     "publishConfig": {
       "access": "public"
     },