@glowlabs-org/utils 0.2.131 → 0.2.133

package/dist/cjs/index.js

@@ -15,7 +15,7 @@ var viem = require('viem');
 var merkletreejs = require('merkletreejs');
 var ethers = require('ethers');
 var Decimal = require('decimal.js');
-var farmsRouter = require('./farms-router-DXTR8f4V.js');
+var farmsRouter = require('./farms-router-Dxx681nB.js');
 
 const GENESIS_TIMESTAMP = 1700352000;
 

package/dist/cjs/lib/control-api/control-router.d.ts

@@ -13,6 +13,15 @@ export interface PayProtocolDepositUsingStakedControlResponse {
     farmId: string;
     applicationId: string;
 }
+export interface MigrateUserRequest {
+    wallet: string;
+    signature: string;
+    deadline: string;
+    nonce: string;
+}
+export interface MigrateUserResponse {
+    success: true;
+}
 export declare function ControlRouter(baseUrl: string): {
     readonly fetchGctlBalance: (wallet: string) => Promise<string>;
     readonly fetchCommittedBalance: (wallet: string) => Promise<string>;
@@ -35,9 +44,11 @@ export declare function ControlRouter(baseUrl: string): {
     readonly restakeGctl: (restakeRequest: RestakeRequest) => Promise<boolean>;
     readonly retryFailedOperation: (operationId: string) => Promise<boolean>;
     readonly payProtocolDepositUsingStakedControl: (paymentRequest: PayProtocolDepositUsingStakedControlRequest) => Promise<PayProtocolDepositUsingStakedControlResponse>;
+    readonly migrateUser: (migrateRequest: MigrateUserRequest) => Promise<MigrateUserResponse>;
     readonly isStaking: boolean;
     readonly isUnstaking: boolean;
     readonly isRestaking: boolean;
     readonly isRetryingFailedOperation: boolean;
     readonly isPayingProtocolDepositUsingStakedControl: boolean;
+    readonly isMigratingUser: boolean;
 };

package/dist/cjs/lib/types/index.d.ts

@@ -475,6 +475,7 @@ export interface MiningScoreParams {
     userId: string;
     dollarCostOfMiner: string;
     numberOfMiners: number;
+    minerRewardSplit: string;
 }
 export interface MiningScoresBatchParams {
     farms: MiningScoreParams[];
@@ -485,6 +486,7 @@ export interface MiningScoreResponse {
     glwPriceUsd6: string;
     dollarCostOfMiner: string;
     numberOfMiners: number;
+    minerRewardSplit: string;
     weeksOfMinerLifeRemaining: number;
     regionInfo: {
         regionId: number;

package/dist/cjs/utils/stake-control.d.ts

@@ -86,6 +86,18 @@ export declare const commitKickstarterEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const applyCertifiedInstallerEIP712Types: {
+    readonly ApplyCertifiedInstaller: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "regionId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const payProtocolDepositUsingStakedControlEIP712Types: {
     readonly PayProtocolDepositUsingStakedControl: readonly [{
         readonly name: "amount";
@@ -101,6 +113,15 @@ export declare const payProtocolDepositUsingStakedControlEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const verifyUserEIP712Types: {
+    readonly VerifyUser: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -143,12 +164,25 @@ export declare const commitKickstarterSignatureRequestSchema: z.ZodObject<{
     kickstarterId: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
-export declare const payProtocolDepositUsingStakedControlSignatureRequestSchema: z.ZodObject<{
+export declare const applyCertifiedInstallerSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
     nonce: z.ZodString;
+    regionId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const payProtocolDepositUsingStakedControlSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
     amount: z.ZodString;
     applicationId: z.ZodString;
+    nonce: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
+export declare const verifyUserSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
@@ -156,7 +190,9 @@ export type UnstakeUnlockSignatureRequest = z.infer<typeof unstakeUnlockSignatur
 export type UnstakeMoveSignatureRequest = z.infer<typeof unstakeMoveSignatureRequestSchema>;
 export type RestakeSignatureRequest = z.infer<typeof restakeSignatureRequestSchema>;
 export type CommitKickstarterSignatureRequest = z.infer<typeof commitKickstarterSignatureRequestSchema>;
+export type ApplyCertifiedInstallerSignatureRequest = z.infer<typeof applyCertifiedInstallerSignatureRequestSchema>;
 export type PayProtocolDepositUsingStakedControlSignatureRequest = z.infer<typeof payProtocolDepositUsingStakedControlSignatureRequestSchema>;
+export type VerifyUserSignatureRequest = z.infer<typeof verifyUserSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -189,12 +225,28 @@ export type CommitKickstarterMessage = {
     kickstarterId: string;
     deadline: bigint;
 };
+export type ApplyCertifiedInstallerMessage = {
+    nonce: bigint;
+    regionId: bigint;
+    deadline: bigint;
+};
 export type PayProtocolDepositUsingStakedControlMessage = {
     amount: bigint;
     applicationId: string;
     nonce: bigint;
     deadline: bigint;
 };
+export type PayProtocolDepositMessage = {
+    nonce: bigint;
+    amount: bigint;
+    regionId: bigint;
+    applicationId: string;
+    deadline: bigint;
+};
+export type VerifyUserMessage = {
+    nonce: bigint;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -206,17 +258,23 @@ type UnstakeUnlockMessageInput = Pick<UnstakeUnlockSignatureRequest, "nonce" | "
 type UnstakeMoveMessageInput = Pick<UnstakeMoveSignatureRequest, "nonce" | "amount" | "fromZoneId" | "toZoneId" | "deadline">;
 type RestakeMessageInput = Pick<RestakeSignatureRequest, "nonce" | "amount" | "fromZoneId" | "toZoneId" | "deadline">;
 type CommitKickstarterMessageInput = Pick<CommitKickstarterSignatureRequest, "nonce" | "amount" | "kickstarterId" | "deadline">;
+type ApplyCertifiedInstallerMessageInput = Pick<ApplyCertifiedInstallerSignatureRequest, "nonce" | "regionId" | "deadline">;
 type PayProtocolDepositUsingStakedControlMessageInput = Pick<PayProtocolDepositUsingStakedControlSignatureRequest, "amount" | "applicationId" | "nonce" | "deadline">;
+type VerifyUserMessageInput = Pick<VerifyUserSignatureRequest, "nonce" | "deadline">;
 export declare function buildStakeMessage(req: StakeMessageInput): StakeMessage;
 export declare function buildUnstakeUnlockMessage(req: UnstakeUnlockMessageInput): UnstakeUnlockMessage;
 export declare function buildUnstakeMoveMessage(req: UnstakeMoveMessageInput): UnstakeMoveMessage;
 export declare function buildRestakeMessage(req: RestakeMessageInput): RestakeMessage;
 export declare function buildCommitKickstarterMessage(req: CommitKickstarterMessageInput): CommitKickstarterMessage;
+export declare function buildApplyCertifiedInstallerMessage(req: ApplyCertifiedInstallerMessageInput): ApplyCertifiedInstallerMessage;
 export declare function buildPayProtocolDepositUsingStakedControlMessage(req: PayProtocolDepositUsingStakedControlMessageInput): PayProtocolDepositUsingStakedControlMessage;
+export declare function buildVerifyUserMessage(req: VerifyUserMessageInput): VerifyUserMessage;
 export declare function validateStakeSignature(input: StakeSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validateUnstakeUnlockSignature(input: UnstakeUnlockSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validateUnstakeMoveSignature(input: UnstakeMoveSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validateRestakeSignature(input: RestakeSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validateCommitKickstarterSignature(input: CommitKickstarterSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateApplyCertifiedInstallerSignature(input: ApplyCertifiedInstallerSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export declare function validatePayProtocolDepositUsingStakedControlSignature(input: PayProtocolDepositUsingStakedControlSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
+export declare function validateVerifyUserSignature(input: VerifyUserSignatureRequest, domain?: ReturnType<typeof stakeControlEIP712Domain>): Promise<SignatureValidationResult>;
 export {};

package/dist/esm/browser.js

@@ -1,6 +1,6 @@
-import { T as TRANSFER_TYPES } from './farms-router-DqPqj03h.js';
-export { C as ControlRouter, D as DECIMALS_BY_TOKEN, i as FORWARDER_ABI, F as FarmsRouter, d as ForwarderError, l as GCA_URLS, G as GLOW_WEIGHT_DECIMAL_PRECISION, H as HUB_URL, c as KICKSTARTER_STATUS, K as KickstarterRouter, M as MAX_WEIGHT, j as OFFCHAIN_FRACTIONS_ABI, O as OFF_CHAIN_PAYMENT_CURRENCIES, e as OffchainFractionsError, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, U as USDG_WEIGHT_DECIMAL_PRECISION, W as WalletsRouter, f as allRegions, h as countries, k as getAddresses, r as regionMetadata, g as usStates, u as useForwarder, a as useOffchainFractions } from './farms-router-DqPqj03h.js';
-import { verifyTypedData, getAddress } from 'viem';
+import { T as TRANSFER_TYPES } from './farms-router-CphuVUes.js';
+export { C as ControlRouter, D as DECIMALS_BY_TOKEN, i as FORWARDER_ABI, F as FarmsRouter, d as ForwarderError, l as GCA_URLS, G as GLOW_WEIGHT_DECIMAL_PRECISION, H as HUB_URL, c as KICKSTARTER_STATUS, K as KickstarterRouter, M as MAX_WEIGHT, j as OFFCHAIN_FRACTIONS_ABI, O as OFF_CHAIN_PAYMENT_CURRENCIES, e as OffchainFractionsError, P as PAYMENT_CURRENCIES, b as REGIONS, R as RegionRouter, S as STAKING_DIRECTIONS, U as USDG_WEIGHT_DECIMAL_PRECISION, W as WalletsRouter, f as allRegions, h as countries, k as getAddresses, r as regionMetadata, g as usStates, u as useForwarder, a as useOffchainFractions } from './farms-router-CphuVUes.js';
+import { verifyTypedData, checksumAddress } from 'viem';
 import 'ethers';
 
 /** A special constant with type `never` */
@@ -11990,6 +11990,13 @@ const commitKickstarterEIP712Types = {
         { name: "deadline", type: "uint256" },
     ],
 };
+const applyCertifiedInstallerEIP712Types = {
+    ApplyCertifiedInstaller: [
+        { name: "nonce", type: "uint256" },
+        { name: "regionId", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+    ],
+};
 const payProtocolDepositUsingStakedControlEIP712Types = {
     PayProtocolDepositUsingStakedControl: [
         { name: "amount", type: "uint256" },
@@ -11998,6 +12005,12 @@ const payProtocolDepositUsingStakedControlEIP712Types = {
         { name: "deadline", type: "uint256" },
     ],
 };
+const verifyUserEIP712Types = {
+    VerifyUser: [
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+    ],
+};
 // Separate request schemas for clarity between stake and unstake
 const stakeSignatureRequestSchema = z.object({
     wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
@@ -12041,12 +12054,25 @@ const commitKickstarterSignatureRequestSchema = z.object({
     kickstarterId: z.string(),
     deadline: z.string(),
 });
-const payProtocolDepositUsingStakedControlSignatureRequestSchema = z.object({
+const applyCertifiedInstallerSignatureRequestSchema = z.object({
     wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
     signature: z.string().regex(/^0x[a-fA-F0-9]{130}$/),
     nonce: z.string(),
+    regionId: z.string(),
+    deadline: z.string(),
+});
+const payProtocolDepositUsingStakedControlSignatureRequestSchema = z.object({
+    wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+    signature: z.string().regex(/^0x[a-fA-F0-9]{130}$/),
     amount: z.string(),
     applicationId: z.string(),
+    nonce: z.string(),
+    deadline: z.string(),
+});
+const verifyUserSignatureRequestSchema = z.object({
+    wallet: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+    signature: z.string().regex(/^0x[a-fA-F0-9]{130}$/),
+    nonce: z.string(),
     deadline: z.string(),
 });
 function isDeadlineExpired(deadline) {
@@ -12130,23 +12156,44 @@ function buildCommitKickstarterMessage(req) {
         throw new Error("kickstarterId must be non-empty");
     return { nonce, amount, kickstarterId, deadline };
 }
+function buildApplyCertifiedInstallerMessage(req) {
+    const nonce = BigInt(req.nonce);
+    const deadline = BigInt(req.deadline);
+    const regionId = req.regionId;
+    if (nonce < 0n)
+        throw new Error("Nonce must be non-negative");
+    if (deadline < 0n)
+        throw new Error("Deadline must be non-negative");
+    if (!regionId)
+        throw new Error("regionId must be non-empty");
+    return { nonce, regionId: BigInt(regionId), deadline };
+}
 function buildPayProtocolDepositUsingStakedControlMessage(req) {
-    const amount = BigInt(req.amount);
     const nonce = BigInt(req.nonce);
+    const amount = BigInt(req.amount);
     const deadline = BigInt(req.deadline);
     const applicationId = req.applicationId;
-    if (amount < 0n)
-        throw new Error("Amount must be non-negative");
     if (nonce < 0n)
         throw new Error("Nonce must be non-negative");
+    if (amount < 0n)
+        throw new Error("Amount must be non-negative");
     if (deadline < 0n)
         throw new Error("Deadline must be non-negative");
     if (!applicationId)
         throw new Error("applicationId must be non-empty");
     return { amount, applicationId, nonce, deadline };
 }
+function buildVerifyUserMessage(req) {
+    const nonce = BigInt(req.nonce);
+    const deadline = BigInt(req.deadline);
+    if (nonce < 0n)
+        throw new Error("Nonce must be non-negative");
+    if (deadline < 0n)
+        throw new Error("Deadline must be non-negative");
+    return { nonce, deadline };
+}
 // Helper to validate the signature using viem
-async function validateStakeSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateStakeSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildStakeMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12158,7 +12205,7 @@ async function validateStakeSignature(input, domain = stakeControlEIP712Domain(1
     }
     try {
         const verified = await verifyTypedData({
-            address: input.wallet,
+            address: checksumAddress(input.wallet),
             domain,
             types: stakeEIP712Types,
             primaryType: "Stake",
@@ -12173,7 +12220,7 @@ async function validateStakeSignature(input, domain = stakeControlEIP712Domain(1
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildUnstakeUnlockMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12185,7 +12232,7 @@ async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712
     }
     try {
         const verified = await verifyTypedData({
-            address: input.wallet,
+            address: checksumAddress(input.wallet),
             domain,
             types: unstakeUnlockEIP712Types,
             primaryType: "Unstake",
@@ -12200,7 +12247,7 @@ async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildUnstakeMoveMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12213,7 +12260,7 @@ async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Do
     }
     try {
         const verified = await verifyTypedData({
-            address: input.wallet,
+            address: checksumAddress(input.wallet),
             domain,
             types: unstakeMoveEIP712Types,
             primaryType: "UnstakeMove",
@@ -12228,7 +12275,7 @@ async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Do
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateRestakeSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateRestakeSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildRestakeMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12241,7 +12288,7 @@ async function validateRestakeSignature(input, domain = stakeControlEIP712Domain
     }
     try {
         const verified = await verifyTypedData({
-            address: input.wallet,
+            address: checksumAddress(input.wallet),
             domain,
             types: restakeEIP712Types,
             primaryType: "Restake",
@@ -12256,7 +12303,7 @@ async function validateRestakeSignature(input, domain = stakeControlEIP712Domain
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateCommitKickstarterSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateCommitKickstarterSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildCommitKickstarterMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12268,7 +12315,7 @@ async function validateCommitKickstarterSignature(input, domain = stakeControlEI
     }
     try {
         const verified = await verifyTypedData({
-            address: input.wallet,
+            address: checksumAddress(input.wallet),
             domain,
             types: commitKickstarterEIP712Types,
             primaryType: "CommitKickstarter",
@@ -12283,7 +12330,33 @@ async function validateCommitKickstarterSignature(input, domain = stakeControlEI
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validatePayProtocolDepositUsingStakedControlSignature(input, domain = stakeControlEIP712Domain(1)) {
+async function validateApplyCertifiedInstallerSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
+    const message = buildApplyCertifiedInstallerMessage({
+        nonce: input.nonce,
+        regionId: input.regionId,
+        deadline: input.deadline,
+    });
+    if (isDeadlineExpired(message.deadline)) {
+        return { valid: false, recovered: null, reason: "deadline_expired" };
+    }
+    try {
+        const verified = await verifyTypedData({
+            address: checksumAddress(input.wallet),
+            domain,
+            types: applyCertifiedInstallerEIP712Types,
+            primaryType: "ApplyCertifiedInstaller",
+            message,
+            signature: input.signature,
+        });
+        return verified
+            ? { valid: true, recovered: input.wallet, reason: null }
+            : { valid: false, recovered: null, reason: "signer_mismatch" };
+    }
+    catch (_) {
+        return { valid: false, recovered: null, reason: "signature_failed" };
+    }
+}
+async function validatePayProtocolDepositUsingStakedControlSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
     const message = buildPayProtocolDepositUsingStakedControlMessage({
         amount: input.amount,
         applicationId: input.applicationId,
@@ -12295,7 +12368,7 @@ async function validatePayProtocolDepositUsingStakedControlSignature(input, doma
     }
     try {
         const verified = await verifyTypedData({
-            address: getAddress(input.wallet),
+            address: checksumAddress(input.wallet),
             domain,
             types: payProtocolDepositUsingStakedControlEIP712Types,
             primaryType: TRANSFER_TYPES.PayProtocolDepositUsingStakedControl,
@@ -12310,6 +12383,31 @@ async function validatePayProtocolDepositUsingStakedControlSignature(input, doma
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
+async function validateVerifyUserSignature(input, domain = stakeControlEIP712Domain(Number(process.env.CHAIN_ID) || 1)) {
+    const message = buildVerifyUserMessage({
+        nonce: input.nonce,
+        deadline: input.deadline,
+    });
+    if (isDeadlineExpired(message.deadline)) {
+        return { valid: false, recovered: null, reason: "deadline_expired" };
+    }
+    try {
+        const verified = await verifyTypedData({
+            address: checksumAddress(input.wallet),
+            domain,
+            types: verifyUserEIP712Types,
+            primaryType: "VerifyUser",
+            message,
+            signature: input.signature,
+        });
+        return verified
+            ? { valid: true, recovered: input.wallet, reason: null }
+            : { valid: false, recovered: null, reason: "signer_mismatch" };
+    }
+    catch (_) {
+        return { valid: false, recovered: null, reason: "signature_failed" };
+    }
+}
 
-export { TRANSFER_TYPES, buildCommitKickstarterMessage, buildPayProtocolDepositUsingStakedControlMessage, buildRestakeMessage, buildStakeMessage, buildUnstakeMoveMessage, buildUnstakeUnlockMessage, commitKickstarterEIP712Types, commitKickstarterSignatureRequestSchema, payProtocolDepositUsingStakedControlEIP712Types, payProtocolDepositUsingStakedControlSignatureRequestSchema, restakeEIP712Types, restakeSignatureRequestSchema, stakeControlEIP712Domain, stakeEIP712Types, stakeSignatureRequestSchema, unstakeMoveEIP712Types, unstakeMoveSignatureRequestSchema, unstakeUnlockEIP712Types, unstakeUnlockSignatureRequestSchema, validateCommitKickstarterSignature, validatePayProtocolDepositUsingStakedControlSignature, validateRestakeSignature, validateStakeSignature, validateUnstakeMoveSignature, validateUnstakeUnlockSignature };
+export { TRANSFER_TYPES, applyCertifiedInstallerEIP712Types, applyCertifiedInstallerSignatureRequestSchema, buildApplyCertifiedInstallerMessage, buildCommitKickstarterMessage, buildPayProtocolDepositUsingStakedControlMessage, buildRestakeMessage, buildStakeMessage, buildUnstakeMoveMessage, buildUnstakeUnlockMessage, buildVerifyUserMessage, commitKickstarterEIP712Types, commitKickstarterSignatureRequestSchema, payProtocolDepositUsingStakedControlEIP712Types, payProtocolDepositUsingStakedControlSignatureRequestSchema, restakeEIP712Types, restakeSignatureRequestSchema, stakeControlEIP712Domain, stakeEIP712Types, stakeSignatureRequestSchema, unstakeMoveEIP712Types, unstakeMoveSignatureRequestSchema, unstakeUnlockEIP712Types, unstakeUnlockSignatureRequestSchema, validateApplyCertifiedInstallerSignature, validateCommitKickstarterSignature, validatePayProtocolDepositUsingStakedControlSignature, validateRestakeSignature, validateStakeSignature, validateUnstakeMoveSignature, validateUnstakeUnlockSignature, validateVerifyUserSignature, verifyUserEIP712Types, verifyUserSignatureRequestSchema };
 //# sourceMappingURL=browser.js.map