@glowlabs-org/utils 0.2.50 → 0.2.52

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

@@ -1,9 +1,9 @@
 import z from "zod";
-export declare const stakeControlEIP712Domain: {
-    readonly name: "ControlManager";
-    readonly version: "1";
-    readonly chainId: number;
-    readonly verifyingContract: "0x0000000000000000000000000000000000000000";
+export declare const stakeControlEIP712Domain: (chainId: number) => {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: "0x0000000000000000000000000000000000000000";
 };
 export declare const stakeEIP712Types: {
     readonly Stake: readonly [{
@@ -71,6 +71,21 @@ export declare const restakeEIP712Types: {
         readonly type: "uint256";
     }];
 };
+export declare const commitKickstarterEIP712Types: {
+    readonly CommitKickstarter: readonly [{
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "kickstarterId";
+        readonly type: "string";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
 export declare const stakeSignatureRequestSchema: z.ZodObject<{
     wallet: z.ZodString;
     signature: z.ZodString;
@@ -105,10 +120,19 @@ export declare const restakeSignatureRequestSchema: z.ZodObject<{
     toZoneId: z.ZodString;
     deadline: z.ZodString;
 }, z.core.$strip>;
+export declare const commitKickstarterSignatureRequestSchema: z.ZodObject<{
+    wallet: z.ZodString;
+    signature: z.ZodString;
+    nonce: z.ZodString;
+    amount: z.ZodString;
+    kickstarterId: z.ZodString;
+    deadline: z.ZodString;
+}, z.core.$strip>;
 export type StakeSignatureRequest = z.infer<typeof stakeSignatureRequestSchema>;
 export type UnstakeUnlockSignatureRequest = z.infer<typeof unstakeUnlockSignatureRequestSchema>;
 export type UnstakeMoveSignatureRequest = z.infer<typeof unstakeMoveSignatureRequestSchema>;
 export type RestakeSignatureRequest = z.infer<typeof restakeSignatureRequestSchema>;
+export type CommitKickstarterSignatureRequest = z.infer<typeof commitKickstarterSignatureRequestSchema>;
 export type StakeMessage = {
     nonce: bigint;
     amount: bigint;
@@ -135,6 +159,12 @@ export type RestakeMessage = {
     toZoneId: bigint;
     deadline: bigint;
 };
+export type CommitKickstarterMessage = {
+    nonce: bigint;
+    amount: bigint;
+    kickstarterId: string;
+    deadline: bigint;
+};
 export type SignatureValidationReason = "deadline_expired" | "signature_failed" | "signer_mismatch" | null;
 export type SignatureValidationResult = {
     valid: boolean;
@@ -145,12 +175,15 @@ type StakeMessageInput = Pick<StakeSignatureRequest, "nonce" | "amount" | "toZon
 type UnstakeUnlockMessageInput = Pick<UnstakeUnlockSignatureRequest, "nonce" | "amount" | "fromZoneId" | "deadline">;
 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">;
 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 validateStakeSignature(input: StakeSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
-export declare function validateUnstakeUnlockSignature(input: UnstakeUnlockSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
-export declare function validateUnstakeMoveSignature(input: UnstakeMoveSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
-export declare function validateRestakeSignature(input: RestakeSignatureRequest, domain?: typeof stakeControlEIP712Domain): Promise<SignatureValidationResult>;
+export declare function buildCommitKickstarterMessage(req: CommitKickstarterMessageInput): CommitKickstarterMessage;
+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 {};

package/dist/esm/browser.js

@@ -11939,12 +11939,12 @@ var z = /*#__PURE__*/Object.freeze({
     xid: xid
 });
 
-const stakeControlEIP712Domain = {
+const stakeControlEIP712Domain = (chainId) => ({
     name: "ControlManager",
     version: "1",
-    chainId: Number(process.env.CHAIN_ID) || 1,
+    chainId,
     verifyingContract: "0x0000000000000000000000000000000000000000",
-};
+});
 // Distinct EIP-712 type sets for stake vs unstake
 const stakeEIP712Types = {
     Stake: [
@@ -11981,6 +11981,14 @@ const restakeEIP712Types = {
         { name: "deadline", type: "uint256" },
     ],
 };
+const commitKickstarterEIP712Types = {
+    CommitKickstarter: [
+        { name: "nonce", type: "uint256" },
+        { name: "amount", type: "uint256" },
+        { name: "kickstarterId", type: "string" },
+        { 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}$/),
@@ -12016,6 +12024,14 @@ const restakeSignatureRequestSchema = z.object({
     toZoneId: z.string(),
     deadline: z.string(),
 });
+const commitKickstarterSignatureRequestSchema = 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(),
+    amount: z.string(),
+    kickstarterId: z.string(),
+    deadline: z.string(),
+});
 function isDeadlineExpired(deadline) {
     const nowSeconds = BigInt(Math.floor(Date.now() / 1000));
     return deadline < nowSeconds;
@@ -12082,8 +12098,23 @@ function buildRestakeMessage(req) {
         throw new Error("Zone must be non-negative");
     return { nonce, amount, fromZoneId, toZoneId, deadline };
 }
+function buildCommitKickstarterMessage(req) {
+    const nonce = BigInt(req.nonce);
+    const amount = BigInt(req.amount);
+    const deadline = BigInt(req.deadline);
+    const kickstarterId = req.kickstarterId;
+    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 (!kickstarterId)
+        throw new Error("kickstarterId must be non-empty");
+    return { nonce, amount, kickstarterId, deadline };
+}
 // Helper to validate the signature using viem
-async function validateStakeSignature(input, domain = stakeControlEIP712Domain) {
+async function validateStakeSignature(input, domain = stakeControlEIP712Domain(1)) {
     const message = buildStakeMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12110,7 +12141,7 @@ async function validateStakeSignature(input, domain = stakeControlEIP712Domain)
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712Domain) {
+async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712Domain(1)) {
     const message = buildUnstakeUnlockMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12137,7 +12168,7 @@ async function validateUnstakeUnlockSignature(input, domain = stakeControlEIP712
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Domain) {
+async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Domain(1)) {
     const message = buildUnstakeMoveMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12165,7 +12196,7 @@ async function validateUnstakeMoveSignature(input, domain = stakeControlEIP712Do
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
-async function validateRestakeSignature(input, domain = stakeControlEIP712Domain) {
+async function validateRestakeSignature(input, domain = stakeControlEIP712Domain(1)) {
     const message = buildRestakeMessage({
         nonce: input.nonce,
         amount: input.amount,
@@ -12193,6 +12224,33 @@ async function validateRestakeSignature(input, domain = stakeControlEIP712Domain
         return { valid: false, recovered: null, reason: "signature_failed" };
     }
 }
+async function validateCommitKickstarterSignature(input, domain = stakeControlEIP712Domain(1)) {
+    const message = buildCommitKickstarterMessage({
+        nonce: input.nonce,
+        amount: input.amount,
+        kickstarterId: input.kickstarterId,
+        deadline: input.deadline,
+    });
+    if (isDeadlineExpired(message.deadline)) {
+        return { valid: false, recovered: null, reason: "deadline_expired" };
+    }
+    try {
+        const verified = await verifyTypedData({
+            address: input.wallet,
+            domain,
+            types: commitKickstarterEIP712Types,
+            primaryType: "CommitKickstarter",
+            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 { buildRestakeMessage, buildStakeMessage, buildUnstakeMoveMessage, buildUnstakeUnlockMessage, restakeEIP712Types, restakeSignatureRequestSchema, stakeControlEIP712Domain, stakeEIP712Types, stakeSignatureRequestSchema, unstakeMoveEIP712Types, unstakeMoveSignatureRequestSchema, unstakeUnlockEIP712Types, unstakeUnlockSignatureRequestSchema, validateRestakeSignature, validateStakeSignature, validateUnstakeMoveSignature, validateUnstakeUnlockSignature };
+export { buildCommitKickstarterMessage, buildRestakeMessage, buildStakeMessage, buildUnstakeMoveMessage, buildUnstakeUnlockMessage, commitKickstarterEIP712Types, commitKickstarterSignatureRequestSchema, restakeEIP712Types, restakeSignatureRequestSchema, stakeControlEIP712Domain, stakeEIP712Types, stakeSignatureRequestSchema, unstakeMoveEIP712Types, unstakeMoveSignatureRequestSchema, unstakeUnlockEIP712Types, unstakeUnlockSignatureRequestSchema, validateCommitKickstarterSignature, validateRestakeSignature, validateStakeSignature, validateUnstakeMoveSignature, validateUnstakeUnlockSignature };
 //# sourceMappingURL=browser.js.map