@panoptic-eng/sdk 1.0.71 → 1.0.73

package/dist/{router-DDJ3OnDA.js → router-lUA1kp8A.js}

@@ -1,7 +1,6 @@
 import { StateViewAbi } from "./StateView-q4yMpBY6.js";
-import { PanopticError, getBlockMeta, getPool, getPoolMetadata, stateViewAbi, submitWrite, uniswapV3PoolAbi } from "./rates-DlqTkuXt.js";
-import { getLegLiquidityRange, tickToSqrtPriceX96 } from "./greeks-DNPP24KL.js";
-import { decodeAllLegs, decodeTokenId } from "./writes-DBu2ltcP.js";
+import { PanopticError, decodeAllLegs, decodeTokenId, getBlockMeta, getPool, getPoolMetadata, stateViewAbi, submitWrite, uniswapV3PoolAbi } from "./rates-c9XVKm3m.js";
+import { getLegLiquidityRange, tickToSqrtPriceX96 } from "./greeks-CEv-Uex1.js";
 import { BaseError, ContractFunctionRevertedError, ExecutionRevertedError, encodeAbiParameters, encodeFunctionData, encodePacked, erc20Abi, isAddressEqual, maxUint256, toHex, zeroAddress } from "viem";
 import Decimal from "decimal.js";
 

package/dist/safe/index.d.ts

@@ -0,0 +1,166 @@
+import { Address, Hex } from "viem";
+
+//#region src/safe/signedSafeTx.d.ts
+declare const safeAbi: readonly [{
+  readonly type: "event";
+  readonly name: "ExecutionSuccess";
+  readonly inputs: readonly [{
+    readonly name: "txHash";
+    readonly type: "bytes32";
+    readonly indexed: true;
+  }, {
+    readonly name: "payment";
+    readonly type: "uint256";
+    readonly indexed: false;
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "execTransaction";
+  readonly stateMutability: "payable";
+  readonly inputs: readonly [{
+    readonly name: "to";
+    readonly type: "address";
+  }, {
+    readonly name: "value";
+    readonly type: "uint256";
+  }, {
+    readonly name: "data";
+    readonly type: "bytes";
+  }, {
+    readonly name: "operation";
+    readonly type: "uint8";
+  }, {
+    readonly name: "safeTxGas";
+    readonly type: "uint256";
+  }, {
+    readonly name: "baseGas";
+    readonly type: "uint256";
+  }, {
+    readonly name: "gasPrice";
+    readonly type: "uint256";
+  }, {
+    readonly name: "gasToken";
+    readonly type: "address";
+  }, {
+    readonly name: "refundReceiver";
+    readonly type: "address";
+  }, {
+    readonly name: "signatures";
+    readonly type: "bytes";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "success";
+    readonly type: "bool";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "VERSION";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "string";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "nonce";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "getThreshold";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "uint256";
+  }];
+}, {
+  readonly type: "function";
+  readonly name: "getOwners";
+  readonly stateMutability: "view";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly type: "address[]";
+  }];
+}];
+/** A plain call the owner asked their wallet to send from the Safe. */
+interface SafeCall {
+  to: Address;
+  value: bigint;
+  data: Hex;
+}
+interface SafeTx extends SafeCall {
+  operation: 0 | 1;
+  safeTxGas: bigint;
+  baseGas: bigint;
+  gasPrice: bigint;
+  gasToken: Address;
+  refundReceiver: Address;
+  nonce: bigint;
+}
+interface SignedSafeTx {
+  safe: Address;
+  chainId: number;
+  tx: SafeTx;
+  safeTxHash: Hex;
+  signer: Address;
+  /** Packed `signatures` argument for `execTransaction`. */
+  signatures: Hex;
+}
+type SignedSafeTxErrorCode = 'INVALID_SIGNATURE' | 'THRESHOLD_NOT_MET' | 'SIGNATURE_MISMATCH';
+declare class SignedSafeTxError extends Error {
+  readonly code: SignedSafeTxErrorCode;
+  constructor(code: SignedSafeTxErrorCode, message: string);
+}
+/** EIP-712 SafeTx hash (Safe ≥ 1.3 domain: chainId + verifyingContract). */
+declare function hashSafeTx(params: {
+  chainId: number;
+  safe: Address;
+  tx: SafeTx;
+}): Hex;
+/**
+ * A wallet signing a plain call for a Safe owner (Rabby, Safe{Wallet}) signs it
+ * with no refund or gas fields; only the nonce varies.
+ */
+declare function safeTxForCall(call: SafeCall, nonce: bigint): SafeTx;
+/** True for a 65-byte ECDSA signature — what a Safe-owner wallet returns instead of a tx hash. */
+declare function isSafeOwnerSignature(value: unknown): value is Hex;
+/**
+ * Rejects anything that cannot be a Safe owner's ECDSA signature, without any
+ * RPC: 65 bytes, supported v (raw 0/1/27/28 or `eth_sign` 31/32), and r, s in
+ * the curve range.
+ */
+declare function assertSafeOwnerSignature(signature: Hex): void;
+/**
+ * Recovers the signer of `safeTxHash`, accepting raw ECDSA (v 27/28, or 0/1)
+ * and `eth_sign` (v 31/32) signatures, and returns the signature in the form
+ * the Safe verifies.
+ */
+declare function recoverSafeTxSigner(safeTxHash: Hex, signature: Hex): Promise<{
+  signer: Address;
+  signature: Hex;
+}>;
+/**
+ * Resolves an owner's signature over a plain call into an executable SafeTx,
+ * given the Safe's on-chain `nonce`, `owners` and `threshold`. The signed nonce
+ * is not part of the call, so it is searched from the on-chain nonce forward
+ * (wallets may sign ahead of queued transactions).
+ */
+declare function resolveSignedSafeTx(params: {
+  chainId: number;
+  safe: Address;
+  call: SafeCall;
+  signature: Hex;
+  state: {
+    nonce: bigint;
+    threshold: bigint;
+    owners: readonly Address[];
+  };
+  nonceWindow?: number;
+}): Promise<SignedSafeTx>;
+/** `execTransaction` arguments for a resolved signed SafeTx. */
+declare function execTransactionArgs(signed: SignedSafeTx): readonly [Address, bigint, `0x${string}`, 0 | 1, bigint, bigint, bigint, Address, Address, `0x${string}`]; //#endregion
+export { SafeCall, SafeTx, SignedSafeTx, SignedSafeTxError, SignedSafeTxErrorCode, assertSafeOwnerSignature, execTransactionArgs, hashSafeTx, isSafeOwnerSignature, recoverSafeTxSigner, resolveSignedSafeTx, safeAbi, safeTxForCall };
+//# sourceMappingURL=index.d.ts.map

package/dist/safe/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Address","Hex","safeAbi","SafeCall","SafeTx","SignedSafeTx","SignedSafeTxErrorCode","SignedSafeTxError","Error","hashSafeTx","safeTxForCall","isSafeOwnerSignature","assertSafeOwnerSignature","recoverSafeTxSigner","Promise","resolveSignedSafeTx","execTransactionArgs"],"sources":["../../src/safe/signedSafeTx.d.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/safe/index.js

@@ -0,0 +1,278 @@
+import { concatHex, getAddress, hashMessage, hashTypedData, hexToBigInt, hexToNumber, isAddressEqual, numberToHex, recoverAddress, sliceHex, zeroAddress } from "viem";
+
+//#region src/safe/signedSafeTx.ts
+const safeAbi = [
+	{
+		type: "event",
+		name: "ExecutionSuccess",
+		inputs: [{
+			name: "txHash",
+			type: "bytes32",
+			indexed: true
+		}, {
+			name: "payment",
+			type: "uint256",
+			indexed: false
+		}]
+	},
+	{
+		type: "function",
+		name: "execTransaction",
+		stateMutability: "payable",
+		inputs: [
+			{
+				name: "to",
+				type: "address"
+			},
+			{
+				name: "value",
+				type: "uint256"
+			},
+			{
+				name: "data",
+				type: "bytes"
+			},
+			{
+				name: "operation",
+				type: "uint8"
+			},
+			{
+				name: "safeTxGas",
+				type: "uint256"
+			},
+			{
+				name: "baseGas",
+				type: "uint256"
+			},
+			{
+				name: "gasPrice",
+				type: "uint256"
+			},
+			{
+				name: "gasToken",
+				type: "address"
+			},
+			{
+				name: "refundReceiver",
+				type: "address"
+			},
+			{
+				name: "signatures",
+				type: "bytes"
+			}
+		],
+		outputs: [{
+			name: "success",
+			type: "bool"
+		}]
+	},
+	{
+		type: "function",
+		name: "VERSION",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{ type: "string" }]
+	},
+	{
+		type: "function",
+		name: "nonce",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{ type: "uint256" }]
+	},
+	{
+		type: "function",
+		name: "getThreshold",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{ type: "uint256" }]
+	},
+	{
+		type: "function",
+		name: "getOwners",
+		stateMutability: "view",
+		inputs: [],
+		outputs: [{ type: "address[]" }]
+	}
+];
+var SignedSafeTxError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "SignedSafeTxError";
+	}
+};
+const SAFE_TX_TYPES = { SafeTx: [
+	{
+		name: "to",
+		type: "address"
+	},
+	{
+		name: "value",
+		type: "uint256"
+	},
+	{
+		name: "data",
+		type: "bytes"
+	},
+	{
+		name: "operation",
+		type: "uint8"
+	},
+	{
+		name: "safeTxGas",
+		type: "uint256"
+	},
+	{
+		name: "baseGas",
+		type: "uint256"
+	},
+	{
+		name: "gasPrice",
+		type: "uint256"
+	},
+	{
+		name: "gasToken",
+		type: "address"
+	},
+	{
+		name: "refundReceiver",
+		type: "address"
+	},
+	{
+		name: "nonce",
+		type: "uint256"
+	}
+] };
+/** EIP-712 SafeTx hash (Safe ≥ 1.3 domain: chainId + verifyingContract). */
+function hashSafeTx(params) {
+	return hashTypedData({
+		domain: {
+			chainId: params.chainId,
+			verifyingContract: params.safe
+		},
+		types: SAFE_TX_TYPES,
+		primaryType: "SafeTx",
+		message: params.tx
+	});
+}
+/**
+* A wallet signing a plain call for a Safe owner (Rabby, Safe{Wallet}) signs it
+* with no refund or gas fields; only the nonce varies.
+*/
+function safeTxForCall(call, nonce) {
+	return {
+		...call,
+		operation: 0,
+		safeTxGas: 0n,
+		baseGas: 0n,
+		gasPrice: 0n,
+		gasToken: zeroAddress,
+		refundReceiver: zeroAddress,
+		nonce
+	};
+}
+/** True for a 65-byte ECDSA signature — what a Safe-owner wallet returns instead of a tx hash. */
+function isSafeOwnerSignature(value) {
+	return typeof value === "string" && /^0x[0-9a-fA-F]{130}$/.test(value);
+}
+const SECP256K1_N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+const SUPPORTED_V = new Set([
+	0,
+	1,
+	27,
+	28,
+	31,
+	32
+]);
+/**
+* Rejects anything that cannot be a Safe owner's ECDSA signature, without any
+* RPC: 65 bytes, supported v (raw 0/1/27/28 or `eth_sign` 31/32), and r, s in
+* the curve range.
+*/
+function assertSafeOwnerSignature(signature) {
+	if (!isSafeOwnerSignature(signature)) throw new SignedSafeTxError("INVALID_SIGNATURE", "expected a 65-byte ECDSA signature");
+	const r = hexToBigInt(sliceHex(signature, 0, 32));
+	const s = hexToBigInt(sliceHex(signature, 32, 64));
+	const v = hexToNumber(sliceHex(signature, 64, 65));
+	if (!SUPPORTED_V.has(v)) throw new SignedSafeTxError("INVALID_SIGNATURE", `unsupported signature v=${v}`);
+	if (r === 0n || r >= SECP256K1_N || s === 0n || s >= SECP256K1_N) throw new SignedSafeTxError("INVALID_SIGNATURE", "signature r/s out of range");
+}
+/**
+* Recovers the signer of `safeTxHash`, accepting raw ECDSA (v 27/28, or 0/1)
+* and `eth_sign` (v 31/32) signatures, and returns the signature in the form
+* the Safe verifies.
+*/
+async function recoverSafeTxSigner(safeTxHash, signature) {
+	assertSafeOwnerSignature(signature);
+	const rs = sliceHex(signature, 0, 64);
+	const v = hexToNumber(sliceHex(signature, 64, 65));
+	const ethSign = v === 31 || v === 32;
+	const normalized = ethSign ? signature : concatHex([rs, numberToHex(v < 27 ? v + 27 : v, { size: 1 })]);
+	try {
+		const signer = ethSign ? await recoverAddress({
+			hash: hashMessage({ raw: safeTxHash }),
+			signature: concatHex([rs, numberToHex(v - 4, { size: 1 })])
+		}) : await recoverAddress({
+			hash: safeTxHash,
+			signature: normalized
+		});
+		return {
+			signer,
+			signature: normalized
+		};
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new SignedSafeTxError("INVALID_SIGNATURE", `signature recovery failed: ${reason}`);
+	}
+}
+/**
+* Resolves an owner's signature over a plain call into an executable SafeTx,
+* given the Safe's on-chain `nonce`, `owners` and `threshold`. The signed nonce
+* is not part of the call, so it is searched from the on-chain nonce forward
+* (wallets may sign ahead of queued transactions).
+*/
+async function resolveSignedSafeTx(params) {
+	const safe = getAddress(params.safe);
+	const nonceWindow = params.nonceWindow ?? 5;
+	const { nonce, threshold, owners } = params.state;
+	if (threshold !== 1n) throw new SignedSafeTxError("THRESHOLD_NOT_MET", `Safe threshold is ${threshold}; a single owner signature cannot execute`);
+	for (let offset = 0n; offset < BigInt(nonceWindow); offset++) {
+		const tx = safeTxForCall(params.call, nonce + offset);
+		const safeTxHash = hashSafeTx({
+			chainId: params.chainId,
+			safe,
+			tx
+		});
+		const { signer, signature } = await recoverSafeTxSigner(safeTxHash, params.signature);
+		if (owners.some((owner) => isAddressEqual(owner, signer))) return {
+			safe,
+			chainId: params.chainId,
+			tx,
+			safeTxHash,
+			signer,
+			signatures: signature
+		};
+	}
+	throw new SignedSafeTxError("SIGNATURE_MISMATCH", `signature does not recover to an owner of ${safe} for nonces ${nonce}..${nonce + BigInt(nonceWindow) - 1n}`);
+}
+/** `execTransaction` arguments for a resolved signed SafeTx. */
+function execTransactionArgs(signed) {
+	const { tx } = signed;
+	return [
+		tx.to,
+		tx.value,
+		tx.data,
+		tx.operation,
+		tx.safeTxGas,
+		tx.baseGas,
+		tx.gasPrice,
+		tx.gasToken,
+		tx.refundReceiver,
+		signed.signatures
+	];
+}
+
+//#endregion
+export { SignedSafeTxError, assertSafeOwnerSignature, execTransactionArgs, hashSafeTx, isSafeOwnerSignature, recoverSafeTxSigner, resolveSignedSafeTx, safeAbi, safeTxForCall };
+//# sourceMappingURL=index.js.map

package/dist/safe/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["code: SignedSafeTxErrorCode","message: string","params: { chainId: number; safe: Address; tx: SafeTx }","call: SafeCall","nonce: bigint","value: unknown","signature: Hex","safeTxHash: Hex","params: {\n  chainId: number\n  safe: Address\n  call: SafeCall\n  signature: Hex\n  state: { nonce: bigint; threshold: bigint; owners: readonly Address[] }\n  nonceWindow?: number\n}","signed: SignedSafeTx"],"sources":["../../src/safe/signedSafeTx.ts"],"sourcesContent":["import {\n  type Address,\n  type Hex,\n  concatHex,\n  getAddress,\n  hashMessage,\n  hashTypedData,\n  hexToBigInt,\n  hexToNumber,\n  isAddressEqual,\n  numberToHex,\n  recoverAddress,\n  sliceHex,\n  zeroAddress,\n} from 'viem'\n\nexport const safeAbi = [\n  {\n    type: 'event',\n    name: 'ExecutionSuccess',\n    inputs: [\n      { name: 'txHash', type: 'bytes32', indexed: true },\n      { name: 'payment', type: 'uint256', indexed: false },\n    ],\n  },\n  {\n    type: 'function',\n    name: 'execTransaction',\n    stateMutability: 'payable',\n    inputs: [\n      { name: 'to', type: 'address' },\n      { name: 'value', type: 'uint256' },\n      { name: 'data', type: 'bytes' },\n      { name: 'operation', type: 'uint8' },\n      { name: 'safeTxGas', type: 'uint256' },\n      { name: 'baseGas', type: 'uint256' },\n      { name: 'gasPrice', type: 'uint256' },\n      { name: 'gasToken', type: 'address' },\n      { name: 'refundReceiver', type: 'address' },\n      { name: 'signatures', type: 'bytes' },\n    ],\n    outputs: [{ name: 'success', type: 'bool' }],\n  },\n  {\n    type: 'function',\n    name: 'VERSION',\n    stateMutability: 'view',\n    inputs: [],\n    outputs: [{ type: 'string' }],\n  },\n  {\n    type: 'function',\n    name: 'nonce',\n    stateMutability: 'view',\n    inputs: [],\n    outputs: [{ type: 'uint256' }],\n  },\n  {\n    type: 'function',\n    name: 'getThreshold',\n    stateMutability: 'view',\n    inputs: [],\n    outputs: [{ type: 'uint256' }],\n  },\n  {\n    type: 'function',\n    name: 'getOwners',\n    stateMutability: 'view',\n    inputs: [],\n    outputs: [{ type: 'address[]' }],\n  },\n] as const\n\n/** A plain call the owner asked their wallet to send from the Safe. */\nexport interface SafeCall {\n  to: Address\n  value: bigint\n  data: Hex\n}\n\nexport interface SafeTx extends SafeCall {\n  operation: 0 | 1\n  safeTxGas: bigint\n  baseGas: bigint\n  gasPrice: bigint\n  gasToken: Address\n  refundReceiver: Address\n  nonce: bigint\n}\n\nexport interface SignedSafeTx {\n  safe: Address\n  chainId: number\n  tx: SafeTx\n  safeTxHash: Hex\n  signer: Address\n  /** Packed `signatures` argument for `execTransaction`. */\n  signatures: Hex\n}\n\nexport type SignedSafeTxErrorCode = 'INVALID_SIGNATURE' | 'THRESHOLD_NOT_MET' | 'SIGNATURE_MISMATCH'\n\nexport class SignedSafeTxError extends Error {\n  constructor(\n    readonly code: SignedSafeTxErrorCode,\n    message: string,\n  ) {\n    super(message)\n    this.name = 'SignedSafeTxError'\n  }\n}\n\nconst SAFE_TX_TYPES = {\n  SafeTx: [\n    { name: 'to', type: 'address' },\n    { name: 'value', type: 'uint256' },\n    { name: 'data', type: 'bytes' },\n    { name: 'operation', type: 'uint8' },\n    { name: 'safeTxGas', type: 'uint256' },\n    { name: 'baseGas', type: 'uint256' },\n    { name: 'gasPrice', type: 'uint256' },\n    { name: 'gasToken', type: 'address' },\n    { name: 'refundReceiver', type: 'address' },\n    { name: 'nonce', type: 'uint256' },\n  ],\n} as const\n\n/** EIP-712 SafeTx hash (Safe ≥ 1.3 domain: chainId + verifyingContract). */\nexport function hashSafeTx(params: { chainId: number; safe: Address; tx: SafeTx }): Hex {\n  return hashTypedData({\n    domain: { chainId: params.chainId, verifyingContract: params.safe },\n    types: SAFE_TX_TYPES,\n    primaryType: 'SafeTx',\n    message: params.tx,\n  })\n}\n\n/**\n * A wallet signing a plain call for a Safe owner (Rabby, Safe{Wallet}) signs it\n * with no refund or gas fields; only the nonce varies.\n */\nexport function safeTxForCall(call: SafeCall, nonce: bigint): SafeTx {\n  return {\n    ...call,\n    operation: 0,\n    safeTxGas: 0n,\n    baseGas: 0n,\n    gasPrice: 0n,\n    gasToken: zeroAddress,\n    refundReceiver: zeroAddress,\n    nonce,\n  }\n}\n\n/** True for a 65-byte ECDSA signature — what a Safe-owner wallet returns instead of a tx hash. */\nexport function isSafeOwnerSignature(value: unknown): value is Hex {\n  return typeof value === 'string' && /^0x[0-9a-fA-F]{130}$/.test(value)\n}\n\nconst SECP256K1_N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n\nconst SUPPORTED_V = new Set([0, 1, 27, 28, 31, 32])\n\n/**\n * Rejects anything that cannot be a Safe owner's ECDSA signature, without any\n * RPC: 65 bytes, supported v (raw 0/1/27/28 or `eth_sign` 31/32), and r, s in\n * the curve range.\n */\nexport function assertSafeOwnerSignature(signature: Hex): void {\n  if (!isSafeOwnerSignature(signature)) {\n    throw new SignedSafeTxError('INVALID_SIGNATURE', 'expected a 65-byte ECDSA signature')\n  }\n  const r = hexToBigInt(sliceHex(signature, 0, 32))\n  const s = hexToBigInt(sliceHex(signature, 32, 64))\n  const v = hexToNumber(sliceHex(signature, 64, 65))\n  if (!SUPPORTED_V.has(v)) {\n    throw new SignedSafeTxError('INVALID_SIGNATURE', `unsupported signature v=${v}`)\n  }\n  if (r === 0n || r >= SECP256K1_N || s === 0n || s >= SECP256K1_N) {\n    throw new SignedSafeTxError('INVALID_SIGNATURE', 'signature r/s out of range')\n  }\n}\n\n/**\n * Recovers the signer of `safeTxHash`, accepting raw ECDSA (v 27/28, or 0/1)\n * and `eth_sign` (v 31/32) signatures, and returns the signature in the form\n * the Safe verifies.\n */\nexport async function recoverSafeTxSigner(\n  safeTxHash: Hex,\n  signature: Hex,\n): Promise<{ signer: Address; signature: Hex }> {\n  assertSafeOwnerSignature(signature)\n  const rs = sliceHex(signature, 0, 64)\n  const v = hexToNumber(sliceHex(signature, 64, 65))\n  const ethSign = v === 31 || v === 32\n  const normalized = ethSign\n    ? signature\n    : concatHex([rs, numberToHex(v < 27 ? v + 27 : v, { size: 1 })])\n  try {\n    const signer = ethSign\n      ? await recoverAddress({\n          hash: hashMessage({ raw: safeTxHash }),\n          signature: concatHex([rs, numberToHex(v - 4, { size: 1 })]),\n        })\n      : await recoverAddress({ hash: safeTxHash, signature: normalized })\n    return { signer, signature: normalized }\n  } catch (error) {\n    const reason = error instanceof Error ? error.message : String(error)\n    throw new SignedSafeTxError('INVALID_SIGNATURE', `signature recovery failed: ${reason}`)\n  }\n}\n\n/**\n * Resolves an owner's signature over a plain call into an executable SafeTx,\n * given the Safe's on-chain `nonce`, `owners` and `threshold`. The signed nonce\n * is not part of the call, so it is searched from the on-chain nonce forward\n * (wallets may sign ahead of queued transactions).\n */\nexport async function resolveSignedSafeTx(params: {\n  chainId: number\n  safe: Address\n  call: SafeCall\n  signature: Hex\n  state: { nonce: bigint; threshold: bigint; owners: readonly Address[] }\n  nonceWindow?: number\n}): Promise<SignedSafeTx> {\n  const safe = getAddress(params.safe)\n  const nonceWindow = params.nonceWindow ?? 5\n  const { nonce, threshold, owners } = params.state\n  if (threshold !== 1n) {\n    throw new SignedSafeTxError(\n      'THRESHOLD_NOT_MET',\n      `Safe threshold is ${threshold}; a single owner signature cannot execute`,\n    )\n  }\n\n  for (let offset = 0n; offset < BigInt(nonceWindow); offset++) {\n    const tx = safeTxForCall(params.call, nonce + offset)\n    const safeTxHash = hashSafeTx({ chainId: params.chainId, safe, tx })\n    const { signer, signature } = await recoverSafeTxSigner(safeTxHash, params.signature)\n    if (owners.some((owner) => isAddressEqual(owner, signer))) {\n      return { safe, chainId: params.chainId, tx, safeTxHash, signer, signatures: signature }\n    }\n  }\n  throw new SignedSafeTxError(\n    'SIGNATURE_MISMATCH',\n    `signature does not recover to an owner of ${safe} for nonces ${nonce}..${nonce + BigInt(nonceWindow) - 1n}`,\n  )\n}\n\n/** `execTransaction` arguments for a resolved signed SafeTx. */\nexport function execTransactionArgs(signed: SignedSafeTx) {\n  const { tx } = signed\n  return [\n    tx.to,\n    tx.value,\n    tx.data,\n    tx.operation,\n    tx.safeTxGas,\n    tx.baseGas,\n    tx.gasPrice,\n    tx.gasToken,\n    tx.refundReceiver,\n    signed.signatures,\n  ] as const\n}\n"],"mappings":"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"}