viem 2.42.1 → 2.43.0

package/_types/chains/definitions/lineaSepolia.d.ts

@@ -39,6 +39,7 @@ export declare const lineaSepolia: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees: {
         readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<import("../../index.js").ChainEstimateFeesPerGasFn>[0]) => ReturnType<import("../../index.js").ChainEstimateFeesPerGasFn>;
         readonly maxPriorityFeePerGas: ({ block, client, request }: import("../../index.js").ChainFeesFnParameters<import("../../index.js").ChainFormatters | undefined>) => Promise<bigint | null>;
@@ -52,5 +53,6 @@ export declare const lineaSepolia: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lineaSepolia.d.ts.map

package/_types/chains/definitions/lineaSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineaSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lineaSepolia.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCvB,CAAA"}
+{"version":3,"file":"lineaSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lineaSepolia.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCvB,CAAA"}

package/_types/chains/definitions/lineaTestnet.d.ts

@@ -31,6 +31,7 @@ export declare const lineaTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -41,5 +42,6 @@ export declare const lineaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lineaTestnet.d.ts.map

package/_types/chains/definitions/lineaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lineaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lineaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBvB,CAAA"}
+{"version":3,"file":"lineaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lineaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBvB,CAAA"}

package/_types/chains/definitions/lisk.d.ts

@@ -62,6 +62,7 @@ export declare const lisk: {
     sourceId: 1;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -304,6 +305,7 @@ export declare const lisk: {
     serializers: {
         readonly transaction: typeof import("../index.js").serializeTransactionOpStack;
     };
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "lisk";
 };
 //# sourceMappingURL=lisk.d.ts.map

package/_types/chains/definitions/lisk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisk.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lisk.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cf,CAAA"}
+{"version":3,"file":"lisk.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lisk.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Cf,CAAA"}

package/_types/chains/definitions/liskSepolia.d.ts

@@ -62,6 +62,7 @@ export declare const liskSepolia: {
     sourceId: 11155111;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -304,6 +305,7 @@ export declare const liskSepolia: {
     serializers: {
         readonly transaction: typeof import("../index.js").serializeTransactionOpStack;
     };
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "lisk-sepolia";
 };
 //# sourceMappingURL=liskSepolia.d.ts.map

package/_types/chains/definitions/liskSepolia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"liskSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/liskSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCtB,CAAA"}
+{"version":3,"file":"liskSepolia.d.ts","sourceRoot":"","sources":["../../../chains/definitions/liskSepolia.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCtB,CAAA"}

package/_types/chains/definitions/loadAlphanet.d.ts

@@ -32,6 +32,7 @@ export declare const loadAlphanet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const loadAlphanet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=loadAlphanet.d.ts.map

package/_types/chains/definitions/loadAlphanet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadAlphanet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/loadAlphanet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcvB,CAAA"}
+{"version":3,"file":"loadAlphanet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/loadAlphanet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcvB,CAAA"}

package/_types/chains/definitions/localhost.d.ts

@@ -38,6 +38,7 @@ export declare const localhost: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -48,5 +49,6 @@ export declare const localhost: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=localhost.d.ts.map

package/_types/chains/definitions/localhost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localhost.d.ts","sourceRoot":"","sources":["../../../chains/definitions/localhost.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWpB,CAAA"}
+{"version":3,"file":"localhost.d.ts","sourceRoot":"","sources":["../../../chains/definitions/localhost.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWpB,CAAA"}

package/_types/chains/definitions/loop.d.ts

@@ -32,6 +32,7 @@ export declare const loop: {
     sourceId?: number | undefined | undefined;
     testnet: false;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const loop: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=loop.d.ts.map

package/_types/chains/definitions/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../chains/definitions/loop.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBf,CAAA"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../../chains/definitions/loop.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBf,CAAA"}

package/_types/chains/definitions/lukso.d.ts

@@ -31,6 +31,7 @@ export declare const lukso: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -41,6 +42,7 @@ export declare const lukso: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "lukso";
 };
 //# sourceMappingURL=lukso.d.ts.map

package/_types/chains/definitions/lukso.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lukso.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lukso.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhB,CAAA"}
+{"version":3,"file":"lukso.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lukso.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhB,CAAA"}

package/_types/chains/definitions/luksoTestnet.d.ts

@@ -31,6 +31,7 @@ export declare const luksoTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -41,5 +42,6 @@ export declare const luksoTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=luksoTestnet.d.ts.map

package/_types/chains/definitions/luksoTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"luksoTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/luksoTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvB,CAAA"}
+{"version":3,"file":"luksoTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/luksoTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvB,CAAA"}

package/_types/chains/definitions/lumiaMainnet.d.ts

@@ -29,6 +29,7 @@ export declare const lumiaMainnet: {
     sourceId?: number | undefined | undefined;
     testnet: false;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -39,6 +40,7 @@ export declare const lumiaMainnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "LumiaMainnet";
 };
 //# sourceMappingURL=lumiaMainnet.d.ts.map

package/_types/chains/definitions/lumiaMainnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lumiaMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumiaMainnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBvB,CAAA"}
+{"version":3,"file":"lumiaMainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumiaMainnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBvB,CAAA"}

package/_types/chains/definitions/lumiaTestnet.d.ts

@@ -29,6 +29,7 @@ export declare const lumiaTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -39,6 +40,7 @@ export declare const lumiaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "LumiaTestnet";
 };
 //# sourceMappingURL=lumiaTestnet.d.ts.map

package/_types/chains/definitions/lumiaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lumiaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumiaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BvB,CAAA"}
+{"version":3,"file":"lumiaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumiaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BvB,CAAA"}

package/_types/chains/definitions/lumoz.d.ts

@@ -32,6 +32,7 @@ export declare const lumoz: {
     sourceId?: number | undefined | undefined;
     testnet: false;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const lumoz: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lumoz.d.ts.map

package/_types/chains/definitions/lumoz.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lumoz.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumoz.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBhB,CAAA"}
+{"version":3,"file":"lumoz.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumoz.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBhB,CAAA"}

package/_types/chains/definitions/lumozTestnet.d.ts

@@ -38,6 +38,7 @@ export declare const lumozTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -48,5 +49,6 @@ export declare const lumozTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lumozTestnet.d.ts.map

package/_types/chains/definitions/lumozTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lumozTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumozTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcvB,CAAA"}
+{"version":3,"file":"lumozTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lumozTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcvB,CAAA"}

package/_types/chains/definitions/lycan.d.ts

@@ -33,6 +33,7 @@ export declare const lycan: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -43,5 +44,6 @@ export declare const lycan: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lycan.d.ts.map

package/_types/chains/definitions/lycan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lycan.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lycan.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkChB,CAAA"}
+{"version":3,"file":"lycan.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lycan.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkChB,CAAA"}

package/_types/chains/definitions/lyra.d.ts

@@ -30,6 +30,7 @@ export declare const lyra: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,5 +41,6 @@ export declare const lyra: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=lyra.d.ts.map

package/_types/chains/definitions/lyra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lyra.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lyra.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBf,CAAA"}
+{"version":3,"file":"lyra.d.ts","sourceRoot":"","sources":["../../../chains/definitions/lyra.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBf,CAAA"}

package/_types/chains/definitions/mainnet.d.ts

@@ -34,6 +34,7 @@ export declare const mainnet: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -44,5 +45,6 @@ export declare const mainnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mainnet.d.ts.map

package/_types/chains/definitions/mainnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mainnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAA"}
+{"version":3,"file":"mainnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mainnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAA"}

package/_types/chains/definitions/mandala.d.ts

@@ -34,6 +34,7 @@ export declare const mandala: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -44,6 +45,7 @@ export declare const mandala: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "mandala";
 };
 //# sourceMappingURL=mandala.d.ts.map

package/_types/chains/definitions/mandala.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mandala.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mandala.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBlB,CAAA"}
+{"version":3,"file":"mandala.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mandala.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBlB,CAAA"}

package/_types/chains/definitions/manta.d.ts

@@ -30,6 +30,7 @@ export declare const manta: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,6 +41,7 @@ export declare const manta: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "manta";
 };
 //# sourceMappingURL=manta.d.ts.map

package/_types/chains/definitions/manta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manta.d.ts","sourceRoot":"","sources":["../../../chains/definitions/manta.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBhB,CAAA"}
+{"version":3,"file":"manta.d.ts","sourceRoot":"","sources":["../../../chains/definitions/manta.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBhB,CAAA"}

package/_types/chains/definitions/mantaSepoliaTestnet.d.ts

@@ -30,6 +30,7 @@ export declare const mantaSepoliaTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,6 +41,7 @@ export declare const mantaSepoliaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "manta-sepolia";
 };
 //# sourceMappingURL=mantaSepoliaTestnet.d.ts.map

package/_types/chains/definitions/mantaSepoliaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantaSepoliaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantaSepoliaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B9B,CAAA"}
+{"version":3,"file":"mantaSepoliaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantaSepoliaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B9B,CAAA"}

package/_types/chains/definitions/mantaTestnet.d.ts

@@ -30,6 +30,7 @@ export declare const mantaTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,6 +41,7 @@ export declare const mantaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "manta-testnet";
 };
 //# sourceMappingURL=mantaTestnet.d.ts.map

package/_types/chains/definitions/mantaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAA"}
+{"version":3,"file":"mantaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BvB,CAAA"}

package/_types/chains/definitions/mantle.d.ts

@@ -30,6 +30,7 @@ export declare const mantle: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,5 +41,6 @@ export declare const mantle: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mantle.d.ts.map

package/_types/chains/definitions/mantle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantle.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBjB,CAAA"}
+{"version":3,"file":"mantle.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantle.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBjB,CAAA"}

package/_types/chains/definitions/mantleSepoliaTestnet.d.ts

@@ -30,6 +30,7 @@ export declare const mantleSepoliaTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,5 +41,6 @@ export declare const mantleSepoliaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mantleSepoliaTestnet.d.ts.map

package/_types/chains/definitions/mantleSepoliaTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantleSepoliaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantleSepoliaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAA"}
+{"version":3,"file":"mantleSepoliaTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantleSepoliaTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB/B,CAAA"}

package/_types/chains/definitions/mantleTestnet.d.ts

@@ -30,6 +30,7 @@ export declare const mantleTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -40,5 +41,6 @@ export declare const mantleTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mantleTestnet.d.ts.map

package/_types/chains/definitions/mantleTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantleTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantleTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAA"}
+{"version":3,"file":"mantleTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantleTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBxB,CAAA"}

package/_types/chains/definitions/mantraDuKongEVMTestnet.d.ts

@@ -32,6 +32,7 @@ export declare const mantraDuKongEVMTestnet: {
     sourceId?: number | undefined | undefined;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const mantraDuKongEVMTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mantraDuKongEVMTestnet.d.ts.map

package/_types/chains/definitions/mantraDuKongEVMTestnet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantraDuKongEVMTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantraDuKongEVMTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBjC,CAAA"}
+{"version":3,"file":"mantraDuKongEVMTestnet.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantraDuKongEVMTestnet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBjC,CAAA"}

package/_types/chains/definitions/mantraEVM.d.ts

@@ -33,6 +33,7 @@ export declare const mantraEVM: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -43,5 +44,6 @@ export declare const mantraEVM: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mantraEVM.d.ts.map

package/_types/chains/definitions/mantraEVM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mantraEVM.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantraEVM.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBpB,CAAA"}
+{"version":3,"file":"mantraEVM.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mantraEVM.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBpB,CAAA"}

package/_types/chains/definitions/mapProtocol.d.ts

@@ -32,6 +32,7 @@ export declare const mapProtocol: {
     sourceId?: number | undefined | undefined;
     testnet: false;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const mapProtocol: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=mapProtocol.d.ts.map

package/_types/chains/definitions/mapProtocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapProtocol.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mapProtocol.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBtB,CAAA"}
+{"version":3,"file":"mapProtocol.d.ts","sourceRoot":"","sources":["../../../chains/definitions/mapProtocol.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBtB,CAAA"}

package/_types/chains/definitions/matchain.d.ts

@@ -32,6 +32,7 @@ export declare const matchain: {
     sourceId?: number | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters?: undefined;
     prepareTransactionRequest?: ((args: import("../../index.js").PrepareTransactionRequestParameters, options: {
@@ -42,5 +43,6 @@ export declare const matchain: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=matchain.d.ts.map

package/_types/chains/definitions/matchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matchain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/matchain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBnB,CAAA"}
+{"version":3,"file":"matchain.d.ts","sourceRoot":"","sources":["../../../chains/definitions/matchain.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiBnB,CAAA"}