@coinbase/cdp-sdk 1.35.0 → 1.36.1

package/_types/policies/solanaSchema.d.ts

@@ -53,6 +53,153 @@ export declare const MintAddressOperatorEnum: z.ZodEnum<["in", "not in"]>;
  * These operators determine how token mint addresses are evaluated against a list.
  */
 export type MintAddressOperator = z.infer<typeof MintAddressOperatorEnum>;
+/**
+ * Enum for KnownIdlType values
+ */
+export declare const KnownIdlTypeEnum: z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>;
+/**
+ * Type representing known Solana programs that have established IDL specifications.
+ * These programs can be referenced directly by name in policy rules.
+ */
+export type KnownIdlType = z.infer<typeof KnownIdlTypeEnum>;
+/**
+ * Schema for IDL specifications following Anchor's IDL format v0.30+
+ */
+export declare const IdlSchema: z.ZodObject<{
+    /** The program address */
+    address: z.ZodString;
+    /** Array of instruction specifications */
+    instructions: z.ZodArray<z.ZodAny, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    /** The program address */
+    address: z.ZodString;
+    /** Array of instruction specifications */
+    instructions: z.ZodArray<z.ZodAny, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    /** The program address */
+    address: z.ZodString;
+    /** Array of instruction specifications */
+    instructions: z.ZodArray<z.ZodAny, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+export type Idl = z.infer<typeof IdlSchema>;
+/**
+ * Enum for SolDataParameterOperator values
+ */
+export declare const SolDataParameterOperatorEnum: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+/**
+ * Type representing the operators that can be used for Solana data parameter comparisons.
+ */
+export type SolDataParameterOperator = z.infer<typeof SolDataParameterOperatorEnum>;
+/**
+ * Enum for SolDataParameterListOperator values
+ */
+export declare const SolDataParameterListOperatorEnum: z.ZodEnum<["in", "not in"]>;
+/**
+ * Type representing the operators that can be used for Solana data parameter list comparisons.
+ */
+export type SolDataParameterListOperator = z.infer<typeof SolDataParameterListOperatorEnum>;
+/**
+ * Schema for Solana data parameter conditions (single value)
+ */
+export declare const SolDataParameterConditionSchema: z.ZodObject<{
+    /** The parameter name */
+    name: z.ZodString;
+    /** The operator to use for the comparison */
+    operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+    /** The value to compare against */
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    name: string;
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}, {
+    value: string;
+    name: string;
+    operator: ">" | ">=" | "<" | "<=" | "==";
+}>;
+export type SolDataParameterCondition = z.infer<typeof SolDataParameterConditionSchema>;
+/**
+ * Schema for Solana data parameter conditions (list values)
+ */
+export declare const SolDataParameterConditionListSchema: z.ZodObject<{
+    /** The parameter name */
+    name: z.ZodString;
+    /** The operator to use for the comparison */
+    operator: z.ZodEnum<["in", "not in"]>;
+    /** The values to compare against */
+    values: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    values: string[];
+    name: string;
+    operator: "in" | "not in";
+}, {
+    values: string[];
+    name: string;
+    operator: "in" | "not in";
+}>;
+export type SolDataParameterConditionList = z.infer<typeof SolDataParameterConditionListSchema>;
+/**
+ * Schema for Solana data conditions
+ */
+export declare const SolDataConditionSchema: z.ZodObject<{
+    /** The instruction name */
+    instruction: z.ZodString;
+    /** Parameter conditions for the instruction */
+    params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        /** The parameter name */
+        name: z.ZodString;
+        /** The operator to use for the comparison */
+        operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+        /** The value to compare against */
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        name: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }, {
+        value: string;
+        name: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    }>, z.ZodObject<{
+        /** The parameter name */
+        name: z.ZodString;
+        /** The operator to use for the comparison */
+        operator: z.ZodEnum<["in", "not in"]>;
+        /** The values to compare against */
+        values: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    }, {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    instruction: string;
+    params?: ({
+        value: string;
+        name: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    })[] | undefined;
+}, {
+    instruction: string;
+    params?: ({
+        value: string;
+        name: string;
+        operator: ">" | ">=" | "<" | "<=" | "==";
+    } | {
+        values: string[];
+        name: string;
+        operator: "in" | "not in";
+    })[] | undefined;
+}>;
+export type SolDataCondition = z.infer<typeof SolDataConditionSchema>;
 /**
  * Schema for Solana address criterions
  */
@@ -180,6 +327,135 @@ export declare const MintAddressCriterionSchema: z.ZodObject<{
     addresses: string[];
 }>;
 export type MintAddressCriterion = z.infer<typeof MintAddressCriterionSchema>;
+/**
+ * Schema for Solana data criterions
+ */
+export declare const SolDataCriterionSchema: z.ZodObject<{
+    /** The type of criterion, must be "solData" for Solana data-based rules. */
+    type: z.ZodLiteral<"solData">;
+    /**
+     * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+     */
+    idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    /**
+     * A list of conditions to apply against the transaction instruction.
+     * Only one condition must evaluate to true for this criterion to be met.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /** The instruction name */
+        instruction: z.ZodString;
+        /** Parameter conditions for the instruction */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /** The value to compare against */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /** The values to compare against */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}>;
+export type SolDataCriterion = z.infer<typeof SolDataCriterionSchema>;
 /**
  * Schema for criteria used in SignSolTransaction operations
  */
@@ -285,6 +561,130 @@ export declare const SignSolTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
     type: "mintAddress";
     operator: "in" | "not in";
     addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solData" for Solana data-based rules. */
+    type: z.ZodLiteral<"solData">;
+    /**
+     * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+     */
+    idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    /**
+     * A list of conditions to apply against the transaction instruction.
+     * Only one condition must evaluate to true for this criterion to be met.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /** The instruction name */
+        instruction: z.ZodString;
+        /** Parameter conditions for the instruction */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /** The value to compare against */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /** The values to compare against */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
 }>]>, "many">;
 /**
  * Type representing a set of criteria for the signSolTransaction operation.
@@ -396,6 +796,130 @@ export declare const SendSolTransactionCriteriaSchema: z.ZodArray<z.ZodDiscrimin
     type: "mintAddress";
     operator: "in" | "not in";
     addresses: string[];
+}>, z.ZodObject<{
+    /** The type of criterion, must be "solData" for Solana data-based rules. */
+    type: z.ZodLiteral<"solData">;
+    /**
+     * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+     */
+    idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">;
+    /**
+     * A list of conditions to apply against the transaction instruction.
+     * Only one condition must evaluate to true for this criterion to be met.
+     */
+    conditions: z.ZodArray<z.ZodObject<{
+        /** The instruction name */
+        instruction: z.ZodString;
+        /** Parameter conditions for the instruction */
+        params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+            /** The value to compare against */
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }, {
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        }>, z.ZodObject<{
+            /** The parameter name */
+            name: z.ZodString;
+            /** The operator to use for the comparison */
+            operator: z.ZodEnum<["in", "not in"]>;
+            /** The values to compare against */
+            values: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }, {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        }>]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }, {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
+}, {
+    type: "solData";
+    conditions: {
+        instruction: string;
+        params?: ({
+            value: string;
+            name: string;
+            operator: ">" | ">=" | "<" | "<=" | "==";
+        } | {
+            values: string[];
+            name: string;
+            operator: "in" | "not in";
+        })[] | undefined;
+    }[];
+    idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+        /** The program address */
+        address: z.ZodString;
+        /** Array of instruction specifications */
+        instructions: z.ZodArray<z.ZodAny, "many">;
+    }, z.ZodTypeAny, "passthrough">)[];
 }>]>, "many">;
 /**
  * Type representing a set of criteria for the sendSolTransaction operation.
@@ -532,6 +1056,130 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solData" for Solana data-based rules. */
+        type: z.ZodLiteral<"solData">;
+        /**
+         * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+         */
+        idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">;
+        /**
+         * A list of conditions to apply against the transaction instruction.
+         * Only one condition must evaluate to true for this criterion to be met.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /** The instruction name */
+            instruction: z.ZodString;
+            /** Parameter conditions for the instruction */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /** The value to compare against */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /** The values to compare against */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -556,6 +1204,26 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -580,6 +1248,26 @@ export declare const SignSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     })[];
 }>;
 export type SignSolTransactionRule = z.infer<typeof SignSolTransactionRuleSchema>;
@@ -704,6 +1392,130 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    }>, z.ZodObject<{
+        /** The type of criterion, must be "solData" for Solana data-based rules. */
+        type: z.ZodLiteral<"solData">;
+        /**
+         * List of IDL specifications. Can contain known program names (strings) or custom IDL objects.
+         */
+        idls: z.ZodArray<z.ZodUnion<[z.ZodEnum<["SystemProgram", "TokenProgram", "AssociatedTokenProgram"]>, z.ZodObject<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">;
+        /**
+         * A list of conditions to apply against the transaction instruction.
+         * Only one condition must evaluate to true for this criterion to be met.
+         */
+        conditions: z.ZodArray<z.ZodObject<{
+            /** The instruction name */
+            instruction: z.ZodString;
+            /** Parameter conditions for the instruction */
+            params: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<[">", ">=", "<", "<=", "=="]>;
+                /** The value to compare against */
+                value: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }, {
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            }>, z.ZodObject<{
+                /** The parameter name */
+                name: z.ZodString;
+                /** The operator to use for the comparison */
+                operator: z.ZodEnum<["in", "not in"]>;
+                /** The values to compare against */
+                values: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }, {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            }>]>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }, {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
+    }, {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
     action: "reject" | "accept";
@@ -728,6 +1540,26 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectOutputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     })[];
 }, {
     action: "reject" | "accept";
@@ -752,6 +1584,26 @@ export declare const SendSolTransactionRuleSchema: z.ZodObject<{
         type: "mintAddress";
         operator: "in" | "not in";
         addresses: string[];
+    } | {
+        type: "solData";
+        conditions: {
+            instruction: string;
+            params?: ({
+                value: string;
+                name: string;
+                operator: ">" | ">=" | "<" | "<=" | "==";
+            } | {
+                values: string[];
+                name: string;
+                operator: "in" | "not in";
+            })[] | undefined;
+        }[];
+        idls: ("SystemProgram" | "TokenProgram" | "AssociatedTokenProgram" | z.objectInputType<{
+            /** The program address */
+            address: z.ZodString;
+            /** Array of instruction specifications */
+            instructions: z.ZodArray<z.ZodAny, "many">;
+        }, z.ZodTypeAny, "passthrough">)[];
     })[];
 }>;
 export type SendSolTransactionRule = z.infer<typeof SendSolTransactionRuleSchema>;