ox 1.7.2 → 1.7.5

package/dist/zod/tempo/TxEnvelopeTempo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TxEnvelopeTempo.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/TxEnvelopeTempo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAY7B,8CAA8C;AAC9C,eAAO,MAAM,IAAI,2BAAqB,CAAA;AAEtC,qCAAqC;AACrC,eAAO,MAAM,IAAI;;;;iBAIf,CAAA;AAqBF,yCAAyC;AACzC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjB,CAAA;AAEF,yFAAyF;AACzF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASrB,CAAA"}
+{"version":3,"file":"TxEnvelopeTempo.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/TxEnvelopeTempo.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAY7B,8CAA8C;AAC9C,eAAO,MAAM,IAAI,2BAAqB,CAAA;AAEtC,qCAAqC;AACrC,eAAO,MAAM,IAAI;;;;iBAIf,CAAA;AAqBF,yCAAyC;AACzC,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG1B,CAAA;AAEF,gDAAgD;AAChD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGjB,CAAA;AAEF,yFAAyF;AACzF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASrB,CAAA"}

package/dist/zod/tempo/ZoneRpcAuthentication.d.ts

@@ -70,7 +70,41 @@ export declare const Signed: z.ZodMiniObject<{
             threshold: z.ZodMiniNumber<number>;
             version: z.ZodMiniBigInt<bigint>;
         }, z.core.$strip>;
-        signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
+        signatures: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                yParity: z.ZodMiniNumber<number>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"secp256k1">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            prehash: z.ZodMiniBoolean<boolean>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"p256">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            metadata: z.ZodMiniObject<{
+                authenticatorData: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                clientDataJSON: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"webAuthn">;
+        }, z.core.$strip>]>>>;
         type: z.ZodMiniLiteral<"multisig">;
     }, z.core.$strip>]>;
     version: z.ZodMiniLiteral<0>;
@@ -132,7 +166,41 @@ export declare const ZoneRpcAuthentication: z.ZodMiniUnion<readonly [z.ZodMiniOb
             threshold: z.ZodMiniNumber<number>;
             version: z.ZodMiniBigInt<bigint>;
         }, z.core.$strip>;
-        signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
+        signatures: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                yParity: z.ZodMiniNumber<number>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"secp256k1">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            prehash: z.ZodMiniBoolean<boolean>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"p256">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            metadata: z.ZodMiniObject<{
+                authenticatorData: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                clientDataJSON: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"webAuthn">;
+        }, z.core.$strip>]>>>;
         type: z.ZodMiniLiteral<"multisig">;
     }, z.core.$strip>]>;
     version: z.ZodMiniLiteral<0>;
@@ -201,7 +269,41 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
             threshold: z.ZodMiniNumber<number>;
             version: z.ZodMiniBigInt<bigint>;
         }, z.core.$strip>;
-        signatures: z.ZodMiniLazy<z.ZodMiniType<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown, z.core.$ZodTypeInternals<readonly import("../../tempo/SignatureEnvelope.js").SignatureEnvelope<number>[], unknown>>>;
+        signatures: z.ZodMiniReadonly<z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                yParity: z.ZodMiniNumber<number>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"secp256k1">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            prehash: z.ZodMiniBoolean<boolean>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"p256">;
+        }, z.core.$strip>, z.ZodMiniObject<{
+            metadata: z.ZodMiniObject<{
+                authenticatorData: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                clientDataJSON: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+            publicKey: z.ZodMiniObject<{
+                prefix: z.ZodMiniNumber<number>;
+                x: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                y: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            signature: z.ZodMiniObject<{
+                r: z.ZodMiniTemplateLiteral<`0x${string}`>;
+                s: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            }, z.core.$strip>;
+            type: z.ZodMiniLiteral<"webAuthn">;
+        }, z.core.$strip>]>>>;
         type: z.ZodMiniLiteral<"multisig">;
     }, z.core.$strip>]>;
     version: z.ZodMiniLiteral<0>;

package/dist/zod/tempo/ZoneRpcAuthentication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ZoneRpcAuthentication.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/ZoneRpcAuthentication.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,8CAA8C;AAC9C,eAAO,MAAM,OAAO,qBAAe,CAAA;AAEnC,iEAAiE;AACjE,eAAO,MAAM,MAAM,yCAAwD,CAAA;AAE3E,mEAAmE;AACnE,eAAO,MAAM,UAAU,yCAAY,CAAA;AAEnC,qDAAqD;AACrD,eAAO,MAAM,QAAQ;;;;;;;iBAOnB,CAAA;AAEF,mDAAmD;AACnD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOjB,CAAA;AAEF,4CAA4C;AAC5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA8B,CAAA;AAEhE,qFAAqF;AACrF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMrB,CAAA"}
+{"version":3,"file":"ZoneRpcAuthentication.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/ZoneRpcAuthentication.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAG7B,8CAA8C;AAC9C,eAAO,MAAM,OAAO,qBAAe,CAAA;AAEnC,iEAAiE;AACjE,eAAO,MAAM,MAAM,yCAAwD,CAAA;AAE3E,mEAAmE;AACnE,eAAO,MAAM,UAAU,yCAAY,CAAA;AAEnC,qDAAqD;AACrD,eAAO,MAAM,QAAQ;;;;;;;iBAOnB,CAAA;AAEF,mDAAmD;AACnD,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOjB,CAAA;AAEF,4CAA4C;AAC5C,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAA8B,CAAA;AAEhE,qFAAqF;AACrF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMrB,CAAA"}

package/dist/zod/tempo/z.d.ts

@@ -2,7 +2,7 @@ export * as AuthorizationTempo from './AuthorizationTempo.js';
 export * as KeyAuthorization from './KeyAuthorization.js';
 export * as MultisigConfig from './MultisigConfig.js';
 export * as MultisigOperation from './MultisigOperation.js';
-export * as MultisigWitness from './MultisigWitness.js';
+export * as MultisigSimulation from './MultisigSimulation.js';
 export * as PoolId from './PoolId.js';
 export * as RpcSchemaTempo from './RpcSchemaTempo.js';
 export * as SignatureEnvelope from './SignatureEnvelope.js';

package/dist/zod/tempo/z.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"z.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/z.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"z.d.ts","sourceRoot":"","sources":["../../../src/zod/tempo/z.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/dist/zod/tempo/z.js

@@ -3,7 +3,7 @@ export * as AuthorizationTempo from './AuthorizationTempo.js';
 export * as KeyAuthorization from './KeyAuthorization.js';
 export * as MultisigConfig from './MultisigConfig.js';
 export * as MultisigOperation from './MultisigOperation.js';
-export * as MultisigWitness from './MultisigWitness.js';
+export * as MultisigSimulation from './MultisigSimulation.js';
 export * as PoolId from './PoolId.js';
 export * as RpcSchemaTempo from './RpcSchemaTempo.js';
 export * as SignatureEnvelope from './SignatureEnvelope.js';

package/dist/zod/tempo/z.js.map

@@ -1 +1 @@
-{"version":3,"file":"z.js","sourceRoot":"","sources":["../../../src/zod/tempo/z.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"z.js","sourceRoot":"","sources":["../../../src/zod/tempo/z.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.7.2",
+  "version": "1.7.5",
   "main": "./dist/index.js",
   "sideEffects": false,
   "license": "MIT",
@@ -604,10 +604,10 @@
       "types": "./dist/tempo/MultisigOperation.d.ts",
       "default": "./dist/tempo/MultisigOperation.js"
     },
-    "./tempo/MultisigWitness": {
-      "src": "./src/tempo/MultisigWitness.ts",
-      "types": "./dist/tempo/MultisigWitness.d.ts",
-      "default": "./dist/tempo/MultisigWitness.js"
+    "./tempo/MultisigSimulation": {
+      "src": "./src/tempo/MultisigSimulation.ts",
+      "types": "./dist/tempo/MultisigSimulation.d.ts",
+      "default": "./dist/tempo/MultisigSimulation.js"
     },
     "./tempo/Period": {
       "src": "./src/tempo/Period.ts",
@@ -1029,10 +1029,10 @@
       "types": "./dist/zod/tempo/MultisigOperation.d.ts",
       "default": "./dist/zod/tempo/MultisigOperation.js"
     },
-    "./zod/tempo/MultisigWitness": {
-      "src": "./src/zod/tempo/MultisigWitness.ts",
-      "types": "./dist/zod/tempo/MultisigWitness.d.ts",
-      "default": "./dist/zod/tempo/MultisigWitness.js"
+    "./zod/tempo/MultisigSimulation": {
+      "src": "./src/zod/tempo/MultisigSimulation.ts",
+      "types": "./dist/zod/tempo/MultisigSimulation.d.ts",
+      "default": "./dist/zod/tempo/MultisigSimulation.js"
     },
     "./zod/tempo/PoolId": {
       "src": "./src/zod/tempo/PoolId.ts",

package/src/core/AbiEvent.ts

@@ -496,12 +496,15 @@ export function decode(
   // don't have to call `inputs.indexOf(...)` per non-indexed entry below
   // (which is O(n^2) on event width).
   const indexedInputs: abitype.AbiEventParameter[] = []
+  const indexedOriginalIndex: number[] = []
   const nonIndexedInputs: abitype.AbiEventParameter[] = []
   const nonIndexedOriginalIndex: number[] = []
   for (let i = 0; i < inputs.length; i++) {
     const input = inputs[i]!
-    if ('indexed' in input && input.indexed) indexedInputs.push(input)
-    else {
+    if ('indexed' in input && input.indexed) {
+      indexedInputs.push(input)
+      indexedOriginalIndex.push(i)
+    } else {
       nonIndexedInputs.push(input)
       nonIndexedOriginalIndex.push(i)
     }
@@ -510,13 +513,14 @@ export function decode(
   // Decode topics (indexed args).
   for (let i = 0; i < indexedInputs.length; i++) {
     const param = indexedInputs[i]!
+    const index = indexedOriginalIndex[i]!
     const topic = argTopics[i]
     if (!topic)
       throw new TopicsMismatchError({
         abiEvent,
         param: param as abitype.AbiParameter & { indexed: boolean },
       })
-    args[isUnnamed ? i : param.name || i] = (() => {
+    args[isUnnamed ? index : param.name || index] = (() => {
       const t = param.type
       if (
         t === 'string' ||
@@ -545,12 +549,10 @@ export function decode(
           options,
         )
         if (decodedData) {
-          if (isUnnamed) args = [...args, ...decodedData]
-          else {
-            for (let i = 0; i < nonIndexedInputs.length; i++) {
-              const index = nonIndexedOriginalIndex[i]!
-              args[nonIndexedInputs[i]!.name! || index] = decodedData[i]
-            }
+          for (let i = 0; i < nonIndexedInputs.length; i++) {
+            const index = nonIndexedOriginalIndex[i]!
+            args[isUnnamed ? index : nonIndexedInputs[i]!.name || index] =
+              decodedData[i]
           }
         }
       } catch (err) {

package/src/core/Blobs.ts

@@ -398,8 +398,10 @@ export function to<
   const data = Cursor.create(new Uint8Array(length))
   let active = true
 
-  for (const blob of blobs_) {
+  for (const [index, blob] of blobs_.entries()) {
     const cursor = Cursor.create(blob)
+    // Only the final blob contains a terminator; preceding blobs contain only data.
+    const isLastBlob = index === blobs_.length - 1
     while (active && cursor.position < blob.length) {
       // First byte will be a zero 0x00 byte – we can skip.
       cursor.incrementPosition(1)
@@ -411,7 +413,9 @@ export function to<
       for (let i = 0; i < consume; i++) {
         const byte = cursor.readByte()
         const isTerminator =
-          byte === 0x80 && !cursor.inspectBytes(cursor.remaining).includes(0x80)
+          isLastBlob &&
+          byte === 0x80 &&
+          !cursor.inspectBytes(cursor.remaining).includes(0x80)
         if (isTerminator) {
           active = false
           break

package/src/core/Signature.ts

@@ -564,13 +564,16 @@ export declare namespace toBytes {
  */
 export function toCompactBytes(signature: Signature<boolean>): Bytes.Bytes {
   const bytes = new Uint8Array(64)
-  bytes.set(Bytes.fromHex(signature.r, { size: 32 }), 0)
-  bytes.set(Bytes.fromHex(signature.s, { size: 32 }), 32)
+  bytes.set(Bytes.fromHex(Hex.padLeft(signature.r, 32)), 0)
+  bytes.set(Bytes.fromHex(Hex.padLeft(signature.s, 32)), 32)
   return bytes
 }
 
 export declare namespace toCompactBytes {
-  type ErrorType = Bytes.fromHex.ErrorType | Errors.GlobalErrorType
+  type ErrorType =
+    | Hex.padLeft.ErrorType
+    | Bytes.fromHex.ErrorType
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -591,6 +594,8 @@ export declare namespace toCompactBytes {
  * @returns The decoded {@link ox#Signature.Signature}.
  */
 export function fromCompactBytes(bytes: Bytes.Bytes): Signature<false> {
+  if (bytes.length !== 64)
+    throw new InvalidSerializedSizeError({ expectedSize: 64, signature: bytes })
   return {
     r: Hex.fromBytes(bytes.subarray(0, 32)),
     s: Hex.fromBytes(bytes.subarray(32, 64)),
@@ -598,7 +603,10 @@ export function fromCompactBytes(bytes: Bytes.Bytes): Signature<false> {
 }
 
 export declare namespace fromCompactBytes {
-  type ErrorType = Hex.fromBytes.ErrorType | Errors.GlobalErrorType
+  type ErrorType =
+    | Hex.fromBytes.ErrorType
+    | InvalidSerializedSizeError
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -621,15 +629,20 @@ export declare namespace fromCompactBytes {
  * @returns The 65-byte recovered representation.
  */
 export function toRecoveredBytes(signature: Signature): Bytes.Bytes {
+  assert(signature, { recovered: true })
   const bytes = new Uint8Array(65)
   bytes[0] = signature.yParity
-  bytes.set(Bytes.fromHex(signature.r, { size: 32 }), 1)
-  bytes.set(Bytes.fromHex(signature.s, { size: 32 }), 33)
+  bytes.set(Bytes.fromHex(Hex.padLeft(signature.r, 32)), 1)
+  bytes.set(Bytes.fromHex(Hex.padLeft(signature.s, 32)), 33)
   return bytes
 }
 
 export declare namespace toRecoveredBytes {
-  type ErrorType = Bytes.fromNumber.ErrorType | Errors.GlobalErrorType
+  type ErrorType =
+    | assert.ErrorType
+    | Hex.padLeft.ErrorType
+    | Bytes.fromHex.ErrorType
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -650,15 +663,24 @@ export declare namespace toRecoveredBytes {
  * @returns The decoded {@link ox#Signature.Signature}.
  */
 export function fromRecoveredBytes(bytes: Bytes.Bytes): Signature {
+  if (bytes.length !== 65)
+    throw new InvalidSerializedSizeError({ expectedSize: 65, signature: bytes })
+  const yParity = bytes[0]!
+  if (yParity !== 0 && yParity !== 1)
+    throw new InvalidYParityError({ value: yParity })
   return {
     r: Hex.fromBytes(bytes.subarray(1, 33)),
     s: Hex.fromBytes(bytes.subarray(33, 65)),
-    yParity: bytes[0]!,
+    yParity,
   }
 }
 
 export declare namespace fromRecoveredBytes {
-  type ErrorType = Hex.fromBytes.ErrorType | Errors.GlobalErrorType
+  type ErrorType =
+    | Hex.fromBytes.ErrorType
+    | InvalidSerializedSizeError
+    | InvalidYParityError
+    | Errors.GlobalErrorType
 }
 
 /**
@@ -945,10 +967,18 @@ export declare namespace yParityToV {
 export class InvalidSerializedSizeError extends Errors.BaseError {
   override readonly name = 'Signature.InvalidSerializedSizeError'
 
-  constructor({ signature }: { signature: Hex.Hex | Bytes.Bytes }) {
+  constructor({
+    expectedSize,
+    signature,
+  }: {
+    expectedSize?: number | undefined
+    signature: Hex.Hex | Bytes.Bytes
+  }) {
     super(`Value \`${signature}\` is an invalid signature size.`, {
       metaMessages: [
-        'Expected: 64 bytes or 65 bytes.',
+        typeof expectedSize === 'number'
+          ? `Expected: ${expectedSize} bytes.`
+          : 'Expected: 64 bytes or 65 bytes.',
         `Received ${Hex.size(Hex.from(signature))} bytes.`,
       ],
     })

package/src/core/Siwe.ts

@@ -330,11 +330,12 @@ export function isUri(value: string): false | string {
   const fragment = splitted[5]
 
   // scheme and path are required, though the path can be empty
-  if (!(scheme?.length && path && path.length >= 0)) return false
+  if (!(scheme?.length && path !== undefined)) return false
 
   // if authority is present, the path must be empty or begin with a /
   if (authority?.length) {
     if (!(path.length === 0 || path.startsWith('/'))) return false
+    if (path.length === 0 && !isAuthority(authority)) return false
   } else {
     // if authority is not present, the path must not start with //
     if (path.startsWith('//')) return false
@@ -356,6 +357,24 @@ export function isUri(value: string): false | string {
   return out
 }
 
+function isAuthority(value: string) {
+  const host = value.match(/^(?:[a-z0-9._~!$&'()*+,;=:%-]*@)?(.*)$/i)?.[1]
+  if (host === undefined) return false
+
+  const ipLiteral = host.match(/^\[([^\]]+)\](?::\d*)?$/)?.[1]
+  if (ipLiteral) {
+    if (/^v[0-9a-f]+\.[a-z0-9._~!$&'()*+,;=:-]+$/i.test(ipLiteral)) return true
+    try {
+      new URL(`http://[${ipLiteral}]`)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  return /^(?:[a-z0-9._~!$&'()*+,;=%-]*)(?::\d*)?$/i.test(host)
+}
+
 function splitUri(value: string) {
   return value.match(
     /(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/,

package/src/core/_test/AbiEvent.test.ts

@@ -330,6 +330,51 @@ describe('decode', () => {
   `)
   })
 
+  test('behavior: unnamed, non-indexed input before indexed input (array mode)', () => {
+    // Declaration order (uint256, bool indexed) differs from indexed-subset
+    // order (bool is the only indexed input). Args must still come back in
+    // declaration order, not indexed-subset order.
+    const foo = AbiEvent.from('event Foo(uint256, bool indexed)')
+    const decoded = AbiEvent.decode(foo, {
+      data: '0x0000000000000000000000000000000000000000000000000000000000000111',
+      topics: [
+        '0x79c52e97493a8f32348c3cf1ebfe4a8dfaeb083ca12cddd87b5d9f7c00d3ccaa',
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ],
+    })
+    expect(decoded).toMatchInlineSnapshot(`
+      [
+        273n,
+        true,
+      ]
+    `)
+  })
+
+  test('behavior: named + unnamed, indexed input interleaved with non-indexed (mixed mode)', () => {
+    // `a` (indexed) and the trailing unnamed `address` (indexed) are not a
+    // contiguous prefix of declaration order — a non-indexed `bool` sits
+    // between them. All three values must be present and at the correct
+    // declaration-order keys; none may be silently dropped or overwritten.
+    const foo = AbiEvent.from(
+      'event Foo(uint256 indexed a, bool, address indexed)',
+    )
+    const decoded = AbiEvent.decode(foo, {
+      data: '0x0000000000000000000000000000000000000000000000000000000000000001',
+      topics: [
+        '0xbf5963a29fe665781e91d832989689110056ee09e32656ea57265dbb1084006e',
+        '0x0000000000000000000000000000000000000000000000000000000000000aaa',
+        '0x00000000000000000000000000cccccccccccccccccccccccccccccccccccccc',
+      ],
+    })
+    expect(decoded).toMatchInlineSnapshot(`
+      {
+        "1": true,
+        "2": "0x00CCCCCCccCcCccCCcccCCcccCcCcCccCcCcCCcc",
+        "a": 2730n,
+      }
+    `)
+  })
+
   test('error: topics mismatch, named', () => {
     const transfer = AbiEvent.from(
       'event Transfer(address indexed from, address to, uint256 indexed value)',

package/src/core/_test/Blobs.test.ts

@@ -415,6 +415,28 @@ describe('to', () => {
     const blobs = Blobs.from(data)
     expect(Blobs.to(blobs, 'Bytes')).toEqual(data)
   })
+
+  test('0x80 byte in a non-final blob is not mistaken for the terminator', () => {
+    // This payload spans multiple blobs and places terminator-shaped data in the first blob.
+    const size = 200_000
+    const data = new Uint8Array(size).fill(0x41)
+    data[1_000] = 0x80
+    data[100_000] = 0x80
+
+    const blobs = Blobs.from(data)
+    expect(blobs.length).toBeGreaterThan(1)
+    expect(Blobs.to(blobs, 'Bytes')).toEqual(data)
+  })
+
+  test('all-0x80 data exactly filling the first blob leaves a terminator-only final blob', () => {
+    // Exact first-blob capacity forces `Blobs.from` to place the terminator in a second blob.
+    const size = 31 * Blobs.fieldElementsPerBlob
+    const data = new Uint8Array(size).fill(0x80)
+
+    const blobs = Blobs.from(data)
+    expect(blobs.length).toBe(2)
+    expect(Blobs.to(blobs, 'Bytes')).toEqual(data)
+  })
 })
 
 describe('toCommitments', () => {