prova-agent-kit 0.1.0

package/LICENSE

@@ -0,0 +1,58 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached with the work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   Copyright 2026 Prova Contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,79 @@
+# prova-agent-kit
+
+**Prova adapter for [Solana Agent Kit](https://github.com/sendaifun/solana-agent-kit) (v2).**
+Add **verifiable on-chain receipts** to any SAK agent — in one line. Every action your agent executes gets sealed as an immutable Prova attestation.
+
+> Status: **proof of concept** (Devnet). Designed against `solana-agent-kit@^2.0.0`.
+
+## Install
+
+```bash
+npm install prova-agent-kit prova-agent-sdk solana-agent-kit
+```
+
+## Quick start
+
+```typescript
+import { SolanaAgentKit } from 'solana-agent-kit';
+import { ProvaClient } from 'prova-agent-sdk';
+import { attachProva, attesterFromProvaClient } from 'prova-agent-kit';
+import { Keypair } from '@solana/web3.js';
+
+// 1) Tu agente normal de Solana Agent Kit
+const agent = new SolanaAgentKit(wallet, RPC_URL, {})
+  .use(TokenPlugin)
+  .use(DefiPlugin);
+
+// 2) Cliente Prova + operador (keypair propio de Devnet, NO el wallet de trading)
+const prova = new ProvaClient({ rpcUrl: 'https://api.devnet.solana.com', agentKeypair });
+const operatorKeypair = Keypair.fromSecretKey(/* ... */);
+const attester = attesterFromProvaClient(prova, ProvaClient.hashAction, operatorKeypair);
+
+// 3) Una línea: atesta cada acción del agente. Llamar DESPUÉS de todos los .use()
+const prova_handle = attachProva(agent, { attester });
+
+// ... el agente opera normal; las acciones se atestan en segundo plano ...
+
+await prova_handle.stop(); // flush final al cerrar
+```
+
+## Cómo funciona
+
+Solana Agent Kit v2 no expone hooks/middleware, así que el adapter ofrece dos puntos de captura (úsalos juntos para cobertura total):
+
+- **`attachProva(agent, opts)`** — envuelve `agent.actions[].handler`. Captura **nombre + input + output** de cada acción (incluidas las de solo lectura). Mecanismo principal.
+- **`new ProvaWallet(wallet, opts)`** — decorador de `BaseWallet`. Captura la **firma on-chain real** de cada transacción, sin importar el plugin. Cinturón de seguridad.
+
+```typescript
+import { ProvaWallet } from 'prova-agent-kit';
+const agent = new SolanaAgentKit(new ProvaWallet(realWallet, { attester }), RPC_URL, {});
+```
+
+### No bloquea al agente
+Las atestaciones son **fire-and-forget con batching**: un fallo de Prova nunca rompe ni frena una acción del agente. Los items se acumulan y se envían con `batchAttest` (hasta 100/tx) cada `maxSize` items o `flushIntervalMs` ms.
+
+```typescript
+attachProva(agent, {
+  attester,
+  rules: (name) => name !== 'fetchPrice',      // qué acciones atestar (default: todas)
+  batch: { maxSize: 25, flushIntervalMs: 10_000 },
+  onError: (err, ctx) => logger.warn(ctx.action, err),
+});
+```
+
+## Modelo de claves
+Prova atesta con **su propio par operador/agente de Devnet**, independiente del wallet de trading del agente. Ventajas: no necesita la private key de trading, funciona con wallets Privy/Turnkey, y el operador Prova es la identidad que avala al agente. Registra el agente una vez con `prova.registerAgent({ operatorKeypair })`.
+
+## API
+- `attachProva(agent, options) → ProvaHandle` · `{ flush(), stop() }`
+- `ProvaWallet(inner, options)` implements SAK `BaseWallet`
+- `attesterFromProvaClient(client, hashAction, operatorKeypair) → ProvaAttester`
+- `createBatcher(attester, options, onError) → Batcher` (interno, exportado para tests)
+- `buildPayload`, `mapActionType`, `extractSignature` (puros)
+
+## Caveats
+- **Orden:** llama `attachProva` **después** de todos los `.use(plugin)`; las acciones añadidas después no quedan envueltas. El `ProvaWallet` no depende del orden.
+- **Tipos:** el adapter usa tipos estructurales de SAK v2 (no importa `solana-agent-kit`). Verifica compatibilidad al fijar versión.
+
+## License
+Apache-2.0 · Prova Labs

package/dist/adapter.d.ts

@@ -0,0 +1,29 @@
+import type { ProvaActionType, ProvaAttester } from './types';
+/** Forma estructural del `ProvaClient` que necesitamos (de prova-agent-sdk). */
+export interface ProvaClientLike {
+    attest(args: {
+        operatorKeypair: unknown;
+        actionHash: Uint8Array;
+        actionType: ProvaActionType;
+    }): Promise<{
+        txSignature: string;
+    }>;
+    batchAttest(args: {
+        operatorKeypair: unknown;
+        attestations: Array<{
+            actionHash: Uint8Array;
+            actionType: ProvaActionType;
+        }>;
+    }): Promise<{
+        txSignature: string;
+    }>;
+}
+/**
+ * Construye un `ProvaAttester` a partir de un `ProvaClient` real, la función
+ * estática `ProvaClient.hashAction` y la keypair operadora de Prova.
+ *
+ * @example
+ * const attester = attesterFromProvaClient(prova, ProvaClient.hashAction, operatorKeypair);
+ */
+export declare function attesterFromProvaClient(client: ProvaClientLike, hashAction: (payload: string) => Promise<Uint8Array>, operatorKeypair: unknown): ProvaAttester;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAmB,eAAe,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE/E,gFAAgF;AAChF,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,IAAI,EAAE;QACX,eAAe,EAAE,OAAO,CAAC;QACzB,UAAU,EAAE,UAAU,CAAC;QACvB,UAAU,EAAE,eAAe,CAAC;KAC7B,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrC,WAAW,CAAC,IAAI,EAAE;QAChB,eAAe,EAAE,OAAO,CAAC;QACzB,YAAY,EAAE,KAAK,CAAC;YAAE,UAAU,EAAE,UAAU,CAAC;YAAC,UAAU,EAAE,eAAe,CAAA;SAAE,CAAC,CAAC;KAC9E,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtC;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC,EACpD,eAAe,EAAE,OAAO,GACvB,aAAa,CAYf"}

package/dist/adapter.js

@@ -0,0 +1,21 @@
+// Puente entre el `ProvaClient` real (prova-agent-sdk) y la interfaz
+// `ProvaAttester` que usa el adapter. Tipado estructural → no importamos el SDK.
+/**
+ * Construye un `ProvaAttester` a partir de un `ProvaClient` real, la función
+ * estática `ProvaClient.hashAction` y la keypair operadora de Prova.
+ *
+ * @example
+ * const attester = attesterFromProvaClient(prova, ProvaClient.hashAction, operatorKeypair);
+ */
+export function attesterFromProvaClient(client, hashAction, operatorKeypair) {
+    return {
+        hashAction,
+        attest: (item) => client.attest({
+            operatorKeypair,
+            actionHash: item.actionHash,
+            actionType: item.actionType,
+        }),
+        batchAttest: (items) => client.batchAttest({ operatorKeypair, attestations: items }),
+    };
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,iFAAiF;AAiBjF;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,MAAuB,EACvB,UAAoD,EACpD,eAAwB;IAExB,OAAO;QACL,UAAU;QACV,MAAM,EAAE,CAAC,IAAqB,EAAE,EAAE,CAChC,MAAM,CAAC,MAAM,CAAC;YACZ,eAAe;YACf,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC;QACJ,WAAW,EAAE,CAAC,KAAwB,EAAE,EAAE,CACxC,MAAM,CAAC,WAAW,CAAC,EAAE,eAAe,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;KAC/D,CAAC;AACJ,CAAC"}

package/dist/attach.d.ts

@@ -0,0 +1,9 @@
+import type { AttachProvaOptions, HostAgent } from './types';
+export interface ProvaHandle {
+    /** Fuerza el envío de las atestaciones pendientes. */
+    flush(): Promise<void>;
+    /** Detiene el batcher y hace un flush final (llamar al cerrar el agente). */
+    stop(): Promise<void>;
+}
+export declare function attachProva(agent: HostAgent, options: AttachProvaOptions): ProvaHandle;
+//# sourceMappingURL=attach.d.ts.map

package/dist/attach.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../src/attach.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAc,SAAS,EAAiB,MAAM,SAAS,CAAC;AAKxF,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,6EAA6E;IAC7E,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAgCtF"}

package/dist/attach.js

@@ -0,0 +1,37 @@
+// Enfoque B: envuelve los handlers de las acciones del agente para atestar cada
+// ejecución en Prova. Es el mecanismo principal de captura (semántica rica:
+// nombre + input + output). Llamar DESPUÉS de registrar todos los plugins.
+import { buildPayload, mapActionType } from './payload';
+import { createBatcher } from './batcher';
+import { warn } from './runtime';
+export function attachProva(agent, options) {
+    const { attester } = options;
+    const should = options.rules ?? (() => true);
+    const onError = options.onError ??
+        ((error, context) => warn(`[Prova] attest failed for "${context.action}":`, error));
+    const batcher = createBatcher(attester, options.batch, (error) => onError(error, { action: 'batch' }));
+    agent.actions = agent.actions.map((action) => {
+        if (!should(action.name))
+            return action;
+        const original = action.handler;
+        return {
+            ...action,
+            handler: async (a, input) => {
+                const result = await original(a, input);
+                // Atestación NO bloqueante: un fallo de Prova jamás rompe la acción.
+                void captureAction(attester, batcher, action.name, input, result).catch((error) => onError(error, { action: action.name }));
+                return result;
+            },
+        };
+    });
+    return {
+        flush: () => batcher.flush(),
+        stop: () => batcher.stop(),
+    };
+}
+async function captureAction(attester, batcher, name, input, result) {
+    const payload = buildPayload(name, input, result);
+    const actionHash = await attester.hashAction(JSON.stringify(payload));
+    batcher.add({ actionHash, actionType: mapActionType(name, result) });
+}
+//# sourceMappingURL=attach.js.map

package/dist/attach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attach.js","sourceRoot":"","sources":["../src/attach.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,4EAA4E;AAC5E,2EAA2E;AAG3E,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,aAAa,EAAgB,MAAM,WAAW,CAAC;AACxD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AASjC,MAAM,UAAU,WAAW,CAAC,KAAgB,EAAE,OAA2B;IACvE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAC7B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,OAAO,GACX,OAAO,CAAC,OAAO;QACf,CAAC,CAAC,KAAc,EAAE,OAA2B,EAAE,EAAE,CAC/C,IAAI,CAAC,8BAA8B,OAAO,CAAC,MAAM,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;IAEnE,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAC/D,OAAO,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CACpC,CAAC;IAEF,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAkB,EAAc,EAAE;QACnE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,OAAO,MAAM,CAAC;QACxC,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC;QAChC,OAAO;YACL,GAAG,MAAM;YACT,OAAO,EAAE,KAAK,EAAE,CAAU,EAAE,KAA8B,EAAE,EAAE;gBAC5D,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBACxC,qEAAqE;gBACrE,KAAK,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAChF,OAAO,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CACxC,CAAC;gBACF,OAAO,MAAM,CAAC;YAChB,CAAC;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE;QAC5B,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE;KAC3B,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,aAAa,CAC1B,QAAuB,EACvB,OAAgB,EAChB,IAAY,EACZ,KAA8B,EAC9B,MAA+B;IAE/B,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAClD,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IACtE,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;AACvE,CAAC"}

package/dist/batcher.d.ts

@@ -0,0 +1,11 @@
+import type { AttestationItem, BatchOptions, ProvaAttester } from './types';
+export interface Batcher {
+    /** Encola una atestación; dispara flush si se alcanza maxSize. */
+    add(item: AttestationItem): void;
+    /** Envía inmediatamente lo pendiente. */
+    flush(): Promise<void>;
+    /** Detiene el timer y hace un último flush. */
+    stop(): Promise<void>;
+}
+export declare function createBatcher(attester: ProvaAttester, options?: BatchOptions, onError?: (error: unknown) => void): Batcher;
+//# sourceMappingURL=batcher.d.ts.map

package/dist/batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../src/batcher.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG5E,MAAM,WAAW,OAAO;IACtB,kEAAkE;IAClE,GAAG,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,yCAAyC;IACzC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,+CAA+C;IAC/C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAMD,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,YAAiB,EAC1B,OAAO,GAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAqD,GACjF,OAAO,CA2CT"}

package/dist/batcher.js

@@ -0,0 +1,52 @@
+// Buffer de atestaciones: acumula items y los envía en lote (batchAttest) cada
+// N items o cada T ms, lo que ocurra primero. Aísla la latencia/coste de Solana
+// del hot-path del agente.
+import { clearIntervalSafe, setIntervalSafe, warn } from './runtime';
+const DEFAULT_MAX_SIZE = 25;
+const DEFAULT_INTERVAL_MS = 10_000;
+const HARD_BATCH_LIMIT = 100;
+export function createBatcher(attester, options = {}, onError = (error) => warn('[Prova] batch error:', error)) {
+    const maxSize = Math.min(Math.max(options.maxSize ?? DEFAULT_MAX_SIZE, 1), HARD_BATCH_LIMIT);
+    const intervalMs = options.flushIntervalMs ?? DEFAULT_INTERVAL_MS;
+    let buffer = [];
+    let timer;
+    async function flush() {
+        if (buffer.length === 0)
+            return;
+        const batch = buffer;
+        buffer = [];
+        try {
+            if (batch.length === 1) {
+                await attester.attest(batch[0]);
+            }
+            else {
+                await attester.batchAttest(batch);
+            }
+        }
+        catch (error) {
+            onError(error);
+        }
+    }
+    function ensureTimer() {
+        if (intervalMs > 0 && timer === undefined) {
+            timer = setIntervalSafe(() => void flush(), intervalMs);
+        }
+    }
+    return {
+        add(item) {
+            buffer.push(item);
+            ensureTimer();
+            if (buffer.length >= maxSize)
+                void flush();
+        },
+        flush,
+        async stop() {
+            if (timer !== undefined) {
+                clearIntervalSafe(timer);
+                timer = undefined;
+            }
+            await flush();
+        },
+    };
+}
+//# sourceMappingURL=batcher.js.map

package/dist/batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batcher.js","sourceRoot":"","sources":["../src/batcher.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,gFAAgF;AAChF,2BAA2B;AAG3B,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,IAAI,EAAgB,MAAM,WAAW,CAAC;AAWnF,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAC5B,MAAM,mBAAmB,GAAG,MAAM,CAAC;AACnC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAE7B,MAAM,UAAU,aAAa,CAC3B,QAAuB,EACvB,UAAwB,EAAE,EAC1B,UAAoC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,sBAAsB,EAAE,KAAK,CAAC;IAElF,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,gBAAgB,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IAC7F,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,IAAI,mBAAmB,CAAC;IAElE,IAAI,MAAM,GAAsB,EAAE,CAAC;IACnC,IAAI,KAA0B,CAAC;IAE/B,KAAK,UAAU,KAAK;QAClB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAChC,MAAM,KAAK,GAAG,MAAM,CAAC;QACrB,MAAM,GAAG,EAAE,CAAC;QACZ,IAAI,CAAC;YACH,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACvB,MAAM,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC;YACnC,CAAC;iBAAM,CAAC;gBACN,MAAM,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,CAAC;QACjB,CAAC;IACH,CAAC;IAED,SAAS,WAAW;QAClB,IAAI,UAAU,GAAG,CAAC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,KAAK,GAAG,eAAe,CAAC,GAAG,EAAE,CAAC,KAAK,KAAK,EAAE,EAAE,UAAU,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,OAAO;QACL,GAAG,CAAC,IAAqB;YACvB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClB,WAAW,EAAE,CAAC;YACd,IAAI,MAAM,CAAC,MAAM,IAAI,OAAO;gBAAE,KAAK,KAAK,EAAE,CAAC;QAC7C,CAAC;QACD,KAAK;QACL,KAAK,CAAC,IAAI;YACR,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,iBAAiB,CAAC,KAAK,CAAC,CAAC;gBACzB,KAAK,GAAG,SAAS,CAAC;YACpB,CAAC;YACD,MAAM,KAAK,EAAE,CAAC;QAChB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { attachProva } from './attach';
+export type { ProvaHandle } from './attach';
+export { ProvaWallet } from './wallet';
+export type { ProvaWalletOptions } from './wallet';
+export { attesterFromProvaClient } from './adapter';
+export type { ProvaClientLike } from './adapter';
+export { createBatcher } from './batcher';
+export type { Batcher } from './batcher';
+export { buildPayload, mapActionType, extractSignature } from './payload';
+export type { HostAgent, HostAction, HostWallet, ProvaAttester, AttestationItem, ProvaActionType, AttachProvaOptions, BatchOptions, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE1E,YAAY,EACV,SAAS,EACT,UAAU,EACV,UAAU,EACV,aAAa,EACb,eAAe,EACf,eAAe,EACf,kBAAkB,EAClB,YAAY,GACb,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// API pública del adapter Prova ↔ Solana Agent Kit.
+export { attachProva } from './attach';
+export { ProvaWallet } from './wallet';
+export { attesterFromProvaClient } from './adapter';
+export { createBatcher } from './batcher';
+export { buildPayload, mapActionType, extractSignature } from './payload';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,oDAAoD;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAGvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAGpD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/payload.d.ts

@@ -0,0 +1,8 @@
+import type { ActionResult, ProvaActionType } from './types';
+/** Extrae la firma on-chain del result de una acción, si está presente. */
+export declare function extractSignature(result: ActionResult): string | undefined;
+/** Mapea el nombre de una acción de SAK al `ActionType` de Prova. */
+export declare function mapActionType(actionName: string, result: ActionResult): ProvaActionType;
+/** Construye el objeto que se serializa y hashea para producir el action_hash. */
+export declare function buildPayload(actionName: string, input: Record<string, unknown>, result: ActionResult): Record<string, unknown>;
+//# sourceMappingURL=payload.d.ts.map

package/dist/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../src/payload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK7D,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAMzE;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,eAAe,CAIvF;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,EAAE,YAAY,GACnB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB"}

package/dist/payload.js

@@ -0,0 +1,30 @@
+// Funciones puras: derivan el payload y el tipo de atestación a partir de la
+// acción de SAK y su resultado. Sin efectos secundarios → fáciles de testear.
+const SIGNATURE_KEYS = ['signature', 'txSignature', 'txid', 'tx'];
+const DECISION_PATTERN = /decision|choose|select|rebalance|hold|exit|approve|reject/i;
+/** Extrae la firma on-chain del result de una acción, si está presente. */
+export function extractSignature(result) {
+    for (const key of SIGNATURE_KEYS) {
+        const value = result[key];
+        if (typeof value === 'string' && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+/** Mapea el nombre de una acción de SAK al `ActionType` de Prova. */
+export function mapActionType(actionName, result) {
+    if (extractSignature(result))
+        return 'Transaction';
+    if (DECISION_PATTERN.test(actionName))
+        return 'Decision';
+    return 'ToolCall';
+}
+/** Construye el objeto que se serializa y hashea para producir el action_hash. */
+export function buildPayload(actionName, input, result) {
+    const signature = extractSignature(result);
+    if (signature) {
+        return { kind: 'transaction', action: actionName, signature, input };
+    }
+    return { kind: 'toolCall', action: actionName, input, result };
+}
+//# sourceMappingURL=payload.js.map

package/dist/payload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.js","sourceRoot":"","sources":["../src/payload.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,8EAA8E;AAI9E,MAAM,cAAc,GAAG,CAAC,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,CAAU,CAAC;AAC3E,MAAM,gBAAgB,GAAG,4DAA4D,CAAC;AAEtF,2EAA2E;AAC3E,MAAM,UAAU,gBAAgB,CAAC,MAAoB;IACnD,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC;IAClE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,aAAa,CAAC,UAAkB,EAAE,MAAoB;IACpE,IAAI,gBAAgB,CAAC,MAAM,CAAC;QAAE,OAAO,aAAa,CAAC;IACnD,IAAI,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC;QAAE,OAAO,UAAU,CAAC;IACzD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,YAAY,CAC1B,UAAkB,EAClB,KAA8B,EAC9B,MAAoB;IAEpB,MAAM,SAAS,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC3C,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IACvE,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AACjE,CAAC"}

package/dist/runtime.d.ts

@@ -0,0 +1,9 @@
+/** Identificador opaco de un timer (number en navegador, objeto en Node). */
+export type TimerId = number | {
+    readonly __timer?: unique symbol;
+};
+/** setInterval que no bloquea la salida del proceso (unref en Node si existe). */
+export declare function setIntervalSafe(handler: () => void, ms: number): TimerId;
+export declare function clearIntervalSafe(id: TimerId): void;
+export declare function warn(...args: unknown[]): void;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAIA,6EAA6E;AAC7E,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,MAAM,CAAA;CAAE,CAAC;AAUpE,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAKxE;AAED,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAEnD;AAED,wBAAgB,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAE7C"}

package/dist/runtime.js

@@ -0,0 +1,19 @@
+// Acceso tipado a globales de runtime (timers, console) sin depender de
+// @types/node ni de los tipos del DOM. En ejecución real los provee Node o el
+// navegador; aquí los declaramos mínimamente para mantener el adapter ligero.
+const runtime = globalThis;
+/** setInterval que no bloquea la salida del proceso (unref en Node si existe). */
+export function setIntervalSafe(handler, ms) {
+    const id = runtime.setInterval(handler, ms);
+    const maybe = id;
+    if (typeof maybe.unref === 'function')
+        maybe.unref();
+    return id;
+}
+export function clearIntervalSafe(id) {
+    runtime.clearInterval(id);
+}
+export function warn(...args) {
+    runtime.console.warn(...args);
+}
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,8EAA8E;AAC9E,8EAA8E;AAW9E,MAAM,OAAO,GAAG,UAAuC,CAAC;AAExD,kFAAkF;AAClF,MAAM,UAAU,eAAe,CAAC,OAAmB,EAAE,EAAU;IAC7D,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,EAAuC,CAAC;IACtD,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU;QAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IACrD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,EAAW;IAC3C,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,GAAG,IAAe;IACrC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,66 @@
+/** Resultado típico del handler de una acción de SAK. */
+export type ActionResult = Record<string, unknown>;
+/** Acción de Solana Agent Kit (subconjunto que el adapter necesita). */
+export interface HostAction {
+    name: string;
+    handler: (agent: unknown, input: Record<string, unknown>) => Promise<ActionResult>;
+    [key: string]: unknown;
+}
+/** Agente de Solana Agent Kit (subconjunto que el adapter necesita). */
+export interface HostAgent {
+    actions: HostAction[];
+    [key: string]: unknown;
+}
+/** BaseWallet de Solana Agent Kit v2, en forma estructural. */
+export interface HostWallet {
+    readonly publicKey: {
+        toBase58(): string;
+    };
+    signTransaction<T>(transaction: T): Promise<T>;
+    signAllTransactions<T>(transactions: T[]): Promise<T[]>;
+    signAndSendTransaction<T>(transaction: T, options?: unknown): Promise<{
+        signature: string;
+    }>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+/** Tipos de acción soportados por Prova (espejo de `ActionType` del SDK). */
+export type ProvaActionType = 'Transaction' | 'ToolCall' | 'ModelInvocation' | 'Decision' | 'ResourceAccess' | 'PolicyCheck' | 'Custom';
+/** Una atestación lista para enviar (action_hash de 32 bytes + tipo). */
+export interface AttestationItem {
+    actionHash: Uint8Array;
+    actionType: ProvaActionType;
+}
+/**
+ * Superficie mínima que el adapter necesita de Prova, inyectada por el
+ * integrador. Permite usar el `ProvaClient` real sin acoplarnos a su tipo.
+ */
+export interface ProvaAttester {
+    hashAction(payload: string): Promise<Uint8Array>;
+    attest(item: AttestationItem): Promise<{
+        txSignature: string;
+    }>;
+    batchAttest(items: AttestationItem[]): Promise<{
+        txSignature: string;
+    }>;
+}
+/** Configuración del batching de atestaciones. */
+export interface BatchOptions {
+    /** Nº máximo de atestaciones por transacción (1–100). Default 25. */
+    maxSize?: number;
+    /** Flush automático cada N ms. Default 10000. 0 = sin flush por tiempo. */
+    flushIntervalMs?: number;
+}
+/** Opciones de `attachProva`. */
+export interface AttachProvaOptions {
+    /** Puente hacia Prova (ver `attesterFromProvaClient`). */
+    attester: ProvaAttester;
+    /** Filtra qué acciones atestar por nombre (default: todas). */
+    rules?: (actionName: string) => boolean;
+    /** Configuración de batching. */
+    batch?: BatchOptions;
+    /** Manejo de errores (default: warn por consola). Nunca rompe la acción. */
+    onError?: (error: unknown, context: {
+        action: string;
+    }) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAKA,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEnD,wEAAwE;AACxE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IACnF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wEAAwE;AACxE,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC;IAC3C,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC/C,mBAAmB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACxD,sBAAsB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7F,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACvD;AAED,6EAA6E;AAC7E,MAAM,MAAM,eAAe,GACvB,aAAa,GACb,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,gBAAgB,GAChB,aAAa,GACb,QAAQ,CAAC;AAEb,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChE,WAAW,CAAC,KAAK,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACzE;AAED,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,iCAAiC;AACjC,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,QAAQ,EAAE,aAAa,CAAC;IACxB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,iCAAiC;IACjC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CACjE"}

package/dist/types.js

@@ -0,0 +1,6 @@
+// Tipos del adapter. Reflejamos estructuralmente la API pública de Solana Agent
+// Kit v2 (BaseWallet, Action, SolanaAgentKit) para NO importar el paquete y
+// mantener el adapter como peerDependency ligera. La compatibilidad se apoya en
+// el tipado estructural de TypeScript.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,4EAA4E;AAC5E,gFAAgF;AAChF,uCAAuC"}

package/dist/wallet.d.ts

@@ -0,0 +1,27 @@
+import type { BatchOptions, HostWallet, ProvaAttester } from './types';
+export interface ProvaWalletOptions {
+    attester: ProvaAttester;
+    batch?: BatchOptions;
+    onError?: (error: unknown) => void;
+}
+export declare class ProvaWallet implements HostWallet {
+    private readonly inner;
+    private readonly attester;
+    private readonly batcher;
+    constructor(inner: HostWallet, options: ProvaWalletOptions);
+    get publicKey(): {
+        toBase58(): string;
+    };
+    signTransaction<T>(transaction: T): Promise<T>;
+    signAllTransactions<T>(transactions: T[]): Promise<T[]>;
+    signMessage(message: Uint8Array): Promise<Uint8Array>;
+    signAndSendTransaction<T>(transaction: T, options?: unknown): Promise<{
+        signature: string;
+    }>;
+    /** Fuerza el envío de las atestaciones pendientes. */
+    flush(): Promise<void>;
+    /** Detiene el batcher y hace un flush final. */
+    stop(): Promise<void>;
+    private captureSignature;
+}
+//# sourceMappingURL=wallet.d.ts.map

package/dist/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGvE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED,qBAAa,WAAY,YAAW,UAAU;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,kBAAkB;IAM1D,IAAI,SAAS,IAAI;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAEtC;IAED,eAAe,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAI9C,mBAAmB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIvD,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAI/C,sBAAsB,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAOlG,sDAAsD;IACtD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,gDAAgD;IAChD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAIP,gBAAgB;CAK/B"}

package/dist/wallet.js

@@ -0,0 +1,46 @@
+// Enfoque A: decorador de BaseWallet (SAK v2). Captura la firma on-chain real
+// de cada transacción firmada/enviada, sin importar qué plugin la produjo. Es
+// el "cinturón de seguridad" que complementa a `attachProva`.
+import { createBatcher } from './batcher';
+export class ProvaWallet {
+    inner;
+    attester;
+    batcher;
+    constructor(inner, options) {
+        this.inner = inner;
+        this.attester = options.attester;
+        this.batcher = createBatcher(options.attester, options.batch, options.onError);
+    }
+    get publicKey() {
+        return this.inner.publicKey;
+    }
+    signTransaction(transaction) {
+        return this.inner.signTransaction(transaction);
+    }
+    signAllTransactions(transactions) {
+        return this.inner.signAllTransactions(transactions);
+    }
+    signMessage(message) {
+        return this.inner.signMessage(message);
+    }
+    async signAndSendTransaction(transaction, options) {
+        const result = await this.inner.signAndSendTransaction(transaction, options);
+        // Atestación NO bloqueante de la firma on-chain real.
+        void this.captureSignature(result.signature).catch(() => { });
+        return result;
+    }
+    /** Fuerza el envío de las atestaciones pendientes. */
+    flush() {
+        return this.batcher.flush();
+    }
+    /** Detiene el batcher y hace un flush final. */
+    stop() {
+        return this.batcher.stop();
+    }
+    async captureSignature(signature) {
+        const payload = { kind: 'transaction', signature, source: 'wallet' };
+        const actionHash = await this.attester.hashAction(JSON.stringify(payload));
+        this.batcher.add({ actionHash, actionType: 'Transaction' });
+    }
+}
+//# sourceMappingURL=wallet.js.map

package/dist/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,8EAA8E;AAC9E,8DAA8D;AAG9D,OAAO,EAAE,aAAa,EAAgB,MAAM,WAAW,CAAC;AAQxD,MAAM,OAAO,WAAW;IACL,KAAK,CAAa;IAClB,QAAQ,CAAgB;IACxB,OAAO,CAAU;IAElC,YAAY,KAAiB,EAAE,OAA2B;QACxD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACjF,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;IAC9B,CAAC;IAED,eAAe,CAAI,WAAc;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;IACjD,CAAC;IAED,mBAAmB,CAAI,YAAiB;QACtC,OAAO,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;IACtD,CAAC;IAED,WAAW,CAAC,OAAmB;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,KAAK,CAAC,sBAAsB,CAAI,WAAc,EAAE,OAAiB;QAC/D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;QAC7E,sDAAsD;QACtD,KAAK,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,sDAAsD;IACtD,KAAK;QACH,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED,gDAAgD;IAChD,IAAI;QACF,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,SAAiB;QAC9C,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACrE,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3E,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;IAC9D,CAAC;CACF"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "prova-agent-kit",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "author": "Prova Labs",
+  "description": "Prova adapter for Solana Agent Kit — emit verifiable on-chain receipts for every action a SAK agent executes",
+  "homepage": "https://prova-solana.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Eras256/Prova.git",
+    "directory": "packages/sdk-agent-kit"
+  },
+  "keywords": [
+    "solana",
+    "solana-agent-kit",
+    "ai-agents",
+    "attestation",
+    "prova",
+    "accountability"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@solana/web3.js": "^1.98.0",
+    "prova-agent-sdk": "^0.1.6",
+    "solana-agent-kit": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@solana/web3.js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8",
+    "@prova/config-typescript": "0.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rimraf dist"
+  }
+}

package/src/adapter.ts

@@ -0,0 +1,42 @@
+// Puente entre el `ProvaClient` real (prova-agent-sdk) y la interfaz
+// `ProvaAttester` que usa el adapter. Tipado estructural → no importamos el SDK.
+
+import type { AttestationItem, ProvaActionType, ProvaAttester } from './types';
+
+/** Forma estructural del `ProvaClient` que necesitamos (de prova-agent-sdk). */
+export interface ProvaClientLike {
+  attest(args: {
+    operatorKeypair: unknown;
+    actionHash: Uint8Array;
+    actionType: ProvaActionType;
+  }): Promise<{ txSignature: string }>;
+  batchAttest(args: {
+    operatorKeypair: unknown;
+    attestations: Array<{ actionHash: Uint8Array; actionType: ProvaActionType }>;
+  }): Promise<{ txSignature: string }>;
+}
+
+/**
+ * Construye un `ProvaAttester` a partir de un `ProvaClient` real, la función
+ * estática `ProvaClient.hashAction` y la keypair operadora de Prova.
+ *
+ * @example
+ * const attester = attesterFromProvaClient(prova, ProvaClient.hashAction, operatorKeypair);
+ */
+export function attesterFromProvaClient(
+  client: ProvaClientLike,
+  hashAction: (payload: string) => Promise<Uint8Array>,
+  operatorKeypair: unknown,
+): ProvaAttester {
+  return {
+    hashAction,
+    attest: (item: AttestationItem) =>
+      client.attest({
+        operatorKeypair,
+        actionHash: item.actionHash,
+        actionType: item.actionType,
+      }),
+    batchAttest: (items: AttestationItem[]) =>
+      client.batchAttest({ operatorKeypair, attestations: items }),
+  };
+}

package/src/attach.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+import { attachProva } from './attach';
+import type { AttestationItem, HostAgent, ProvaAttester } from './types';
+
+function fakeAttester(): ProvaAttester & { items: AttestationItem[] } {
+  const items: AttestationItem[] = [];
+  return {
+    items,
+    hashAction: async () => new Uint8Array(32),
+    attest: async (item) => {
+      items.push(item);
+      return { txSignature: 'tx' };
+    },
+    batchAttest: async (batch) => {
+      items.push(...batch);
+      return { txSignature: 'tx' };
+    },
+  };
+}
+
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+describe('attachProva', () => {
+  it('runs the original action and attests its result', async () => {
+    const attester = fakeAttester();
+    const agent: HostAgent = {
+      actions: [{ name: 'trade', handler: async () => ({ signature: 'sig123' }) }],
+    };
+
+    const handle = attachProva(agent, {
+      attester,
+      batch: { maxSize: 1, flushIntervalMs: 0 },
+    });
+
+    const result = await agent.actions[0]!.handler(agent, { amount: 10 });
+    expect(result).toEqual({ signature: 'sig123' });
+
+    await tick();
+    await handle.flush();
+
+    expect(attester.items).toHaveLength(1);
+    expect(attester.items[0]!.actionType).toBe('Transaction');
+  });
+
+  it('never breaks the action when attestation fails', async () => {
+    const attester: ProvaAttester = {
+      hashAction: async () => {
+        throw new Error('boom');
+      },
+      attest: async () => ({ txSignature: 'tx' }),
+      batchAttest: async () => ({ txSignature: 'tx' }),
+    };
+    const agent: HostAgent = {
+      actions: [{ name: 'x', handler: async () => ({ ok: true }) }],
+    };
+
+    attachProva(agent, { attester, onError: () => {} });
+
+    const result = await agent.actions[0]!.handler(agent, {});
+    expect(result).toEqual({ ok: true });
+  });
+
+  it('respects the rules filter', async () => {
+    const attester = fakeAttester();
+    const agent: HostAgent = {
+      actions: [
+        { name: 'trade', handler: async () => ({ signature: 's' }) },
+        { name: 'fetchPrice', handler: async () => ({ price: 1 }) },
+      ],
+    };
+
+    const handle = attachProva(agent, {
+      attester,
+      rules: (name) => name === 'trade',
+      batch: { maxSize: 1, flushIntervalMs: 0 },
+    });
+
+    await agent.actions[0]!.handler(agent, {});
+    await agent.actions[1]!.handler(agent, {});
+    await tick();
+    await handle.flush();
+
+    expect(attester.items).toHaveLength(1);
+  });
+});

package/src/attach.ts

@@ -0,0 +1,61 @@
+// Enfoque B: envuelve los handlers de las acciones del agente para atestar cada
+// ejecución en Prova. Es el mecanismo principal de captura (semántica rica:
+// nombre + input + output). Llamar DESPUÉS de registrar todos los plugins.
+
+import type { AttachProvaOptions, HostAction, HostAgent, ProvaAttester } from './types';
+import { buildPayload, mapActionType } from './payload';
+import { createBatcher, type Batcher } from './batcher';
+import { warn } from './runtime';
+
+export interface ProvaHandle {
+  /** Fuerza el envío de las atestaciones pendientes. */
+  flush(): Promise<void>;
+  /** Detiene el batcher y hace un flush final (llamar al cerrar el agente). */
+  stop(): Promise<void>;
+}
+
+export function attachProva(agent: HostAgent, options: AttachProvaOptions): ProvaHandle {
+  const { attester } = options;
+  const should = options.rules ?? (() => true);
+  const onError =
+    options.onError ??
+    ((error: unknown, context: { action: string }) =>
+      warn(`[Prova] attest failed for "${context.action}":`, error));
+
+  const batcher = createBatcher(attester, options.batch, (error) =>
+    onError(error, { action: 'batch' }),
+  );
+
+  agent.actions = agent.actions.map((action: HostAction): HostAction => {
+    if (!should(action.name)) return action;
+    const original = action.handler;
+    return {
+      ...action,
+      handler: async (a: unknown, input: Record<string, unknown>) => {
+        const result = await original(a, input);
+        // Atestación NO bloqueante: un fallo de Prova jamás rompe la acción.
+        void captureAction(attester, batcher, action.name, input, result).catch((error) =>
+          onError(error, { action: action.name }),
+        );
+        return result;
+      },
+    };
+  });
+
+  return {
+    flush: () => batcher.flush(),
+    stop: () => batcher.stop(),
+  };
+}
+
+async function captureAction(
+  attester: ProvaAttester,
+  batcher: Batcher,
+  name: string,
+  input: Record<string, unknown>,
+  result: Record<string, unknown>,
+): Promise<void> {
+  const payload = buildPayload(name, input, result);
+  const actionHash = await attester.hashAction(JSON.stringify(payload));
+  batcher.add({ actionHash, actionType: mapActionType(name, result) });
+}

package/src/batcher.ts

@@ -0,0 +1,68 @@
+// Buffer de atestaciones: acumula items y los envía en lote (batchAttest) cada
+// N items o cada T ms, lo que ocurra primero. Aísla la latencia/coste de Solana
+// del hot-path del agente.
+
+import type { AttestationItem, BatchOptions, ProvaAttester } from './types';
+import { clearIntervalSafe, setIntervalSafe, warn, type TimerId } from './runtime';
+
+export interface Batcher {
+  /** Encola una atestación; dispara flush si se alcanza maxSize. */
+  add(item: AttestationItem): void;
+  /** Envía inmediatamente lo pendiente. */
+  flush(): Promise<void>;
+  /** Detiene el timer y hace un último flush. */
+  stop(): Promise<void>;
+}
+
+const DEFAULT_MAX_SIZE = 25;
+const DEFAULT_INTERVAL_MS = 10_000;
+const HARD_BATCH_LIMIT = 100;
+
+export function createBatcher(
+  attester: ProvaAttester,
+  options: BatchOptions = {},
+  onError: (error: unknown) => void = (error) => warn('[Prova] batch error:', error),
+): Batcher {
+  const maxSize = Math.min(Math.max(options.maxSize ?? DEFAULT_MAX_SIZE, 1), HARD_BATCH_LIMIT);
+  const intervalMs = options.flushIntervalMs ?? DEFAULT_INTERVAL_MS;
+
+  let buffer: AttestationItem[] = [];
+  let timer: TimerId | undefined;
+
+  async function flush(): Promise<void> {
+    if (buffer.length === 0) return;
+    const batch = buffer;
+    buffer = [];
+    try {
+      if (batch.length === 1) {
+        await attester.attest(batch[0]!);
+      } else {
+        await attester.batchAttest(batch);
+      }
+    } catch (error) {
+      onError(error);
+    }
+  }
+
+  function ensureTimer(): void {
+    if (intervalMs > 0 && timer === undefined) {
+      timer = setIntervalSafe(() => void flush(), intervalMs);
+    }
+  }
+
+  return {
+    add(item: AttestationItem): void {
+      buffer.push(item);
+      ensureTimer();
+      if (buffer.length >= maxSize) void flush();
+    },
+    flush,
+    async stop(): Promise<void> {
+      if (timer !== undefined) {
+        clearIntervalSafe(timer);
+        timer = undefined;
+      }
+      await flush();
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+// API pública del adapter Prova ↔ Solana Agent Kit.
+
+export { attachProva } from './attach';
+export type { ProvaHandle } from './attach';
+
+export { ProvaWallet } from './wallet';
+export type { ProvaWalletOptions } from './wallet';
+
+export { attesterFromProvaClient } from './adapter';
+export type { ProvaClientLike } from './adapter';
+
+export { createBatcher } from './batcher';
+export type { Batcher } from './batcher';
+
+export { buildPayload, mapActionType, extractSignature } from './payload';
+
+export type {
+  HostAgent,
+  HostAction,
+  HostWallet,
+  ProvaAttester,
+  AttestationItem,
+  ProvaActionType,
+  AttachProvaOptions,
+  BatchOptions,
+} from './types';

package/src/payload.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { buildPayload, extractSignature, mapActionType } from './payload';
+
+describe('extractSignature', () => {
+  it('reads the signature from common SAK result shapes', () => {
+    expect(extractSignature({ signature: 'abc' })).toBe('abc');
+    expect(extractSignature({ txSignature: 'def' })).toBe('def');
+    expect(extractSignature({ txid: 'ghi' })).toBe('ghi');
+  });
+
+  it('returns undefined when there is no signature', () => {
+    expect(extractSignature({ foo: 1 })).toBeUndefined();
+    expect(extractSignature({ signature: '' })).toBeUndefined();
+  });
+});
+
+describe('mapActionType', () => {
+  it('classifies as Transaction when a signature is present', () => {
+    expect(mapActionType('trade', { signature: 'x' })).toBe('Transaction');
+  });
+
+  it('classifies decision-like actions', () => {
+    expect(mapActionType('rebalancePortfolio', {})).toBe('Decision');
+    expect(mapActionType('exitPosition', {})).toBe('Decision');
+  });
+
+  it('falls back to ToolCall', () => {
+    expect(mapActionType('fetchPrice', {})).toBe('ToolCall');
+  });
+});
+
+describe('buildPayload', () => {
+  it('builds a transaction payload when a signature is present', () => {
+    const payload = buildPayload('trade', { amount: 1 }, { signature: 'sig' });
+    expect(payload['kind']).toBe('transaction');
+    expect(payload['signature']).toBe('sig');
+  });
+
+  it('builds a toolCall payload otherwise', () => {
+    const payload = buildPayload('fetchPrice', { token: 'SOL' }, { price: 100 });
+    expect(payload['kind']).toBe('toolCall');
+  });
+});

package/src/payload.ts

@@ -0,0 +1,36 @@
+// Funciones puras: derivan el payload y el tipo de atestación a partir de la
+// acción de SAK y su resultado. Sin efectos secundarios → fáciles de testear.
+
+import type { ActionResult, ProvaActionType } from './types';
+
+const SIGNATURE_KEYS = ['signature', 'txSignature', 'txid', 'tx'] as const;
+const DECISION_PATTERN = /decision|choose|select|rebalance|hold|exit|approve|reject/i;
+
+/** Extrae la firma on-chain del result de una acción, si está presente. */
+export function extractSignature(result: ActionResult): string | undefined {
+  for (const key of SIGNATURE_KEYS) {
+    const value = result[key];
+    if (typeof value === 'string' && value.length > 0) return value;
+  }
+  return undefined;
+}
+
+/** Mapea el nombre de una acción de SAK al `ActionType` de Prova. */
+export function mapActionType(actionName: string, result: ActionResult): ProvaActionType {
+  if (extractSignature(result)) return 'Transaction';
+  if (DECISION_PATTERN.test(actionName)) return 'Decision';
+  return 'ToolCall';
+}
+
+/** Construye el objeto que se serializa y hashea para producir el action_hash. */
+export function buildPayload(
+  actionName: string,
+  input: Record<string, unknown>,
+  result: ActionResult,
+): Record<string, unknown> {
+  const signature = extractSignature(result);
+  if (signature) {
+    return { kind: 'transaction', action: actionName, signature, input };
+  }
+  return { kind: 'toolCall', action: actionName, input, result };
+}

package/src/runtime.ts

@@ -0,0 +1,30 @@
+// Acceso tipado a globales de runtime (timers, console) sin depender de
+// @types/node ni de los tipos del DOM. En ejecución real los provee Node o el
+// navegador; aquí los declaramos mínimamente para mantener el adapter ligero.
+
+/** Identificador opaco de un timer (number en navegador, objeto en Node). */
+export type TimerId = number | { readonly __timer?: unique symbol };
+
+interface RuntimeGlobals {
+  setInterval(handler: () => void, ms: number): TimerId;
+  clearInterval(id: TimerId): void;
+  console: { warn(...args: unknown[]): void };
+}
+
+const runtime = globalThis as unknown as RuntimeGlobals;
+
+/** setInterval que no bloquea la salida del proceso (unref en Node si existe). */
+export function setIntervalSafe(handler: () => void, ms: number): TimerId {
+  const id = runtime.setInterval(handler, ms);
+  const maybe = id as unknown as { unref?: () => void };
+  if (typeof maybe.unref === 'function') maybe.unref();
+  return id;
+}
+
+export function clearIntervalSafe(id: TimerId): void {
+  runtime.clearInterval(id);
+}
+
+export function warn(...args: unknown[]): void {
+  runtime.console.warn(...args);
+}

package/src/types.ts

@@ -0,0 +1,75 @@
+// Tipos del adapter. Reflejamos estructuralmente la API pública de Solana Agent
+// Kit v2 (BaseWallet, Action, SolanaAgentKit) para NO importar el paquete y
+// mantener el adapter como peerDependency ligera. La compatibilidad se apoya en
+// el tipado estructural de TypeScript.
+
+/** Resultado típico del handler de una acción de SAK. */
+export type ActionResult = Record<string, unknown>;
+
+/** Acción de Solana Agent Kit (subconjunto que el adapter necesita). */
+export interface HostAction {
+  name: string;
+  handler: (agent: unknown, input: Record<string, unknown>) => Promise<ActionResult>;
+  [key: string]: unknown;
+}
+
+/** Agente de Solana Agent Kit (subconjunto que el adapter necesita). */
+export interface HostAgent {
+  actions: HostAction[];
+  [key: string]: unknown;
+}
+
+/** BaseWallet de Solana Agent Kit v2, en forma estructural. */
+export interface HostWallet {
+  readonly publicKey: { toBase58(): string };
+  signTransaction<T>(transaction: T): Promise<T>;
+  signAllTransactions<T>(transactions: T[]): Promise<T[]>;
+  signAndSendTransaction<T>(transaction: T, options?: unknown): Promise<{ signature: string }>;
+  signMessage(message: Uint8Array): Promise<Uint8Array>;
+}
+
+/** Tipos de acción soportados por Prova (espejo de `ActionType` del SDK). */
+export type ProvaActionType =
+  | 'Transaction'
+  | 'ToolCall'
+  | 'ModelInvocation'
+  | 'Decision'
+  | 'ResourceAccess'
+  | 'PolicyCheck'
+  | 'Custom';
+
+/** Una atestación lista para enviar (action_hash de 32 bytes + tipo). */
+export interface AttestationItem {
+  actionHash: Uint8Array;
+  actionType: ProvaActionType;
+}
+
+/**
+ * Superficie mínima que el adapter necesita de Prova, inyectada por el
+ * integrador. Permite usar el `ProvaClient` real sin acoplarnos a su tipo.
+ */
+export interface ProvaAttester {
+  hashAction(payload: string): Promise<Uint8Array>;
+  attest(item: AttestationItem): Promise<{ txSignature: string }>;
+  batchAttest(items: AttestationItem[]): Promise<{ txSignature: string }>;
+}
+
+/** Configuración del batching de atestaciones. */
+export interface BatchOptions {
+  /** Nº máximo de atestaciones por transacción (1–100). Default 25. */
+  maxSize?: number;
+  /** Flush automático cada N ms. Default 10000. 0 = sin flush por tiempo. */
+  flushIntervalMs?: number;
+}
+
+/** Opciones de `attachProva`. */
+export interface AttachProvaOptions {
+  /** Puente hacia Prova (ver `attesterFromProvaClient`). */
+  attester: ProvaAttester;
+  /** Filtra qué acciones atestar por nombre (default: todas). */
+  rules?: (actionName: string) => boolean;
+  /** Configuración de batching. */
+  batch?: BatchOptions;
+  /** Manejo de errores (default: warn por consola). Nunca rompe la acción. */
+  onError?: (error: unknown, context: { action: string }) => void;
+}

package/src/wallet.ts

@@ -0,0 +1,63 @@
+// Enfoque A: decorador de BaseWallet (SAK v2). Captura la firma on-chain real
+// de cada transacción firmada/enviada, sin importar qué plugin la produjo. Es
+// el "cinturón de seguridad" que complementa a `attachProva`.
+
+import type { BatchOptions, HostWallet, ProvaAttester } from './types';
+import { createBatcher, type Batcher } from './batcher';
+
+export interface ProvaWalletOptions {
+  attester: ProvaAttester;
+  batch?: BatchOptions;
+  onError?: (error: unknown) => void;
+}
+
+export class ProvaWallet implements HostWallet {
+  private readonly inner: HostWallet;
+  private readonly attester: ProvaAttester;
+  private readonly batcher: Batcher;
+
+  constructor(inner: HostWallet, options: ProvaWalletOptions) {
+    this.inner = inner;
+    this.attester = options.attester;
+    this.batcher = createBatcher(options.attester, options.batch, options.onError);
+  }
+
+  get publicKey(): { toBase58(): string } {
+    return this.inner.publicKey;
+  }
+
+  signTransaction<T>(transaction: T): Promise<T> {
+    return this.inner.signTransaction(transaction);
+  }
+
+  signAllTransactions<T>(transactions: T[]): Promise<T[]> {
+    return this.inner.signAllTransactions(transactions);
+  }
+
+  signMessage(message: Uint8Array): Promise<Uint8Array> {
+    return this.inner.signMessage(message);
+  }
+
+  async signAndSendTransaction<T>(transaction: T, options?: unknown): Promise<{ signature: string }> {
+    const result = await this.inner.signAndSendTransaction(transaction, options);
+    // Atestación NO bloqueante de la firma on-chain real.
+    void this.captureSignature(result.signature).catch(() => {});
+    return result;
+  }
+
+  /** Fuerza el envío de las atestaciones pendientes. */
+  flush(): Promise<void> {
+    return this.batcher.flush();
+  }
+
+  /** Detiene el batcher y hace un flush final. */
+  stop(): Promise<void> {
+    return this.batcher.stop();
+  }
+
+  private async captureSignature(signature: string): Promise<void> {
+    const payload = { kind: 'transaction', signature, source: 'wallet' };
+    const actionHash = await this.attester.hashAction(JSON.stringify(payload));
+    this.batcher.add({ actionHash, actionType: 'Transaction' });
+  }
+}