@pufferfinance/puffer-sdk 1.2.0 → 1.2.2

package/dist/contracts/handlers/puffer-l2-depositor-handler.d.ts

@@ -1,6 +1,6 @@
 import { WalletClient, PublicClient, Address } from 'viem';
 import { Chain, ViemChain } from '../../chains/constants';
-import { NonPufToken } from '../tokens';
+import { Token } from '../tokens';
 
 /**
  * Handler for the `PufferL2Depositor` contract exposing methods to
@@ -228,14 +228,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -603,14 +604,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -972,14 +974,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -1341,14 +1344,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -1710,14 +1714,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -2079,14 +2084,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -2448,14 +2454,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -2824,14 +2831,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -3199,14 +3207,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -3568,14 +3577,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -3937,14 +3947,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -4306,14 +4317,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -4675,14 +4687,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -5044,14 +5057,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -5421,14 +5435,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -5795,14 +5810,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -6170,14 +6186,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -6538,14 +6555,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -6907,14 +6925,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -7275,14 +7294,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -7644,14 +7664,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -8012,14 +8033,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -8381,14 +8403,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -8749,14 +8772,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -9118,14 +9142,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -9486,14 +9511,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -9855,14 +9881,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -10223,14 +10250,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -10599,14 +10627,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -10981,14 +11010,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -11371,14 +11401,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -11753,14 +11784,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -12135,14 +12167,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -12517,14 +12550,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -12893,14 +12927,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -13269,14 +13304,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -13647,14 +13683,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -14023,14 +14060,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -14399,14 +14437,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -14775,14 +14814,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -15152,14 +15192,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -15531,14 +15572,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -15912,14 +15954,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -16291,14 +16334,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -16670,14 +16714,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -17049,14 +17094,15 @@ export declare class PufferL2DepositorHandler {
                         readonly name: "isAllowed";
                         readonly type: "bool";
                     }];
-                    readonly name: "SetIsMigratorAllowed"; /**
-                     * Deposit the given token in exchange for pufETH. This doesn't make
-                     * the transaction but returns two methods namely `transact` and
-                     * `estimate`.
+                    readonly name: "SetIsMigratorAllowed";
+                    /**
+                     * Deposit the given token in exchange for the wrapped PufToken. This
+                     * doesn't make the transaction but returns two methods namely
+                     * `transact` and `estimate`.
                      *
                      * Note that not all token contracts support permit signatures (e.g.
                      * USDC). If a token's contract doesn't support permit signatures, use
-                     * `Token.approve()` and call `depositAfterApproval()` instead.
+                     * `Token.approve()` and call `this.depositPreApproved()` instead.
                      *
                      * @param token Token to deposit.
                      * @param walletAddress Wallet address to take the token from.
@@ -17422,14 +17468,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -17796,14 +17843,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -18177,14 +18225,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -18545,14 +18594,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -18914,14 +18964,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -19282,14 +19333,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -19651,14 +19703,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -20019,14 +20072,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -20388,14 +20442,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -20756,14 +20811,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -21125,14 +21181,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -21493,14 +21550,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -21862,14 +21920,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -22230,14 +22289,15 @@ export declare class PufferL2DepositorHandler {
                     readonly name: "isAllowed";
                     readonly type: "bool";
                 }];
-                readonly name: "SetIsMigratorAllowed"; /**
-                 * Deposit the given token in exchange for pufETH. This doesn't make
-                 * the transaction but returns two methods namely `transact` and
-                 * `estimate`.
+                readonly name: "SetIsMigratorAllowed";
+                /**
+                 * Deposit the given token in exchange for the wrapped PufToken. This
+                 * doesn't make the transaction but returns two methods namely
+                 * `transact` and `estimate`.
                  *
                  * Note that not all token contracts support permit signatures (e.g.
                  * USDC). If a token's contract doesn't support permit signatures, use
-                 * `Token.approve()` and call `depositAfterApproval()` instead.
+                 * `Token.approve()` and call `this.depositPreApproved()` instead.
                  *
                  * @param token Token to deposit.
                  * @param walletAddress Wallet address to take the token from.
@@ -22601,14 +22661,15 @@ export declare class PufferL2DepositorHandler {
                 readonly name: "isAllowed";
                 readonly type: "bool";
             }];
-            readonly name: "SetIsMigratorAllowed"; /**
-             * Deposit the given token in exchange for pufETH. This doesn't make
-             * the transaction but returns two methods namely `transact` and
-             * `estimate`.
+            readonly name: "SetIsMigratorAllowed";
+            /**
+             * Deposit the given token in exchange for the wrapped PufToken. This
+             * doesn't make the transaction but returns two methods namely
+             * `transact` and `estimate`.
              *
              * Note that not all token contracts support permit signatures (e.g.
              * USDC). If a token's contract doesn't support permit signatures, use
-             * `Token.approve()` and call `depositAfterApproval()` instead.
+             * `Token.approve()` and call `this.depositPreApproved()` instead.
              *
              * @param token Token to deposit.
              * @param walletAddress Wallet address to take the token from.
@@ -22824,8 +22885,8 @@ export declare class PufferL2DepositorHandler {
     };
     /**
      * Deposit the given token which is pre-approved using
-     * `token.approve()` in exchange for pufETH. This doesn't make the
-     * transaction but returns two methods namely `transact` and
+     * `Token.approve()` in exchange for wrapped PufToken. This doesn't
+     * make the transaction but returns two methods namely `transact` and
      * `estimate`.
      *
      * @param token Token to deposit.
@@ -22837,18 +22898,18 @@ export declare class PufferL2DepositorHandler {
      * `estimate: () => Promise<bigint>` - Gas estimate of the
      * transaction.
      */
-    depositAfterApproval(token: NonPufToken, walletAddress: Address, value: bigint): {
+    depositPreApproved(token: Token, walletAddress: Address, value: bigint): {
         transact: () => Promise<`0x${string}`>;
         estimate: () => Promise<bigint>;
     };
     /**
-     * Deposit the given token in exchange for pufETH. This doesn't make
-     * the transaction but returns two methods namely `transact` and
-     * `estimate`.
+     * Deposit the given token in exchange for the wrapped PufToken. This
+     * doesn't make the transaction but returns two methods namely
+     * `transact` and `estimate`.
      *
      * Note that not all token contracts support permit signatures (e.g.
      * USDC). If a token's contract doesn't support permit signatures, use
-     * `Token.approve()` and call `depositAfterApproval()` instead.
+     * `Token.approve()` and call `this.depositPreApproved()` instead.
      *
      * @param token Token to deposit.
      * @param walletAddress Wallet address to take the token from.
@@ -22860,7 +22921,7 @@ export declare class PufferL2DepositorHandler {
      * `estimate: () => Promise<bigint>` - Gas estimate of the
      * transaction.
      */
-    deposit(token: NonPufToken, walletAddress: Address, value: bigint, referralCode?: bigint): Promise<{
+    deposit(token: Token, walletAddress: Address, value: bigint, referralCode?: bigint): Promise<{
         transact: () => Promise<`0x${string}`>;
         estimate: () => Promise<bigint>;
     }>;