Off-chase

export function hashRecord(record: object, signatureField: string): Hex {
  const payload: Record<string, unknown> = { ...record };
  delete payload[signatureField];
  const canonical = canonicalize(payload);
  if (canonical === undefined) throw new Error('INVALID_RECORD');
  return keccak256(toBytes(canonical));
}

export async function signRecord<T extends object>(
  record: T,
  signatureField: string,
  account: PrivateKeyAccount,
): Promise<T & Record<string, Hex>> {
  const hash = hashRecord(record, signatureField);
  const signature = await account.signMessage({ message: { raw: hash } });
  return { ...record, [signatureField]: signature };
}

    const requestAnchor = await this.anchor.anchorRequest(request.request_id, requestHash, request.policy_hash as `0x${string}`);
    const receipt = await createReceipt(this.verificationAccount, request, requestAnchor);
    const bundle = EvidenceBundleSchema.parse({
      schema_version: 1, policy, request, verification_receipt: receipt, decision: null,
      anchors: {
        chain_id: this.anchor.chainId, contract_address: this.anchor.address, request_tx: requestAnchor.requestTx,
      },
    });
    await this.store.saveBundle(bundle);
    if (options.omitDecision) return bundle;
    const decision = await decideRequest(this.institutionAccount, request, policy, receipt, this.registry);
    return this.submitDecision(decision);
  }

    function anchorDecision(bytes32 requestKey, bytes32 decisionHash) external onlyOwner {
        require(decisionHash != bytes32(0), "INVALID_ANCHOR_HASH");
        RequestAnchorData storage record = records[requestKey];
        require(record.requestHash != bytes32(0), "UNVERIFIED_REQUEST");
        require(record.decisionHash == bytes32(0), "DECISION_ALREADY_ANCHORED");
        require(block.timestamp <= record.decisionDeadline, "DEADLINE_EXPIRED");
        record.decisionHash = decisionHash;
        record.decisionAnchoredAt = uint64(block.timestamp);
        emit DecisionAnchored(requestKey, decisionHash, record.decisionAnchoredAt);
    }

  const signatures: Array<{ record: object; signature: string; key: string; error: string }> = [
    { record: policy, signature: 'enterprise_signature', key: policy.enterprise_key_id, error: 'INVALID_ENTERPRISE_SIGNATURE' },
    { record: request, signature: 'agent_signature', key: request.agent_key_id, error: 'INVALID_AGENT_SIGNATURE' },
    { record: receipt, signature: 'verification_signature', key: receipt.verification_key_id, error: 'INVALID_VERIFICATION_SIGNATURE' },
  ];
  if (decision) signatures.push({
    record: decision, signature: 'institution_signature', key: decision.institution_key_id, error: 'INVALID_INSTITUTION_SIGNATURE',
  });
  for (const { record, signature, key, error } of signatures) {
    const address = registry[key];
    if (!address || !await verifyRecordSignature(record, signature, address)) errors.push(error);
  }

    const recovered = record.decisionHash === decisionHash;
    if (recovered && (record.decisionAnchoredAt === null || record.decisionAnchoredAt > record.decisionDeadline)) {
      throw new Error('DEADLINE_EXPIRED');
    }
    if (!recovered && await this.anchor.chainTime() > record.decisionDeadline) throw new Error('DEADLINE_EXPIRED');
    let result: { decisionTx: `0x${string}` };
    if (recovered) {
      const recoveredTx = await this.anchor.findDecisionTx(
        decision.request_id,
        decisionHash,
        BigInt(bundle.verification_receipt.request_anchor_block),
      );
      if (!recoveredTx) throw new Error('DECISION_ANCHOR_RECOVERY_FAILED');
      result = { decisionTx: recoveredTx };
    } else {
      result = await this.anchor.anchorDecision(decision.request_id, decisionHash);
    }