viem 2.57.7 → 2.57.8

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

@@ -68,6 +68,25 @@ export declare const tempo: {
             transaction: import("../../index.js").TransactionSerializable;
         }) => Promise<`0x${string}`>;
     };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("abitype").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("../../index.js").ReplacementReason;
+    };
     verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     extend: <const extended_1 extends {
         feeToken?: import("ox/tempo/TokenId").TokenIdOrAddress | undefined;
@@ -135,6 +154,25 @@ export declare const tempo: {
                 transaction: import("../../index.js").TransactionSerializable;
             }) => Promise<`0x${string}`>;
         };
+        readonly transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("../../index.js").ReplacementReason;
+        };
         readonly verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     }>, extended_1>;
 };

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

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

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

@@ -69,6 +69,25 @@ export declare const tempoDevnet: {
             transaction: import("../../index.js").TransactionSerializable;
         }) => Promise<`0x${string}`>;
     };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("abitype").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("../../index.js").ReplacementReason;
+    };
     verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     readonly hardfork: "t3";
     extend: <const extended_1 extends {
@@ -131,6 +150,25 @@ export declare const tempoDevnet: {
                 transaction: import("../../index.js").TransactionSerializable;
             }) => Promise<`0x${string}`>;
         };
+        readonly transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("../../index.js").ReplacementReason;
+        };
         readonly verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     }>, extended_1>;
 };

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

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

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

@@ -74,6 +74,25 @@ export declare const tempoLocalnet: {
             transaction: import("../../index.js").TransactionSerializable;
         }) => Promise<`0x${string}`>;
     };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("abitype").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("../../index.js").ReplacementReason;
+    };
     verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     readonly hardfork: "t3";
     extend: <const extended_1 extends {
@@ -128,6 +147,25 @@ export declare const tempoLocalnet: {
                 transaction: import("../../index.js").TransactionSerializable;
             }) => Promise<`0x${string}`>;
         };
+        readonly transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("../../index.js").ReplacementReason;
+        };
         readonly verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     }>, extended_1>;
 };

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

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

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

@@ -68,6 +68,25 @@ export declare const tempoModerato: {
             transaction: import("../../index.js").TransactionSerializable;
         }) => Promise<`0x${string}`>;
     };
+    transactionReplacement: {
+        readonly getKey: (transaction: {
+            from: import("abitype").Address;
+            hash: `0x${string}`;
+            nonce: number;
+        }) => string;
+        readonly getReason: ({ replaced, replacement }: {
+            replaced: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+            replacement: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            };
+        }) => import("../../index.js").ReplacementReason;
+    };
     verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     readonly hardfork: "t5";
     extend: <const extended_1 extends {
@@ -138,6 +157,25 @@ export declare const tempoModerato: {
                 transaction: import("../../index.js").TransactionSerializable;
             }) => Promise<`0x${string}`>;
         };
+        readonly transactionReplacement: {
+            readonly getKey: (transaction: {
+                from: import("abitype").Address;
+                hash: `0x${string}`;
+                nonce: number;
+            }) => string;
+            readonly getReason: ({ replaced, replacement }: {
+                replaced: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+                replacement: {
+                    from: import("abitype").Address;
+                    hash: `0x${string}`;
+                    nonce: number;
+                };
+            }) => import("../../index.js").ReplacementReason;
+        };
         readonly verifyHash: (client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<boolean>;
     }>, extended_1>;
 };

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

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

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

@@ -47,6 +47,7 @@ export declare const tenet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
     readonly network: "tenet-mainnet";
 };

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

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

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

@@ -46,6 +46,7 @@ export declare const ternoa: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ternoa.d.ts.map

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

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

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

@@ -44,6 +44,7 @@ export declare const thaiChain: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=thaiChain.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const that: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=that.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const theta: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=theta.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const thetaTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=thetaTestnet.d.ts.map

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

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

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

@@ -43,6 +43,7 @@ export declare const thunderCore: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=thunderCore.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const thunderTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=thunderTestnet.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const tiktrixTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=tiktrixTestnet.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const tomb: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=tomb.d.ts.map

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

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

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

@@ -75,6 +75,7 @@ export declare const treasure: {
     serializers: {
         readonly transaction: typeof import("../../zksync/serializers.js").serializeTransaction;
     };
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=treasure.d.ts.map

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

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

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

@@ -75,6 +75,7 @@ export declare const treasureTopaz: {
     serializers: {
         readonly transaction: typeof import("../../zksync/serializers.js").serializeTransaction;
     };
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=treasureTopaz.d.ts.map

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

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

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

@@ -47,6 +47,7 @@ export declare const tron: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=tron.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const tronNile: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=tronNile.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const tronShasta: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=tronShasta.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const ubiq: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ubiq.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const ultra: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ultra.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const ultraTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ultraTestnet.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const ultron: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ultron.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const ultronTestnet: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=ultronTestnet.d.ts.map

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

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

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

@@ -95,6 +95,7 @@ export declare const unichain: {
     serializers: {
         readonly transaction: typeof import("../index.js").serializeTransactionOpStack;
     };
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=unichain.d.ts.map

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

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

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

@@ -95,6 +95,7 @@ export declare const unichainSepolia: {
     serializers: {
         readonly transaction: typeof import("../index.js").serializeTransactionOpStack;
     };
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=unichainSepolia.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const unique: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=unique.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const uniqueOpal: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=uniqueOpal.d.ts.map

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

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

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

@@ -46,6 +46,7 @@ export declare const uniqueQuartz: {
         runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
     }] | undefined;
     serializers?: import("../../index.js").ChainSerializers<undefined, import("../../index.js").TransactionSerializable> | undefined;
+    transactionReplacement?: import("../../types/chain.js").ChainTransactionReplacement | undefined;
     verifyHash?: ((client: import("../../index.js").Client, parameters: import("../../index.js").VerifyHashActionParameters) => Promise<import("../../index.js").VerifyHashActionReturnType>) | undefined;
 };
 //# sourceMappingURL=uniqueQuartz.d.ts.map