@uniswap/client-liquidity 1.4.20 → 1.4.22

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

@@ -480,13 +480,12 @@ export declare class CreateAuctionRequest extends Message<CreateAuctionRequest>
      */
     simulateTransaction?: boolean;
     /**
-     * Explicit creator-fee toggle for the post-graduation LP position. During
-     * rollout an absent field is treated as false — identical to today's
-     * behavior, so a client that predates the field keeps launching exactly as
-     * it does now (a silent flip could only occur if absent meant true). The
-     * field is intended to become required once apps/web and the crowd-launch
-     * client send it explicitly; it is declared optional so presence stays
-     * detectable on the wire for that flip.
+     * Explicit creator-fee toggle for the post-graduation LP position. An
+     * absent field keeps fully legacy routing (pool owner or the configured
+     * liquidity_lock recipient), so a client that predates the field keeps
+     * launching exactly as it does now. The field is intended to become
+     * required once every client sends it explicitly; it is declared optional
+     * so presence stays detectable on the wire for that flip.
      *
      * Unlike CreateDirectLaunch there is NO beneficiary parameter: attribution is
      * the beneficiary vault's graffiti claim. The wallet that sends createToken is
@@ -501,8 +500,14 @@ export declare class CreateAuctionRequest extends Message<CreateAuctionRequest>
      * liquidity_lock (the FeeSplitter replaces the lock; setting both is
      * rejected). This is distinct from LiquidityLockConfig.fees_forwarder, which
      * deploys a per-launch forwarder with a fixed fee_recipient and no vault
-     * attribution. When false, behavior is unchanged: the position goes to the
-     * pool owner or the configured liquidity_lock recipient.
+     * attribution.
+     *
+     * When false, position routing is unchanged: the position goes to the pool
+     * owner or the configured liquidity_lock recipient. This field answers only
+     * "does the creator claim fees" — to park a fees-off position with the
+     * shared fees-OFF FeeSplitter (100% of LP fees autocompound to the
+     * protocol), name that recipient explicitly with liquidity_lock mode
+     * `autocompound` instead of relying on this toggle.
      *
      * @generated from field: optional bool creator_fees_enabled = 8;
      */
@@ -761,8 +766,9 @@ export declare class PoolConfig extends Message<PoolConfig> {
 }
 /**
  * Locks the migrated LP positions in a per-launch position-recipient contract (or burns
- * them outright — see BurnLock). 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.
+ * them outright — see BurnLock — or parks them with the shared fees-OFF FeeSplitter — see
+ * AutocompoundLock). 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
  */
@@ -770,7 +776,8 @@ 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 contract-held mode — all recipients hold the LP until this block.
-     * Must be UNSET (0) for BURN: a burned position can never be unlocked.
+     * Must be UNSET (0) for BURN and AUTOCOMPOUND: a burned position can never be
+     * unlocked, and the shared FeeSplitter holds an autocompounding position forever.
      *
      * @generated from field: uint64 unlock_time_unix = 1;
      */
@@ -802,6 +809,12 @@ export declare class LiquidityLockConfig extends Message<LiquidityLockConfig> {
          */
         value: BurnLock;
         case: "burn";
+    } | {
+        /**
+         * @generated from field: uniswap.liquidity.v1.AutocompoundLock autocompound = 6;
+         */
+        value: AutocompoundLock;
+        case: "autocompound";
     } | {
         case: undefined;
         value?: undefined;
@@ -891,6 +904,31 @@ export declare class BurnLock extends Message<BurnLock> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): BurnLock;
     static equals(a: BurnLock | PlainMessage<BurnLock> | undefined, b: BurnLock | PlainMessage<BurnLock> | undefined): boolean;
 }
+/**
+ * Permanently parks the migrated LP position in the chain's shared fees-OFF
+ * FeeSplitter — the same custody as fees-off bonding-curve (instant) launches:
+ * 100% of the position's LP fees autocompound to the protocol and nothing ever
+ * accrues to the creator. Like BURN there is no per-launch recipient contract
+ * (no deploy tx) and the position can never be withdrawn, so unlock_time_unix
+ * must be UNSET (0). The splitter can only custody a new-token launch with a
+ * native-ETH raise on a chain that has a fees-OFF deployment; any other shape
+ * is rejected. Only the migrated LP position is affected: the auction
+ * tokensRecipient, the failure-recovery recipient, and pool_owner semantics
+ * are unchanged (the creator keeps them), so a failed (non-graduated) auction
+ * returns funds to the creator.
+ *
+ * @generated from message uniswap.liquidity.v1.AutocompoundLock
+ */
+export declare class AutocompoundLock extends Message<AutocompoundLock> {
+    constructor(data?: PartialMessage<AutocompoundLock>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "uniswap.liquidity.v1.AutocompoundLock";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AutocompoundLock;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AutocompoundLock;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AutocompoundLock;
+    static equals(a: AutocompoundLock | PlainMessage<AutocompoundLock> | undefined, b: AutocompoundLock | PlainMessage<AutocompoundLock> | undefined): boolean;
+}
 /**
  * @generated from message uniswap.liquidity.v1.CustomPriceRange
  */
@@ -1112,6 +1150,22 @@ export declare class CreateDirectLaunchRequest extends Message<CreateDirectLaunc
      * @generated from field: optional bool creator_fees_enabled = 8;
      */
     creatorFeesEnabled?: boolean;
+    /**
+     * Optional launch-time creator buy, in basis points of the fixed total
+     * supply (1–10000), bought atomically in the same launch multicall via the
+     * launcher's UniversalRouterStrategy. Instant (direct) launches only — this
+     * field exists only on CreateDirectLaunchRequest, so auctions can never
+     * carry it. The launch pool's opening state is fully determined before the
+     * transaction exists and the buy is the pool's first-ever swap inside the
+     * same transaction, so the server computes the exact native cost, encodes
+     * the exact-in route (slippage bounds live inside the route), and the
+     * returned transaction carries value == that exact cost — the wallet MUST
+     * send it unchanged. Rejected with INVALID_ARGUMENT where the launch-time
+     * buy is not enabled/supported on the requested chain.
+     *
+     * @generated from field: optional uint32 prelaunch_buy_supply_bps = 9;
+     */
+    prelaunchBuySupplyBps?: number;
     constructor(data?: PartialMessage<CreateDirectLaunchRequest>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "uniswap.liquidity.v1.CreateDirectLaunchRequest";
@@ -1130,8 +1184,11 @@ export declare class CreateDirectLaunchResponse extends Message<CreateDirectLaun
      */
     requestId: string;
     /**
-     * Ordered; today always a single LiquidityLauncher.multicall(createToken,
-     * distributeToken) with value 0.
+     * Ordered; always a single LiquidityLauncher.multicall — createToken +
+     * distributeToken, plus a distributeWithNative buy leg when
+     * prelaunch_buy_supply_bps was set. Value is 0 without a buy leg and exactly
+     * the computed buy cost with one (the launcher strands any excess, so the
+     * wallet must not alter it).
      *
      * @generated from field: repeated uniswap.liquidity.v1.TransactionRequest transactions = 2;
      */

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

@@ -975,8 +975,9 @@ PoolConfig.fields = proto3.util.newFieldList(() => [
 ]);
 /**
  * Locks the migrated LP positions in a per-launch position-recipient contract (or burns
- * them outright — see BurnLock). 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.
+ * them outright — see BurnLock — or parks them with the shared fees-OFF FeeSplitter — see
+ * AutocompoundLock). 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
  */
@@ -986,7 +987,8 @@ export class LiquidityLockConfig extends Message {
         /**
          * Absolute unix seconds when the lock expires; the backend converts this to a block number.
          * Applies to every contract-held mode — all recipients hold the LP until this block.
-         * Must be UNSET (0) for BURN: a burned position can never be unlocked.
+         * Must be UNSET (0) for BURN and AUTOCOMPOUND: a burned position can never be
+         * unlocked, and the shared FeeSplitter holds an autocompounding position forever.
          *
          * @generated from field: uint64 unlock_time_unix = 1;
          */
@@ -1018,6 +1020,7 @@ LiquidityLockConfig.fields = proto3.util.newFieldList(() => [
     { no: 3, name: "fees_forwarder", kind: "message", T: FeesForwarderLock, oneof: "mode" },
     { no: 4, name: "buyback_burn", kind: "message", T: BuybackBurnLock, oneof: "mode" },
     { no: 5, name: "burn", kind: "message", T: BurnLock, oneof: "mode" },
+    { no: 6, name: "autocompound", kind: "message", T: AutocompoundLock, oneof: "mode" },
 ]);
 /**
  * Holds the LP until unlock_time_unix, then lets the configured operator withdraw it.
@@ -1143,6 +1146,42 @@ export class BurnLock extends Message {
 BurnLock.runtime = proto3;
 BurnLock.typeName = "uniswap.liquidity.v1.BurnLock";
 BurnLock.fields = proto3.util.newFieldList(() => []);
+/**
+ * Permanently parks the migrated LP position in the chain's shared fees-OFF
+ * FeeSplitter — the same custody as fees-off bonding-curve (instant) launches:
+ * 100% of the position's LP fees autocompound to the protocol and nothing ever
+ * accrues to the creator. Like BURN there is no per-launch recipient contract
+ * (no deploy tx) and the position can never be withdrawn, so unlock_time_unix
+ * must be UNSET (0). The splitter can only custody a new-token launch with a
+ * native-ETH raise on a chain that has a fees-OFF deployment; any other shape
+ * is rejected. Only the migrated LP position is affected: the auction
+ * tokensRecipient, the failure-recovery recipient, and pool_owner semantics
+ * are unchanged (the creator keeps them), so a failed (non-graduated) auction
+ * returns funds to the creator.
+ *
+ * @generated from message uniswap.liquidity.v1.AutocompoundLock
+ */
+export class AutocompoundLock extends Message {
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new AutocompoundLock().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new AutocompoundLock().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new AutocompoundLock().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(AutocompoundLock, a, b);
+    }
+}
+AutocompoundLock.runtime = proto3;
+AutocompoundLock.typeName = "uniswap.liquidity.v1.AutocompoundLock";
+AutocompoundLock.fields = proto3.util.newFieldList(() => []);
 /**
  * @generated from message uniswap.liquidity.v1.CustomPriceRange
  */
@@ -1406,6 +1445,7 @@ CreateDirectLaunchRequest.fields = proto3.util.newFieldList(() => [
     { no: 6, name: "fee_beneficiary", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
     { no: 7, name: "simulate_transaction", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     { no: 8, name: "creator_fees_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+    { no: 9, name: "prelaunch_buy_supply_bps", kind: "scalar", T: 13 /* ScalarType.UINT32 */, opt: true },
 ]);
 /**
  * @generated from message uniswap.liquidity.v1.CreateDirectLaunchResponse
@@ -1418,8 +1458,11 @@ export class CreateDirectLaunchResponse extends Message {
          */
         this.requestId = "";
         /**
-         * Ordered; today always a single LiquidityLauncher.multicall(createToken,
-         * distributeToken) with value 0.
+         * Ordered; always a single LiquidityLauncher.multicall — createToken +
+         * distributeToken, plus a distributeWithNative buy leg when
+         * prelaunch_buy_supply_bps was set. Value is 0 without a buy leg and exactly
+         * the computed buy cost with one (the launcher strands any excess, so the
+         * wallet must not alter it).
          *
          * @generated from field: repeated uniswap.liquidity.v1.TransactionRequest transactions = 2;
          */

package/package.json

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