@parmanasystems/core

npm install @parmanasystems/core

import crypto from "crypto";
import {
  executeFromSignals,
  confirmExecution,
  verifyAttestation,
  LocalSigner,
  LocalVerifier,
  MemoryReplayStore,
} from "@parmanasystems/core";

async function main() {
  const { privateKey, publicKey } = crypto.generateKeyPairSync("ed25519", {
    privateKeyEncoding: { type: "pkcs8", format: "pem" },
    publicKeyEncoding:  { type: "spki",  format: "pem" },
  });

  const signer   = new LocalSigner(privateKey);
  const verifier = new LocalVerifier(publicKey);
  const store    = new MemoryReplayStore();

  const attestation = await executeFromSignals(
    {
      policyId:      "loan-approval",
      policyVersion: "1.0.0",
      signals:       { credit_score: 720, loan_amount: 15000 },
    },
    signer,
    verifier,
    undefined, // use default runtime paths
    store
  );

  console.log(attestation.decision);
  // { action: "approve", requires_override: false, reason: "Credit score meets standard threshold." }

  const result = verifyAttestation(attestation, verifier);
  console.log(result.valid); // true

  // Confirm a real-world action against the authorization
  const proof = await confirmExecution(
    {
      attestation,
      executedAction: {
        type:       "LOAN_DISBURSED",
        payload:    { amount: 15000 },
        executedAt: new Date().toISOString(),
      },
    },
    signer,
    verifier,
    store
  );

  console.log(proof.match); // true — action matches authorization
}

main().catch(console.error);

import {
  executeFromSignals,
  withProvenance,
  accountAggregatorProvenance,
  validateProvenance,
  extractSignalValues,
  LocalSigner,
  LocalVerifier,
  RedisReplayStore,
} from "@parmanasystems/core";

const signals = {
  monthly_income: withProvenance(
    aaResponse.derivedMonthlyIncome,
    accountAggregatorProvenance({
      consentId: aaResponse.consentId,
      fiuId:     "FIU-NBFC-001",
      fetchedAt: aaResponse.fetchedAt,
      rawData:   aaResponse.rawFiData,
    })
  ),
  credit_score: 720,
  employed:     true,
};

const validation = validateProvenance(signals, { minimumTrustLevel: "verified" });
if (!validation.valid) throw new Error(validation.errors.join(", "));

const attestation = await executeFromSignals(
  {
    policyId:      "personal-loan",
    policyVersion: "1.0.0",
    signals:       extractSignalValues(signals),
  },
  signer, verifier, undefined, store
);

import { executeFromSignals, RedisReplayStore, LocalSigner, LocalVerifier } from "@parmanasystems/core";
import { ErrorCodes } from "@parmanasystems/execution";

try {
  const attestation = await executeFromSignals(
    {
      policyId:      "upi-fraud-gate",
      policyVersion: "1.0.0",
      signals: {
        transaction_amount: 50000,
        risk_score:         87,
        is_foreign:         false,
      },
    },
    signer, verifier, undefined, store
  );
  return attestation.decision.action; // "fraud_review" | "approve"
} catch (err: any) {
  if (err.message?.includes(ErrorCodes.INV_013)) {
    // Already executed — idempotent return
    return cachedDecision;
  }
  throw err;
}

import { verifyAttestation, LocalVerifier } from "@parmanasystems/core";

const verifier = new LocalVerifier(insurerPublicKey);

for (const attestation of auditBatch) {
  const result = verifyAttestation(attestation, verifier);
  if (!result.valid) {
    flag(attestation.executionId, result.errors);
  }
}