ox 0.14.57 → 0.14.59

package/_types/tempo/AccountConfig.d.ts

@@ -1,6 +1,5 @@
 import * as Address from '../core/Address.js';
 import type * as Bytes from '../core/Bytes.js';
-import * as ContractAddress from '../core/ContractAddress.js';
 import * as Errors from '../core/Errors.js';
 import * as Hash from '../core/Hash.js';
 import * as Hex from '../core/Hex.js';
@@ -217,9 +216,9 @@ export declare namespace fromUpgrade {
 /**
  * Derives the stable configurable account address.
  *
- * The initial config is hashed into a CREATE2 salt using fixed-width
- * big-endian fields, not RLP. The account uses the chain-configured recovery
- * factory and account proxy init-code hash.
+ * The address is the last 20 bytes of the keccak256 hash of the initial
+ * config, encoded with fixed-width big-endian fields, not RLP:
+ * `keccak256("tempo:configurable-account:account" || salt || uint8(threshold) || uint8(owners.length) || owners)`.
  *
  * The address is derived once from the initial version-0 config. Config
  * updates do not change it.
@@ -235,22 +234,15 @@ export declare namespace fromUpgrade {
  *   threshold: 1,
  * })
  *
- * const address = AccountConfig.getAddress(initialConfig, {
- *   factory: '0x7171717171717171717171717171717171717171'
- * })
+ * const address = AccountConfig.getAddress(initialConfig)
  * ```
  *
  * @param config - The initial account config.
- * @param options - The recovery factory configured by the chain.
  * @returns The configurable account address.
  */
-export declare function getAddress(config: Input, options: getAddress.Options): Address.Address;
+export declare function getAddress(config: Input): Address.Address;
 export declare namespace getAddress {
-    type Options = {
-        /** Recovery factory configured by the chain. */
-        factory: Address.Address;
-    };
-    type ErrorType = assert.ErrorType | ContractAddress.fromCreate2.ErrorType | Hash.keccak256.ErrorType | Hex.concat.ErrorType | Hex.fromNumber.ErrorType | Hex.fromString.ErrorType | Errors.GlobalErrorType;
+    type ErrorType = assert.ErrorType | Hash.keccak256.ErrorType | Hex.concat.ErrorType | Hex.fromNumber.ErrorType | Hex.fromString.ErrorType | Hex.slice.ErrorType | Errors.GlobalErrorType;
 }
 /**
  * Computes the commitment for an account configuration.
@@ -306,9 +298,7 @@ export declare namespace getCommitment {
  * })
  *
  * const digest = AccountConfig.getSignPayload({
- *   account: AccountConfig.getAddress(config, {
- *     factory: '0x7171717171717171717171717171717171717171'
- *   }),
+ *   account: AccountConfig.getAddress(config),
  *   config,
  *   payload: TxEnvelopeTempo.getSignPayload(envelope),
  * })

package/_types/tempo/AccountConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccountConfig.d.ts","sourceRoot":"","sources":["../../tempo/AccountConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,OAAO,KAAK,KAAK,KAAK,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,eAAe,MAAM,4BAA4B,CAAA;AAC7D,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,GAAG,MAAM,gBAAgB,CAAA;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAExD,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,OAAO,CAAA;AAE1C,6DAA6D;AAC7D,eAAO,MAAM,SAAS,KAAK,CAAA;AAE3B,6EAA6E;AAC7E,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,MAAO,CAAA;AAEhC,qDAAqD;AACrD,eAAO,MAAM,UAAU,QAAiB,CAAA;AAExC,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,QAAkB,CAAA;AAEhD,gEAAgE;AAChE,eAAO,MAAM,QAAQ,eAAkC,CAAA;AAuBvD;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,UAAU,GAAG,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI,OAAO,CAAC;IACrE,gEAAgE;IAChE,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;IACpC,kCAAkC;IAClC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAA;IACb,6DAA6D;IAC7D,SAAS,EAAE,UAAU,CAAA;IACrB,wEAAwE;IACxE,OAAO,EAAE,UAAU,CAAA;CACpB,CAAC,CAAA;AAEF,iEAAiE;AACjE,MAAM,MAAM,KAAK,CACf,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EACrD,UAAU,GAAG,MAAM,IACjB,OAAO,CAAC;IACV,mEAAmE;IACnE,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;IACpC;;;OAGG;IACH,IAAI,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,CAAA;IAC1B,sEAAsE;IACtE,SAAS,EAAE,UAAU,CAAA;IACrB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;CAClC,CAAC,CAAA;AAEF,kCAAkC;AAClC,MAAM,MAAM,KAAK,CAAC,UAAU,GAAG,MAAM,IAAI;IACvC,2DAA2D;IAC3D,KAAK,EAAE,OAAO,CAAC,OAAO,CAAA;IACtB,4BAA4B;IAC5B,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,2DAA2D;AAC3D,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;AAEzC,qEAAqE;AACrE,MAAM,MAAM,KAAK,GAAG,SAAS;IAC3B,IAAI,EAAE,GAAG,CAAC,GAAG;IACb,OAAO,EAAE,GAAG,CAAC,GAAG;IAChB,SAAS,EAAE,GAAG,CAAC,GAAG;IAClB,MAAM,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,EAAE;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CACpB,WAAW,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EACrD,UAAU,GAAG,MAAM,EACnB,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG,IAAI,CA2D9C;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,KAAK,SAAS,GAAG,kBAAkB,GAAG,MAAM,CAAC,eAAe,CAAA;CAC7D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,UAAU,GAAG,MAAM,EACtC,MAAM,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,UAAU,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA;CAAE,GACnE,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,CAAA;AACzB,wBAAgB,IAAI,CAAC,UAAU,SAAS,MAAM,EAAE,UAAU,GAAG,MAAM,EACjE,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,GAAG;IAAE,OAAO,EAAE,UAAU,CAAA;CAAE,GAC9D,MAAM,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AACjC,wBAAgB,IAAI,CAAC,UAAU,GAAG,MAAM,EACtC,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACtD,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAC7B,wBAAgB,IAAI,CAAC,UAAU,GAAG,MAAM,EACtC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,CAAC,GACzC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;AAoB7B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,CAK3C;AAED,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,GAAG,CAAC,QAAQ,CAAC,SAAS,GACtB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAuC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,UAAU,GAAG,MAAM,EAC7C,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,GACvC,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,CAQxB;AAED,MAAM,CAAC,OAAO,WAAW,WAAW,CAAC;IACnC,KAAK,OAAO,CAAC,UAAU,GAAG,MAAM,IAAI;QAClC,+DAA+D;QAC/D,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;QACpC,6DAA6D;QAC7D,SAAS,EAAE,UAAU,CAAA;KACtB,CAAA;IAED,KAAK,SAAS,GACV,OAAO,CAAC,MAAM,CAAC,SAAS,GACxB,MAAM,CAAC,SAAS,GAChB,IAAI,CAAC,SAAS,CAAC,SAAS,GACxB,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,KAAK,EACb,OAAO,EAAE,UAAU,CAAC,OAAO,GAC1B,OAAO,CAAC,OAAO,CA+BjB;AAED,MAAM,CAAC,OAAO,WAAW,UAAU,CAAC;IAClC,KAAK,OAAO,GAAG;QACb,gDAAgD;QAChD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;KACzB,CAAA;IAED,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,eAAe,CAAC,WAAW,CAAC,SAAS,GACrC,IAAI,CAAC,SAAS,CAAC,SAAS,GACxB,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,KAAK,GAAG,GAAG,CAAC,GAAG,CAepD;AAED,MAAM,CAAC,OAAO,WAAW,aAAa,CAAC;IACrC,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,IAAI,CAAC,SAAS,CAAC,SAAS,GACxB,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAcnE;AAED,MAAM,CAAC,OAAO,WAAW,cAAc,CAAC;IACtC,KAAK,KAAK,GAAG;QACX,wCAAwC;QACxC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;QACxB,2DAA2D;QAC3D,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,SAAS,CAAC,CAAA;QAChD,kEAAkE;QAClE,OAAO,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;KAC/B,CAAA;IAED,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,IAAI,CAAC,SAAS,CAAC,SAAS,GACxB,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,IAAI,CAAC,SAAS,GAClB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,GAAG,GAAG,CAWxC;AAED,MAAM,CAAC,OAAO,WAAW,KAAK,CAAC;IAC7B,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,KAAK,GAAG,KAAK,CAe5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,UAAU,GAAG,MAAM,EACxC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,EAAE,UAAU,CAAC,EAC1C,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,GAClC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAU5B;AAED,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,KAAK,OAAO,CAAC,UAAU,GAAG,MAAM,IAAI;QAClC,gEAAgE;QAChE,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,CAAC,EAAE,CAAA;QACpC,yEAAyE;QACzE,SAAS,EAAE,UAAU,CAAA;KACtB,CAAA;IAED,KAAK,SAAS,GACV,MAAM,CAAC,SAAS,GAChB,kBAAkB,GAClB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,KAAK,GAAG,OAAO,CAO/C;AAED,gDAAgD;AAChD,qBAAa,kBAAmB,SAAQ,MAAM,CAAC,SAAS;IACtD,SAAkB,IAAI,sCAAqC;gBAC/C,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE;CAG3C"}
+{"version":3,"file":"AccountConfig.d.ts","sourceRoot":"","sources":["../../tempo/AccountConfig.ts"],"names":[],"mappings":"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"}

package/_types/tempo/AccountOperation.d.ts

@@ -105,7 +105,7 @@ export declare namespace getHash {
  * The function retains one canonical approval per owner. It selects the
  * smallest deterministic quorum by owner weight, then orders the selected
  * approvals by owner address for serialization. The caller supplies the
- * account and config; the chain validates their factory-derived identity.
+ * account and config; the chain validates their derived identity.
  *
  * @example
  * ```ts twoslash

package/_types/tempo/index.d.ts

@@ -22,9 +22,7 @@ export type {};
  *   ],
  * })
  *
- * const account = AccountConfig.getAddress(initialConfig, {
- *   factory: '0x7171717171717171717171717171717171717171'
- * })
+ * const account = AccountConfig.getAddress(initialConfig)
  * ```
  *
  * @category Reference

package/_types/tempo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD;;;;;;;GAOG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;GAOG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,oBAAoB,MAAM,2BAA2B,CAAA;AACjE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD;;;;;;;GAOG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;GAOG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,oBAAoB,MAAM,2BAA2B,CAAA;AACjE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.57";
+export declare const version = "0.14.59";
 //# sourceMappingURL=version.d.ts.map

package/core/AbiEvent.ts

@@ -12,6 +12,7 @@ import type * as AbiItem_internal from './internal/abiItem.js'
 import * as Cursor from './internal/cursor.js'
 import { prettyPrint } from './internal/errors.js'
 import type { Compute, IsNarrowable } from './internal/types.js'
+import * as Solidity from './Solidity.js'
 
 /** Root type for an {@link ox#AbiItem.AbiItem} with an `event` type. */
 export type AbiEvent = abitype.AbiEvent & {
@@ -136,9 +137,29 @@ export function assertArgs<const abiEvent extends AbiEvent>(
   ) {
     if (input.type === 'address')
       return Address.isEqual(value as Address.Address, arg as Address.Address)
-    if (input.type === 'string')
-      return Hash.keccak256(Bytes.fromString(value as string)) === arg
-    if (input.type === 'bytes') return Hash.keccak256(value as Hex.Hex) === arg
+    // Indexed `string` and `bytes` topics hold the keccak256 of their contents.
+    // Values decoded from data hold the contents.
+    if (input.indexed) {
+      if (input.type === 'string')
+        return (
+          Hash.keccak256(Bytes.fromString(value as string), { as: 'Hex' }) ===
+          arg
+        )
+      if (input.type === 'bytes') {
+        const hex =
+          typeof value === 'string'
+            ? (value as Hex.Hex)
+            : Hex.fromBytes(value as Bytes.Bytes)
+        return Hash.keccak256(hex, { as: 'Hex' }) === arg
+      }
+    }
+    // Decoded `bytes` and `bytesN` are lowercase hex, so match either case.
+    if (
+      typeof value === 'string' &&
+      typeof arg === 'string' &&
+      Solidity.bytesRegex.test(input.type)
+    )
+      return value.toLowerCase() === arg.toLowerCase()
     return value === arg
   }
 

package/core/Authorization.ts

@@ -175,7 +175,11 @@ export declare namespace from {
  */
 export function fromRpc(authorization: Rpc): Signed {
   const { address, chainId, nonce } = authorization
-  const signature = Signature.extract(authorization)!
+  // EIP-7702 permits any `y_parity` below 2**8 in an authorization tuple, so
+  // check `yParity` against one byte rather than against 0 or 1.
+  const signature = Signature.fromRpc(authorization)
+  Signature.assert({ r: signature.r, s: signature.s })
+  assertYParity(signature.yParity)
 
   return {
     address,
@@ -272,8 +276,18 @@ export function fromTuple<const tuple extends Tuple>(
     chainId: chainId === '0x' ? 0 : Number(chainId),
     nonce: nonce === '0x' ? 0n : BigInt(nonce),
   }
-  if (yParity && r && s)
-    args = { ...args, ...Signature.fromTuple([yParity, r, s]) }
+  if (yParity && r && s) {
+    // EIP-7702 permits any `y_parity` below 2**8 in an authorization tuple, so
+    // check `yParity` against one byte rather than against 0 or 1.
+    const signature = {
+      r: r === '0x' ? 0n : BigInt(r),
+      s: s === '0x' ? 0n : BigInt(s),
+      yParity: yParity === '0x' ? 0 : Number(yParity),
+    }
+    Signature.assert({ r: signature.r, s: signature.s })
+    assertYParity(signature.yParity)
+    args = { ...args, ...signature }
+  }
   return from(args) as never
 }
 
@@ -472,12 +486,16 @@ export declare namespace hash {
  */
 export function toRpc(authorization: Signed): Rpc {
   const { address, chainId, nonce, ...signature } = authorization
+  assertYParity(signature.yParity)
 
   return {
     address,
     chainId: Hex.fromNumber(chainId),
     nonce: Hex.fromNumber(nonce),
     ...Signature.toRpc(signature),
+    // EIP-7702 permits any `y_parity` below 2**8 in an authorization tuple, so
+    // encode `yParity` as is instead of the 0 or 1 of `Signature.toRpc`.
+    yParity: Hex.fromNumber(signature.yParity),
   }
 }
 
@@ -540,13 +558,23 @@ export declare namespace toRpcList {
 export function toTuple<const authorization extends Authorization>(
   authorization: authorization,
 ): toTuple.ReturnType<authorization> {
-  const { address, chainId, nonce } = authorization
-  const signature = Signature.extract(authorization)
+  const { address, chainId, nonce, r, s, yParity } = authorization
+  const signature = Signature.extract({ r, s })
+  if (signature && typeof yParity !== 'undefined') assertYParity(yParity)
   return [
     chainId ? Hex.fromNumber(chainId) : '0x',
     address,
     nonce ? Hex.fromNumber(nonce) : '0x',
-    ...(signature ? Signature.toTuple(signature) : []),
+    // EIP-7702 permits any `y_parity` below 2**8 in an authorization tuple, and a
+    // tuple that fails recovery does not invalidate the transaction. Encode
+    // `yParity` as is, so that serialization preserves the transaction hash.
+    ...(signature
+      ? [
+          yParity ? Hex.fromNumber(yParity, { size: 1 }) : '0x',
+          signature.r === 0n ? '0x' : Hex.trimLeft(Hex.fromNumber(signature.r)),
+          signature.s === 0n ? '0x' : Hex.trimLeft(Hex.fromNumber(signature.s)),
+        ]
+      : []),
   ] as never
 }
 
@@ -617,3 +645,15 @@ export declare namespace toTupleList {
 
   type ErrorType = Errors.GlobalErrorType
 }
+
+// Asserts that an EIP-7702 authorization `yParity` fits in one byte.
+function assertYParity(yParity: number) {
+  if (Number.isInteger(yParity) && yParity >= 0 && yParity < 256) return
+  throw new Hex.IntegerOutOfRangeError({
+    max: '255',
+    min: '0',
+    signed: false,
+    size: 1,
+    value: `${yParity}`,
+  })
+}

package/core/Hex.ts

@@ -34,17 +34,24 @@ export function assert(
   value: unknown,
   options: assert.Options = {},
 ): asserts value is Hex {
-  const { strict = false } = options
+  const { even = false, strict = false } = options
   if (!value) throw new InvalidHexTypeError(value)
   if (typeof value !== 'string') throw new InvalidHexTypeError(value)
   if (strict) {
     if (!/^0x[0-9a-fA-F]*$/.test(value)) throw new InvalidHexValueError(value)
   }
   if (!value.startsWith('0x')) throw new InvalidHexValueError(value)
+  if (even && value.length % 2 !== 0) throw new InvalidLengthError(value as Hex)
 }
 
 export declare namespace assert {
   type Options = {
+    /**
+     * Checks if the {@link ox#Hex.Hex} value has an even number of hexadecimal characters (whole bytes).
+     * Keep disabled for RPC quantities (e.g. `0x0`, `0x400`).
+     * @default false
+     */
+    even?: boolean | undefined
     /** Checks if the {@link ox#Hex.Hex} value contains invalid hexadecimal characters. @default false */
     strict?: boolean | undefined
   }
@@ -52,6 +59,7 @@ export declare namespace assert {
   type ErrorType =
     | InvalidHexTypeError
     | InvalidHexValueError
+    | InvalidLengthError
     | Errors.GlobalErrorType
 }
 
@@ -741,9 +749,9 @@ export function validate(
   value: unknown,
   options: validate.Options = {},
 ): value is Hex {
-  const { strict = false } = options
+  const { even = false, strict = false } = options
   try {
-    assert(value, { strict })
+    assert(value, { even, strict })
     return true
   } catch {
     return false
@@ -752,6 +760,12 @@ export function validate(
 
 export declare namespace validate {
   type Options = {
+    /**
+     * Checks if the {@link ox#Hex.Hex} value has an even number of hexadecimal characters (whole bytes).
+     * Keep disabled for RPC quantities (e.g. `0x0`, `0x400`).
+     * @default false
+     */
+    even?: boolean | undefined
     /** Checks if the {@link ox#Hex.Hex} value contains invalid hexadecimal characters. @default false */
     strict?: boolean | undefined
   }

package/core/RpcTransport.ts

@@ -95,8 +95,14 @@ export function fromHttp<
             ? await fetchOptions_(body_)
             : fetchOptions_
 
-        const response = await promise.withTimeout(
-          ({ signal }) => {
+        const { data, response } = await promise.withTimeout(
+          async ({ signal }) => {
+            // Abort on whichever signal fires first, so that a caller's
+            // `signal` does not disable the timeout.
+            const signals = [
+              fetchOptions?.signal,
+              timeout > 0 ? signal : null,
+            ].filter((s): s is AbortSignal => Boolean(s))
             const init: RequestInit = {
               ...fetchOptions,
               body,
@@ -105,10 +111,40 @@ export function fromHttp<
                 ...fetchOptions?.headers,
               },
               method: fetchOptions?.method ?? 'POST',
-              signal: fetchOptions?.signal ?? (timeout > 0 ? signal : null),
+              signal: (() => {
+                if (signals.length < 2) return signals[0] ?? null
+                // Runtimes without `AbortSignal.any` (e.g. Node < 18.17) keep
+                // only the caller's signal, as before.
+                if (typeof AbortSignal.any !== 'function') return signals[0]!
+                return AbortSignal.any(signals)
+              })(),
             }
             const request = new Request(url, init)
-            return fetchFn(request)
+            const response = await fetchFn(request)
+
+            // Read the body within the timeout too, so a response that stalls
+            // after its headers cannot hang the request.
+            const data = await (async () => {
+              if (
+                response.headers
+                  .get('Content-Type')
+                  ?.startsWith('application/json')
+              )
+                return response.json()
+              return response.text().then((data) => {
+                try {
+                  return JSON.parse(data || '{}')
+                } catch (_err) {
+                  if (response.ok)
+                    throw new MalformedResponseError({
+                      response: data,
+                    })
+                  return { error: data }
+                }
+              })
+            })()
+
+            return { data, response }
           },
           {
             timeout,
@@ -116,24 +152,6 @@ export function fromHttp<
           },
         )
 
-        const data = await (async () => {
-          if (
-            response.headers.get('Content-Type')?.startsWith('application/json')
-          )
-            return response.json()
-          return response.text().then((data) => {
-            try {
-              return JSON.parse(data || '{}')
-            } catch (_err) {
-              if (response.ok)
-                throw new MalformedResponseError({
-                  response: data,
-                })
-              return { error: data }
-            }
-          })
-        })()
-
         if (!response.ok)
           throw new HttpError({
             body,

package/core/Siwe.ts

@@ -4,7 +4,7 @@ import type { ExactPartial } from './internal/types.js'
 import { uid } from './internal/uid.js'
 
 export const domainRegex =
-  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(:[0-9]{1,5})?$/
+  /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+(?:[a-zA-Z]{2,63}|[xX][nN]--[a-zA-Z0-9-]{0,58}[a-zA-Z0-9])(:[0-9]{1,5})?$/
 
 export const ipRegex =
   /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(:[0-9]{1,5})?$/

package/core/TypedData.ts

@@ -393,7 +393,7 @@ export function extractEip712DomainTypes(
 ): Parameter[] {
   return [
     typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-    domain?.version && { name: 'version', type: 'string' },
+    typeof domain?.version === 'string' && { name: 'version', type: 'string' },
     (typeof domain?.chainId === 'number' ||
       typeof domain?.chainId === 'bigint') && {
       name: 'chainId',

package/core/internal/abiItem.ts

@@ -4,6 +4,7 @@ import type * as AbiItem from '../AbiItem.js'
 import type * as AbiParameters from '../AbiParameters.js'
 import * as Address from '../Address.js'
 import * as Errors from '../Errors.js'
+import { getArrayComponents } from './abiParameters.js'
 import type {
   Compute,
   IsNever,
@@ -466,8 +467,9 @@ export function normalizeSignature(signature: string): string {
 
     // Ignore spaces
     if (char === ' ') {
-      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
-      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+      // A space directly after a `(` or `,` separator is leading whitespace.
+      // Otherwise, it ends the type, so we want to deactivate.
+      if (!current.endsWith(',') && !current.endsWith('(')) {
         current = ''
         active = false
       }
@@ -508,9 +510,12 @@ export function isArgOfType(
       if (abiParameterType === 'tuple' && 'components' in abiParameter)
         return Object.values(abiParameter.components).every(
           (component, index) => {
-            return isArgOfType(
-              Object.values(arg as unknown[] | Record<string, unknown>)[index],
-              component as AbiParameters.Parameter,
+            return (
+              argType === 'object' &&
+              isArgOfType(
+                getComponentValue(arg, component, index),
+                component as AbiParameters.Parameter,
+              )
             )
           },
         )
@@ -530,15 +535,16 @@ export function isArgOfType(
         return argType === 'string' || arg instanceof Uint8Array
 
       // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
-      // https://regexr.com/6va6i
-      if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+      const arrayComponents = getArrayComponents(abiParameterType)
+      if (arrayComponents) {
+        const [length, type] = arrayComponents
         return (
           Array.isArray(arg) &&
+          (length === null || arg.length === length) &&
           arg.every((x: unknown) =>
             isArgOfType(x, {
               ...abiParameter,
-              // Pop off `[]` or `[M]` from end of type
-              type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, ''),
+              type,
             } as AbiParameters.Parameter),
           )
         )
@@ -557,32 +563,65 @@ export function getAmbiguousTypes(
 ): AbiParameters.Parameter['type'][] | undefined {
   for (const parameterIndex in sourceParameters) {
     const sourceParameter = sourceParameters[parameterIndex]!
-    const targetParameter = targetParameters[parameterIndex]!
+    const targetParameter = targetParameters[parameterIndex]
+    if (!targetParameter) continue
 
     if (
       sourceParameter.type === 'tuple' &&
       targetParameter.type === 'tuple' &&
       'components' in sourceParameter &&
       'components' in targetParameter
-    )
-      return getAmbiguousTypes(
+    ) {
+      const value = args[parameterIndex]
+      const types = getAmbiguousTypes(
         sourceParameter.components,
         targetParameter.components,
-        (args as any)[parameterIndex],
+        sourceParameter.components.map((component, index) =>
+          getComponentValue(value, component, index),
+        ),
       )
+      if (types) return types
+      continue
+    }
+
+    const sourceArray = getArrayComponents(sourceParameter.type)
+    const targetArray = getArrayComponents(targetParameter.type)
+    if (sourceArray && targetArray) {
+      // Every item matches both element types, so the first item (or `undefined` for an empty array) decides.
+      const types = getAmbiguousTypes(
+        [
+          {
+            ...sourceParameter,
+            type: sourceArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [
+          {
+            ...targetParameter,
+            type: targetArray[1],
+          } as AbiParameters.Parameter,
+        ],
+        [(args[parameterIndex] as readonly unknown[] | undefined)?.[0]],
+      )
+      if (types) return types
+      continue
+    }
 
     const types = [sourceParameter.type, targetParameter.type]
 
+    const value = args[parameterIndex]
+
     const ambiguous = (() => {
       if (types.includes('address') && types.includes('bytes20')) return true
-      if (types.includes('address') && types.includes('string'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
-      if (types.includes('address') && types.includes('bytes'))
-        return Address.validate(args[parameterIndex] as Address.Address, {
-          strict: false,
-        })
+      // An `undefined` value comes from an empty array, which matches both types.
+      if (
+        types.includes('address') &&
+        (types.includes('string') || types.includes('bytes'))
+      )
+        return (
+          value === undefined ||
+          Address.validate(value as Address.Address, { strict: false })
+        )
       return false
     })()
 
@@ -591,3 +630,13 @@ export function getAmbiguousTypes(
 
   return
 }
+
+// Reads a tuple component's value by index from arrays and by name from objects, like `AbiParameters.encode`.
+function getComponentValue(
+  arg: unknown,
+  component: AbiParameters.Parameter,
+  index: number,
+): unknown {
+  if (Array.isArray(arg)) return arg[index]
+  return (arg as Record<string, unknown> | undefined)?.[component.name!]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.57",
+  "version": "0.14.59",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",