uvd-x402-sdk 2.110.0 → 2.111.0

package/dist/providers/near/index.js

@@ -1484,7 +1484,7 @@ function validateEscrowAuthorizationDelegate(d, o) {
   if (gas < NEAR_ESCROW_MIN_GAS || gas > NEAR_ESCROW_MAX_GAS) throw new Error("FT gas outside 38..100 TGas");
 }
 async function signDelegate(o, d, scheme = "escrow") {
-  const network = o.network;
+  const network2 = o.network;
   const pk = new Uint8Array(o.signer.publicKey);
   if (pk.length !== 32) throw new Error("Expected 32-byte Ed25519 public key");
   const a = d.actions[0];
@@ -1511,7 +1511,7 @@ async function signDelegate(o, d, scheme = "escrow") {
   return {
     x402Version: 2,
     scheme,
-    network,
+    network: network2,
     payload: { signedDelegateAction: btoa(Array.from(signed, (b) => String.fromCharCode(b)).join("")) }
   };
 }
@@ -1726,6 +1726,496 @@ function parseArrasEvents(logs) {
   }
   return result;
 }
+var NEAR_REGISTRY_CONTRACTS = Object.freeze({
+  "near:mainnet": Object.freeze(["registry.arras-escrow.near"]),
+  "near:testnet": Object.freeze([])
+});
+var NEAR_REGISTRY_ESCROWS = Object.freeze({
+  "near:mainnet": Object.freeze(["v1.arras-escrow.near"]),
+  "near:testnet": Object.freeze([])
+});
+var REGISTER_DEPOSIT = "17510000000000000000000";
+var FEEDBACK_DEPOSIT = "18640000000000000000000";
+var REGISTRY_GAS = "30000000000000";
+var GIVE_FEEDBACK_GAS = "100000000000000";
+var MIN_GIVE_FEEDBACK_GAS = "60000000000000";
+var RegistryErrorCode = /* @__PURE__ */ ((RegistryErrorCode2) => {
+  RegistryErrorCode2["E01"] = "E01_AGENT_URI_INVALIDA";
+  RegistryErrorCode2["E02"] = "E02_METADATA_INVALIDA";
+  RegistryErrorCode2["E03"] = "E03_YA_REGISTRADO";
+  RegistryErrorCode2["E04"] = "E04_NO_REGISTRADO";
+  RegistryErrorCode2["E05"] = "E05_DEPOSITO_INSUFICIENTE";
+  RegistryErrorCode2["E06"] = "E06_REQUIERE_DEPOSITO";
+  RegistryErrorCode2["E10"] = "E10_ESCROW_NO_PERMITIDO";
+  RegistryErrorCode2["E11"] = "E11_PAYMENT_ID_INVALIDO";
+  RegistryErrorCode2["E12"] = "E12_SCORE_INVALIDO";
+  RegistryErrorCode2["E13"] = "E13_TAG_INVALIDO";
+  RegistryErrorCode2["E14"] = "E14_FEEDBACK_URI_INVALIDA";
+  RegistryErrorCode2["E15"] = "E15_FEEDBACK_HASH_INVALIDO";
+  RegistryErrorCode2["E16"] = "E16_DEPOSITO_FEEDBACK";
+  RegistryErrorCode2["E17"] = "E17_GAS_INSUFICIENTE";
+  RegistryErrorCode2["E18"] = "E18_YA_CALIFICADO";
+  RegistryErrorCode2["E19"] = "E19_EN_VUELO";
+  RegistryErrorCode2["E20"] = "E20_GET_PAYMENT_FALLO";
+  RegistryErrorCode2["E21"] = "E21_RESPUESTA_INVALIDA";
+  RegistryErrorCode2["E22"] = "E22_PAGO_INEXISTENTE";
+  RegistryErrorCode2["E23"] = "E23_PAGO_SIN_LIBERAR";
+  RegistryErrorCode2["E24"] = "E24_NO_ES_PARTE";
+  RegistryErrorCode2["E25"] = "E25_AUTO_CALIFICACION";
+  RegistryErrorCode2["E26"] = "E26_REEMPLAZADO";
+  RegistryErrorCode2["E30"] = "E30_FEEDBACK_INEXISTENTE";
+  RegistryErrorCode2["E31"] = "E31_YA_REVOCADO";
+  RegistryErrorCode2["E40"] = "E40_ESCROWS_INVALIDOS";
+  return RegistryErrorCode2;
+})(RegistryErrorCode || {});
+var RegistryValidationError = class extends Error {
+  constructor(code) {
+    super(`ARRAS_REG_${code.slice(0, 3)}: ${code}`);
+    this.code = code;
+  }
+};
+function requireRule(ok, code) {
+  if (!ok) throw new RegistryValidationError(code);
+}
+function validUri(value) {
+  return typeof value === "string" && value.length <= 512 && fullMatch(/^[A-Za-z][A-Za-z0-9+.-]*:[\x21-\x7e]+$/, value);
+}
+function validMetadata(value) {
+  return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).length <= 1024 && !/[\x00-\x1f\x7f]/u.test(value) && !/[\ud800-\udfff]/u.test(value);
+}
+function validTag(value) {
+  return typeof value === "string" && fullMatch(/^[A-Za-z0-9._:/-]{1,64}$/, value);
+}
+function validPaymentId(value) {
+  return typeof value === "string" && fullMatch(/^[\x21-\x7e]{1,64}$/, value);
+}
+function validHash(value) {
+  return typeof value === "string" && fullMatch(/^[0-9a-f]{64}$/, value);
+}
+function validScore(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100;
+}
+function network(value) {
+  if (value !== "near:mainnet" && value !== "near:testnet") throw new Error("Unsupported NEAR network");
+}
+function receiver(o) {
+  network(o.network);
+  const id = o.registryContract ?? NEAR_REGISTRY_CONTRACTS[o.network][0];
+  if (!NEAR_REGISTRY_CONTRACTS[o.network].includes(id)) throw new Error("receiverId: unregistered registry for network");
+  return id;
+}
+function escrow(value, net) {
+  requireRule(NEAR_REGISTRY_ESCROWS[net].includes(value), "E10_ESCROW_NO_PERMITIDO" /* E10 */);
+}
+function codedUint(value, bits, code) {
+  try {
+    return uint(value, bits, code);
+  } catch {
+    throw new RegistryValidationError(code);
+  }
+}
+function canonicalArgs(method, input, net) {
+  const allowed = method === "register" || method === "update" ? ["agent_uri", "metadata"] : method === "give_feedback" ? ["escrow", "payment_id", "score", "tag1", "tag2", "feedback_uri", "feedback_hash"] : ["escrow", "payment_id"];
+  if (Object.keys(input).some((key) => !allowed.includes(key))) throw new Error("Unexpected registry argument");
+  const args = {};
+  if (method === "register" || method === "update") {
+    requireRule(validUri(input.agent_uri), "E01_AGENT_URI_INVALIDA" /* E01 */);
+    args.agent_uri = input.agent_uri;
+    if (input.metadata != null) {
+      requireRule(validMetadata(input.metadata), "E02_METADATA_INVALIDA" /* E02 */);
+      args.metadata = input.metadata;
+    }
+  } else {
+    escrow(input.escrow, net);
+    requireRule(validPaymentId(input.payment_id), "E11_PAYMENT_ID_INVALIDO" /* E11 */);
+    args.escrow = input.escrow;
+    args.payment_id = input.payment_id;
+    if (method === "give_feedback") {
+      requireRule(validScore(input.score), "E12_SCORE_INVALIDO" /* E12 */);
+      args.score = input.score;
+      for (const field of ["tag1", "tag2"]) {
+        if (input[field] != null) {
+          requireRule(validTag(input[field]), "E13_TAG_INVALIDO" /* E13 */);
+          args[field] = input[field];
+        }
+      }
+      if (input.feedback_uri != null) {
+        requireRule(validUri(input.feedback_uri), "E14_FEEDBACK_URI_INVALIDA" /* E14 */);
+        args.feedback_uri = input.feedback_uri;
+      }
+      if (input.feedback_hash != null) {
+        requireRule(validHash(input.feedback_hash), "E15_FEEDBACK_HASH_INVALIDO" /* E15 */);
+        args.feedback_hash = input.feedback_hash;
+      }
+    }
+  }
+  return args;
+}
+function build(method, options, input) {
+  const o = { ...options };
+  const receiverId = receiver(o);
+  account(o.signerId, "signerId");
+  const updateDeposit = method === "update" ? codedUint(o.deposit === void 0 ? REGISTER_DEPOSIT : o.deposit, 128, "E06_REQUIERE_DEPOSITO" /* E06 */) : void 0;
+  if (updateDeposit !== void 0) requireRule(updateDeposit > 0n, "E06_REQUIERE_DEPOSITO" /* E06 */);
+  const args = canonicalArgs(method, { ...input }, o.network);
+  const depositCode = method === "give_feedback" ? "E16_DEPOSITO_FEEDBACK" /* E16 */ : "E05_DEPOSITO_INSUFICIENTE" /* E05 */;
+  const minimum = method === "give_feedback" ? FEEDBACK_DEPOSIT : REGISTER_DEPOSIT;
+  const deposit = updateDeposit ?? (method === "revoke_feedback" ? uint(o.deposit === void 0 ? "1" : o.deposit, 128, "deposit") : codedUint(o.deposit === void 0 ? minimum : o.deposit, 128, depositCode));
+  if (method === "revoke_feedback") {
+    if (deposit !== 1n) throw new Error("revoke_feedback deposit must be exactly 1 yocto");
+  } else if (method !== "update") {
+    requireRule(deposit >= BigInt(minimum), depositCode);
+  }
+  const gas = uint(o.gas === void 0 ? method === "give_feedback" ? GIVE_FEEDBACK_GAS : REGISTRY_GAS : o.gas, 64, "gas");
+  if (method === "give_feedback") requireRule(gas >= BigInt(MIN_GIVE_FEEDBACK_GAS), "E17_GAS_INSUFICIENTE" /* E17 */);
+  else if (gas < 1n) throw new Error("gas must be positive");
+  if (gas > 300000000000000n) throw new Error("gas exceeds 300 TGas");
+  return { signerId: o.signerId, receiverId, actions: [{ type: "FunctionCall", params: {
+    methodName: method,
+    args,
+    gas: gas.toString(),
+    deposit: deposit.toString()
+  } }] };
+}
+var buildRegistryRegister = (options) => {
+  const { agent_uri, metadata, ...o } = options;
+  return build("register", o, { agent_uri, metadata });
+};
+var buildRegistryUpdate = (options) => {
+  const { agent_uri, metadata, ...o } = options;
+  return build("update", o, { agent_uri, metadata });
+};
+var buildGiveFeedback = (options) => {
+  const { escrow: escrow2, payment_id, score, tag1, tag2, feedback_uri, feedback_hash, ...o } = options;
+  return build("give_feedback", o, { escrow: escrow2, payment_id, score, tag1, tag2, feedback_uri, feedback_hash });
+};
+var buildRevokeFeedback = (options) => {
+  const { escrow: escrow2, payment_id, ...o } = options;
+  return build("revoke_feedback", o, { escrow: escrow2, payment_id });
+};
+function base64(bytes) {
+  return btoa(Array.from(bytes, (b) => String.fromCharCode(b)).join(""));
+}
+function fromBase64(value) {
+  if (!fullMatch(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, value)) throw new Error("Invalid base64");
+  return Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+}
+async function signRegistryTransaction(descriptor, signer, nonce, blockHash) {
+  const { signerId, receiverId, actions } = descriptor;
+  const net = Object.keys(NEAR_REGISTRY_CONTRACTS).find((n2) => NEAR_REGISTRY_CONTRACTS[n2].includes(receiverId));
+  if (!net) throw new Error("receiverId: unregistered registry");
+  if (!Array.isArray(actions) || actions.length !== 1) throw new Error("Expected exactly one registry action");
+  const action = { ...actions[0] };
+  if (action.type !== "FunctionCall") throw new Error("Expected FunctionCall");
+  const p = { ...action.params };
+  if (!["register", "update", "give_feedback", "revoke_feedback"].includes(p.methodName)) throw new Error("Unknown registry method");
+  if (typeof p.gas !== "string" || typeof p.deposit !== "string") throw new Error("Expected gas and deposit strings");
+  if (!object2(p.args)) throw new Error("Expected registry args object");
+  const d = build(p.methodName, { network: net, registryContract: receiverId, signerId, deposit: p.deposit, gas: p.gas }, { ...p.args });
+  const a = d.actions[0].params;
+  const n = uint(nonce, 64, "nonce");
+  if (n === 0n) throw new Error("nonce must be positive");
+  const hash = unbase58(blockHash);
+  if (hash.length !== 32) throw new Error("Expected 32-byte block hash");
+  const pk = new Uint8Array(signer.publicKey);
+  if (pk.length !== 32) throw new Error("Expected 32-byte Ed25519 public key");
+  const bytes = concat(
+    str(d.signerId),
+    Uint8Array.of(0),
+    pk,
+    le(n, 8),
+    str(d.receiverId),
+    hash,
+    le(1n, 4),
+    Uint8Array.of(2),
+    str(a.methodName),
+    str(JSON.stringify(a.args)),
+    le(BigInt(a.gas), 8),
+    le(BigInt(a.deposit), 16)
+  );
+  const digest = sha256.sha256(bytes);
+  const signature = await signer.sign(digest.slice());
+  if (!(signature instanceof Uint8Array) || signature.length !== 64 || !ed25519.ed25519.verify(signature, digest, pk)) {
+    throw new Error("Invalid Ed25519 transaction signature");
+  }
+  return base64(concat(bytes, Uint8Array.of(0), signature));
+}
+var object2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var string2 = (v) => typeof v === "string";
+var boolean2 = (v) => typeof v === "boolean";
+var nullable = (check) => (v) => v === null || check(v);
+var array = (check) => (v) => Array.isArray(v) && v.every(check);
+function record2(required, optional = {}) {
+  return (v) => object2(v) && Object.entries(required).every(([k, check]) => Object.hasOwn(v, k) && check(v[k])) && Object.entries(optional).every(([k, check]) => !Object.hasOwn(v, k) || check(v[k]));
+}
+var integer2 = (bits) => (v) => {
+  if (typeof v !== "string") return false;
+  try {
+    uint(v, bits, "view integer");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var u32 = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 4294967295;
+var u642 = integer2(64);
+var u1282 = integer2(128);
+var accountCheck = (v) => {
+  try {
+    account(v, "account");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var operator2 = (v) => typeof v === "string" && new TextEncoder().encode(v).length <= 64 && !/[\ud800-\udfff]/u.test(v);
+var role = (v) => v === "payer" || v === "receiver";
+var agentFields = { account_id: accountCheck, agent_uri: validUri, metadata: nullable(validMetadata) };
+var feedbackFields = {
+  feedback_id: u32,
+  rater: accountCheck,
+  ratee: accountCheck,
+  ratee_role: role,
+  escrow: accountCheck,
+  payment_id: validPaymentId,
+  operator_id: operator2,
+  released: u1282,
+  score: validScore,
+  tag1: nullable(validTag),
+  tag2: nullable(validTag),
+  feedback_uri: nullable(validUri),
+  feedback_hash: nullable(validHash),
+  created_at: u642
+};
+var agentCheck = record2({ ...agentFields, registered_at: u642, updated_at: u642 });
+var feedbackCheck = record2({ ...feedbackFields, revoked: boolean2, revoked_at: nullable(u642) });
+var average = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0 && v <= 1e4;
+var summaryFields = { count: u32, revoked: u32, score_sum: u642, average_x100: nullable(average) };
+var summaryCheck = record2({
+  ...summaryFields,
+  account_id: accountCheck,
+  as_payer: record2(summaryFields),
+  as_receiver: record2(summaryFields),
+  last_feedback_id: nullable(u32),
+  last_at: nullable(u642)
+}, { operator_id: string2 });
+var configCheck = record2({
+  version: (v) => v === "arras-registry-v1",
+  escrows: array(accountCheck),
+  agents: u32,
+  feedbacks: u32,
+  register_deposit: u1282,
+  feedback_deposit: u1282,
+  min_gas_give_feedback: u642,
+  limits: record2({
+    max_agent_uri_len: u32,
+    max_metadata_len: u32,
+    max_feedback_uri_len: u32,
+    max_tag_len: u32,
+    max_payment_id_len: u32,
+    max_score: (v) => u32(v) && v <= 255,
+    max_list_limit: u32,
+    pending_ttl_blocks: u642
+  })
+});
+var rpcUrls = {
+  "near:mainnet": "https://rpc.mainnet.near.org",
+  "near:testnet": "https://rpc.testnet.near.org"
+};
+async function view(options, method, args, check) {
+  const o = { ...options };
+  const id = receiver(o);
+  const rpc = o.rpc ?? (async (method2, params) => {
+    const response2 = await fetch(rpcUrls[o.network], {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: "registry", method: method2, params })
+    });
+    if (!response2.ok) throw new Error(`NEAR RPC HTTP ${response2.status}`);
+    const data = await response2.json();
+    if (!object2(data) || data.error || !Object.hasOwn(data, "result")) throw new Error("Invalid NEAR RPC response");
+    return data.result;
+  });
+  const response = await rpc("query", {
+    request_type: "call_function",
+    finality: "final",
+    account_id: id,
+    method_name: method,
+    args_base64: base64(new TextEncoder().encode(JSON.stringify(args)))
+  });
+  if (!object2(response) || !Array.isArray(response.result) || !response.result.every((v) => Number.isInteger(v) && v >= 0 && v <= 255)) throw new Error("Invalid call_function response");
+  const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(response.result)));
+  if (!check(value)) throw new Error(`Invalid ${method} response shape`);
+  return value;
+}
+function accountArgs(accountId) {
+  account(accountId, "account_id");
+  return { account_id: accountId };
+}
+function page(p) {
+  const result = {};
+  for (const k of ["from_index", "limit"]) {
+    const v = p[k];
+    if (v !== void 0) {
+      if (!u32(v)) throw new Error(`Invalid ${k}`);
+      result[k] = v;
+    }
+  }
+  return result;
+}
+function paymentArgs(o, input) {
+  network(o.network);
+  escrow(input.escrow, o.network);
+  requireRule(validPaymentId(input.payment_id), "E11_PAYMENT_ID_INVALIDO" /* E11 */);
+  account(input.rater, "rater");
+  return { escrow: input.escrow, payment_id: input.payment_id, rater: input.rater };
+}
+var getConfig = async (o) => view(o, "get_config", {}, configCheck);
+var getAgent = async (o, accountId) => view(o, "get_agent", accountArgs(accountId), nullable(agentCheck));
+var listAgents = async (o, p = {}) => view(o, "list_agents", page(p), array(agentCheck));
+var getFeedback = async (o, feedbackId) => {
+  if (!u32(feedbackId)) throw new Error("Invalid feedback_id");
+  return view(o, "get_feedback", { feedback_id: feedbackId }, nullable(feedbackCheck));
+};
+var getFeedbackForPayment = async (o, p) => view(o, "get_feedback_for_payment", paymentArgs(o, p), nullable(feedbackCheck));
+var listFeedback = async (o, accountId, p = {}) => view(o, "list_feedback", { ...accountArgs(accountId), ...page(p) }, array(feedbackCheck));
+var getSummary = async (o, accountId) => view(o, "get_summary", accountArgs(accountId), (v) => summaryCheck(v) && object2(v) && !Object.hasOwn(v, "operator_id"));
+var getSummaryByOperator = async (o, accountId, operatorId) => {
+  if (typeof operatorId !== "string") throw new Error("Invalid operator_id");
+  return view(
+    o,
+    "get_summary_by_operator",
+    { ...accountArgs(accountId), operator_id: operatorId },
+    (v) => summaryCheck(v) && object2(v) && Object.hasOwn(v, "operator_id")
+  );
+};
+var isFeedbackPending = async (o, p) => view(o, "is_feedback_pending", paymentArgs(o, p), boolean2);
+var eventChecks = {
+  agent_registered: record2({ ...agentFields, at: u642 }),
+  agent_updated: record2({ ...agentFields, at: u642 }),
+  feedback_given: record2(feedbackFields),
+  feedback_revoked: record2({
+    feedback_id: u32,
+    rater: accountCheck,
+    ratee: accountCheck,
+    escrow: accountCheck,
+    payment_id: validPaymentId,
+    revoked_at: u642
+  })
+};
+function parseRegistryEvents(logs) {
+  const result = [];
+  if (!Array.isArray(logs)) return result;
+  for (const log of logs) {
+    if (typeof log !== "string" || !log.startsWith("EVENT_JSON:")) continue;
+    let v;
+    try {
+      v = JSON.parse(log.slice(11));
+    } catch {
+      continue;
+    }
+    if (!object2(v) || v.standard !== "arras-registry" || v.version !== "1.0.0" || typeof v.event !== "string" || !Object.hasOwn(eventChecks, v.event) || !Array.isArray(v.data)) continue;
+    if (!v.data.every(eventChecks[v.event])) continue;
+    result.push({ standard: "arras-registry", version: "1.0.0", event: v.event, data: v.data });
+  }
+  return result;
+}
+function parseRegistryReceiptEvents(receiptsOutcome, net) {
+  network(net);
+  const result = [];
+  if (!Array.isArray(receiptsOutcome)) return result;
+  for (const receipt of receiptsOutcome) {
+    if (!object2(receipt) || !object2(receipt.outcome)) continue;
+    const outcome = receipt.outcome;
+    if (!NEAR_REGISTRY_CONTRACTS[net].includes(outcome.executor_id)) continue;
+    const status = outcome.status;
+    if (!object2(status) || Object.hasOwn(status, "Failure") || typeof status.SuccessValue !== "string" && typeof status.SuccessReceiptId !== "string") continue;
+    result.push(...parseRegistryEvents(outcome.logs));
+  }
+  return result;
+}
+var rejectionCodes = [
+  "E18_YA_CALIFICADO" /* E18 */,
+  "E20_GET_PAYMENT_FALLO" /* E20 */,
+  "E21_RESPUESTA_INVALIDA" /* E21 */,
+  "E22_PAGO_INEXISTENTE" /* E22 */,
+  "E23_PAGO_SIN_LIBERAR" /* E23 */,
+  "E24_NO_ES_PARTE" /* E24 */,
+  "E25_AUTO_CALIFICACION" /* E25 */,
+  "E26_REEMPLAZADO" /* E26 */
+];
+function panic(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  const number = text?.match(/ARRAS_REG_(E[0-9]{2}):/)?.[1];
+  const code = Object.values(RegistryErrorCode).find((c) => c.slice(0, 3) === number);
+  if (code) return { status: "error", code, message: text };
+  return void 0;
+}
+function parseGiveFeedbackOutcome(outcome) {
+  let value = outcome;
+  let logs = [];
+  if (typeof outcome === "string") {
+    const error = panic(outcome);
+    if (error) return error;
+  }
+  if (object2(outcome)) {
+    if (object2(outcome.status) && Object.hasOwn(outcome.status, "Failure")) {
+      const error = panic(outcome.status.Failure);
+      if (error) return error;
+      throw new Error("NEAR transaction failed without a registry code");
+    }
+    if (object2(outcome.status) && typeof outcome.status.SuccessValue === "string") {
+      value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(fromBase64(outcome.status.SuccessValue)));
+      if (Array.isArray(outcome.receipts_outcome)) {
+        logs = outcome.receipts_outcome.flatMap((r) => object2(r) && object2(r.outcome) && Array.isArray(r.outcome.logs) ? r.outcome.logs : []);
+      }
+    } else if (Object.hasOwn(outcome, "value")) {
+      value = outcome.value;
+      logs = Array.isArray(outcome.logs) ? outcome.logs : [];
+    } else throw new Error("Expected final give_feedback outcome");
+  }
+  if (u32(value)) return { status: "accepted", feedbackId: value };
+  if (value === null) {
+    const codes = new Set(logs.filter((l) => typeof l === "string").filter((l) => l.startsWith("arras-registry:rechazo:")).map((l) => l.slice(23)));
+    if (codes.size === 1) {
+      const code = [...codes][0];
+      if (rejectionCodes.includes(code)) return { status: "rejected", code };
+    }
+  }
+  throw new Error("Malformed or incomplete give_feedback outcome");
+}
+function summarizeFeedback(feedbacks, escrow2, operatorId) {
+  let count = 0, revoked = 0, score = 0n, released = 0n, weighted = 0n;
+  const raters = /* @__PURE__ */ new Set();
+  for (const f of feedbacks) {
+    if (!feedbackCheck(f)) throw new Error("Invalid FeedbackView");
+    if (f.escrow !== escrow2 || f.operator_id !== operatorId) continue;
+    if (f.revoked) {
+      revoked++;
+      continue;
+    }
+    count++;
+    raters.add(f.rater);
+    const amount = BigInt(f.released);
+    score += BigInt(f.score);
+    released += amount;
+    weighted += BigInt(f.score) * amount;
+  }
+  return {
+    count,
+    distinct_raters: raters.size,
+    revoked,
+    released_total: released.toString(),
+    average_x100: count ? Number(score * 100n / BigInt(count)) : null,
+    weighted_average_x100: released ? Number(weighted * 100n / released) : null
+  };
+}
+function safeLink(uri) {
+  return validUri(uri) && /^(https|ipfs|ar):/i.test(uri) ? uri : null;
+}
+function displayText(s) {
+  return s.replace(/[\p{Cc}\p{Cf}\p{Cs}\p{Default_Ignorable_Code_Point}]/gu, "");
+}
 
 // src/providers/near/index.ts
 var NEAR_CONFIG = {
@@ -1806,7 +2296,7 @@ function serializeSignedDelegateAction(delegateActionBytes, signatureBytes) {
   ser.writeFixedBytes(signatureBytes);
   return ser.getBytes();
 }
-async function sha2563(data) {
+async function sha2564(data) {
   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
   return new Uint8Array(hashBuffer);
 }
@@ -2050,7 +2540,7 @@ var NEARProvider = class {
       const hashInput = new Uint8Array(NEP366_PREFIX.length + delegateActionBytes.length);
       hashInput.set(NEP366_PREFIX, 0);
       hashInput.set(delegateActionBytes, NEP366_PREFIX.length);
-      const delegateHash = await sha2563(hashInput);
+      const delegateHash = await sha2564(hashInput);
       const signature = await this.signMessage(delegateHash);
       const signedDelegateActionBytes = serializeSignedDelegateAction(
         delegateActionBytes,
@@ -2258,30 +2748,59 @@ var NEARProvider = class {
 };
 var near_default = NEARProvider;
 
+exports.FEEDBACK_DEPOSIT = FEEDBACK_DEPOSIT;
+exports.GIVE_FEEDBACK_GAS = GIVE_FEEDBACK_GAS;
+exports.MIN_GIVE_FEEDBACK_GAS = MIN_GIVE_FEEDBACK_GAS;
 exports.NEARProvider = NEARProvider;
 exports.NEAR_ARRAS_STORAGE_DEPOSIT = NEAR_ARRAS_STORAGE_DEPOSIT;
 exports.NEAR_ESCROW_CONTRACTS = NEAR_ESCROW_CONTRACTS;
 exports.NEAR_ESCROW_MAX_GAS = NEAR_ESCROW_MAX_GAS;
 exports.NEAR_ESCROW_MIN_GAS = NEAR_ESCROW_MIN_GAS;
 exports.NEAR_ESCROW_TOKENS = NEAR_ESCROW_TOKENS;
+exports.NEAR_REGISTRY_CONTRACTS = NEAR_REGISTRY_CONTRACTS;
+exports.NEAR_REGISTRY_ESCROWS = NEAR_REGISTRY_ESCROWS;
 exports.NEAR_USDC_STORAGE_DEPOSIT = NEAR_USDC_STORAGE_DEPOSIT;
+exports.REGISTER_DEPOSIT = REGISTER_DEPOSIT;
+exports.REGISTRY_GAS = REGISTRY_GAS;
+exports.RegistryErrorCode = RegistryErrorCode;
+exports.RegistryValidationError = RegistryValidationError;
 exports.buildArrasStorageDeposit = buildArrasStorageDeposit;
 exports.buildEscrowAuthorizationDelegate = buildEscrowAuthorizationDelegate;
 exports.buildEscrowMsg = buildEscrowMsg;
+exports.buildGiveFeedback = buildGiveFeedback;
+exports.buildRegistryRegister = buildRegistryRegister;
+exports.buildRegistryUpdate = buildRegistryUpdate;
+exports.buildRevokeFeedback = buildRevokeFeedback;
 exports.buildUsdcStorageDeposit = buildUsdcStorageDeposit;
 exports.computePaymentId = computePaymentId;
 exports.createNearLocalSigner = createNearLocalSigner;
 exports.default = near_default;
+exports.displayText = displayText;
+exports.getAgent = getAgent;
+exports.getConfig = getConfig;
+exports.getFeedback = getFeedback;
+exports.getFeedbackForPayment = getFeedbackForPayment;
+exports.getSummary = getSummary;
+exports.getSummaryByOperator = getSummaryByOperator;
+exports.isFeedbackPending = isFeedbackPending;
+exports.listAgents = listAgents;
+exports.listFeedback = listFeedback;
 exports.nep413Preimage = nep413Preimage;
 exports.parseArrasEvents = parseArrasEvents;
+exports.parseGiveFeedbackOutcome = parseGiveFeedbackOutcome;
+exports.parseRegistryEvents = parseRegistryEvents;
+exports.parseRegistryReceiptEvents = parseRegistryReceiptEvents;
 exports.paymentIdPreimage = paymentIdPreimage;
 exports.reclaim = reclaim;
 exports.refund = refund;
 exports.release = release;
+exports.safeLink = safeLink;
 exports.signEscrowAuthorization = signEscrowAuthorization;
 exports.signEscrowLifecycle = signEscrowLifecycle;
 exports.signExactNearDelegate = signExactNearDelegate;
 exports.signNep413 = signNep413;
+exports.signRegistryTransaction = signRegistryTransaction;
+exports.summarizeFeedback = summarizeFeedback;
 exports.validateEscrowAuthorizationDelegate = validateEscrowAuthorizationDelegate;
 exports.withdraw = withdraw;
 exports.withdrawFor = withdrawFor;