viem 2.42.0 → 2.43.0

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

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

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

@@ -30,6 +30,7 @@ export declare const fantom: {
     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 fantom: {
         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=fantom.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const fantomSonicTestnet: {
     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,6 +43,7 @@ export declare const fantomSonicTestnet: {
         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: "fantom-sonic-testnet";
 };
 //# sourceMappingURL=fantomSonicTestnet.d.ts.map

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

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

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

@@ -30,6 +30,7 @@ export declare const fantomTestnet: {
     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 fantomTestnet: {
         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=fantomTestnet.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const fibo: {
     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 fibo: {
         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=fibo.d.ts.map

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

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

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

@@ -29,6 +29,7 @@ export declare const filecoin: {
     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: {
@@ -39,5 +40,6 @@ export declare const filecoin: {
         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=filecoin.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const filecoinCalibration: {
     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 filecoinCalibration: {
         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=filecoinCalibration.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const filecoinHyperspace: {
     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 filecoinHyperspace: {
         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=filecoinHyperspace.d.ts.map

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

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

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

@@ -30,6 +30,7 @@ export declare const flame: {
     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 flame: {
         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: "flame";
 };
 //# sourceMappingURL=flame.d.ts.map

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

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

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

@@ -30,6 +30,7 @@ export declare const flare: {
     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 flare: {
         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=flare.d.ts.map

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

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

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

@@ -33,6 +33,7 @@ export declare const flareTestnet: {
     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: {
@@ -43,5 +44,6 @@ export declare const flareTestnet: {
         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=flareTestnet.d.ts.map

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

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

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

@@ -29,6 +29,7 @@ export declare const flowMainnet: {
     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: {
@@ -39,5 +40,6 @@ export declare const flowMainnet: {
         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=flowMainnet.d.ts.map

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

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

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

@@ -29,6 +29,7 @@ export declare const flowPreviewnet: {
     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: {
@@ -39,5 +40,6 @@ export declare const flowPreviewnet: {
         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=flowPreviewnet.d.ts.map

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

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

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

@@ -29,6 +29,7 @@ export declare const flowTestnet: {
     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,5 +40,6 @@ export declare const flowTestnet: {
         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=flowTestnet.d.ts.map

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

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

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

@@ -31,6 +31,7 @@ export declare const fluence: {
     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,5 +42,6 @@ export declare const fluence: {
         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=fluence.d.ts.map

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

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

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

@@ -31,6 +31,7 @@ export declare const fluenceStage: {
     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 fluenceStage: {
         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=fluenceStage.d.ts.map

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

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

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

@@ -31,6 +31,7 @@ export declare const fluenceTestnet: {
     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 fluenceTestnet: {
         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=fluenceTestnet.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const fluentTestnet: {
     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 fluentTestnet: {
         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=fluentTestnet.d.ts.map

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

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

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

@@ -72,6 +72,7 @@ export declare const form: {
     sourceId: 1;
     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: {
@@ -82,5 +83,6 @@ export declare const form: {
         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=form.d.ts.map

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

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

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

@@ -72,6 +72,7 @@ export declare const formTestnet: {
     sourceId: 11155111;
     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: {
@@ -82,5 +83,6 @@ export declare const formTestnet: {
         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=formTestnet.d.ts.map

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

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

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

@@ -30,6 +30,7 @@ export declare const forma: {
     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 forma: {
         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: "forma";
 };
 //# sourceMappingURL=forma.d.ts.map

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

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

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

@@ -32,6 +32,7 @@ export declare const forta: {
     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 forta: {
         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=forta.d.ts.map

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

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

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

@@ -39,6 +39,7 @@ export declare const foundry: {
     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: {
@@ -49,5 +50,6 @@ export declare const foundry: {
         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=foundry.d.ts.map

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

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

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

@@ -64,6 +64,7 @@ export declare const fraxtal: {
     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: {
@@ -306,5 +307,6 @@ export declare const fraxtal: {
     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;
 };
 //# sourceMappingURL=fraxtal.d.ts.map

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

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

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

@@ -64,6 +64,7 @@ export declare const fraxtalTestnet: {
     sourceId: 17000;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -306,5 +307,6 @@ export declare const fraxtalTestnet: {
     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;
 };
 //# sourceMappingURL=fraxtalTestnet.d.ts.map

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

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

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

@@ -43,6 +43,7 @@ export declare const funkiMainnet: {
     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: {
@@ -285,5 +286,6 @@ export declare const funkiMainnet: {
     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;
 };
 //# sourceMappingURL=funkiMainnet.d.ts.map

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

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

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

@@ -47,6 +47,7 @@ export declare const funkiSepolia: {
     sourceId: 11155111;
     testnet: true;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("../../index.js").ChainFees<undefined> | undefined;
     formatters: {
         readonly block: {
@@ -289,6 +290,7 @@ export declare const funkiSepolia: {
     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: "funkiSepolia";
 };
 //# sourceMappingURL=funkiSepolia.d.ts.map

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

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

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

@@ -30,6 +30,7 @@ export declare const fuse: {
     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 fuse: {
         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=fuse.d.ts.map

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

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