@framers/agentos-ext-anchor-providers 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# @framers/agentos-ext-anchor-providers
+
+## 1.1.0
+
+### Minor Changes
+
+- [`e6a2eb6`](https://github.com/framersai/agentos-extensions/commit/e6a2eb61145c5715df63668b795fe90720a3c7c1) Thanks [@jddunn](https://github.com/jddunn)! - Initial release of AgentOS extension packages.
+
+  - Auth: JWT authentication and subscription management
+  - Anchor Providers: Solana on-chain provenance anchoring
+  - Wunderland Tip Ingestion: Tip content processing pipeline
+  - Web Search: Search, research aggregation, and fact-checking
+  - Web Browser: Browser automation and content extraction
+  - Telegram Integration: Telegram Bot API integration
+  - Telegram Bot: Telegram bot communications handler
+  - CLI Executor: Shell command execution and file management

package/README.md

@@ -0,0 +1,353 @@
+# @framers/agentos-ext-anchor-providers
+
+External anchor providers for the [AgentOS](https://github.com/framersai/agentos) provenance system. Extends the built-in signed hash chain with external tamper-evidence backends — WORM storage, transparency logs, and blockchain timestamping.
+
+## Proof Levels
+
+Each provider advertises a proof level (ascending trust):
+
+| Level | Meaning | Provider |
+|-------|---------|----------|
+| `verifiable` | Local signed hash chain only | Built-in (`NoneProvider`) |
+| `externally-archived` | Immutable external archive with retention policy | `WormSnapshotProvider` |
+| `publicly-auditable` | Append-only public transparency log | `RekorProvider` |
+| `publicly-timestamped` | Blockchain-anchored timestamp proof | `OpenTimestampsProvider`, `EthereumProvider`, `SolanaProvider` |
+
+## Installation
+
+```bash
+pnpm add @framers/agentos-ext-anchor-providers
+```
+
+Install the peer dependency for your chosen provider:
+
+```bash
+# For WORM Snapshot (S3 Object Lock)
+pnpm add @aws-sdk/client-s3
+
+# For Rekor (Sigstore Transparency Log)
+pnpm add sigstore
+
+# For OpenTimestamps (Bitcoin)
+pnpm add opentimestamps
+
+# For Ethereum (On-Chain Anchor)
+pnpm add ethers
+
+# For Solana (On-Chain Anchor)
+pnpm add @solana/web3.js
+
+# Optional (only if using base58 secret keys)
+pnpm add bs58
+```
+
+## Quick Start
+
+### Option 1: Config-Driven (via Registry)
+
+Register all providers once at startup, then use the core factory:
+
+```typescript
+import { registerExtensionProviders } from '@framers/agentos-ext-anchor-providers';
+import { createAnchorProvider } from '@framers/agentos';
+
+// Register once at startup
+registerExtensionProviders();
+
+// Create provider from config
+const provider = createAnchorProvider({
+  type: 'rekor',
+  options: { serverUrl: 'https://rekor.sigstore.dev' },
+});
+```
+
+### Option 2: Direct Construction
+
+Import and instantiate providers directly:
+
+```typescript
+import { RekorProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new RekorProvider({
+  serverUrl: 'https://rekor.sigstore.dev',
+  timeoutMs: 15000,
+});
+```
+
+### Using with AnchorManager
+
+```typescript
+import { AnchorManager, profiles } from '@framers/agentos';
+import { RekorProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new RekorProvider();
+const config = profiles.sealedAutonomous();
+
+const anchorManager = new AnchorManager(
+  storageAdapter,
+  ledger,
+  keyManager,
+  config,
+  '', // table prefix
+  provider, // external anchor provider
+);
+```
+
+## Providers
+
+### WORM Snapshot Provider (S3 Object Lock)
+
+Archives anchor records to S3 with Object Lock retention. Provides compliance-grade immutability — objects cannot be deleted or overwritten during the retention period.
+
+**Proof level:** `externally-archived`
+**Peer dependency:** `@aws-sdk/client-s3`
+
+```typescript
+import { WormSnapshotProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new WormSnapshotProvider({
+  bucket: 'my-provenance-bucket',    // Required: S3 bucket with Object Lock enabled
+  region: 'us-east-1',               // Required: AWS region
+  keyPrefix: 'provenance/anchors/',  // Default: 'provenance/anchors/'
+  retentionDays: 365,                // Default: 365
+  retentionMode: 'COMPLIANCE',       // 'GOVERNANCE' (default) or 'COMPLIANCE'
+  timeoutMs: 30000,                  // Default: 30000
+  retries: 3,                        // Default: 3
+});
+```
+
+### Rekor Provider (Sigstore Transparency Log)
+
+Publishes anchor hashes to [Sigstore Rekor](https://rekor.sigstore.dev), a publicly auditable append-only transparency log. Entries are permanently recorded and anyone can verify inclusion.
+
+**Proof level:** `publicly-auditable`
+**Peer dependency:** `sigstore`
+
+```typescript
+import { RekorProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new RekorProvider({
+  serverUrl: 'https://rekor.sigstore.dev',  // Default: public Rekor instance
+  timeoutMs: 30000,
+  retries: 3,
+});
+```
+
+### OpenTimestamps Provider (Bitcoin)
+
+Creates [OpenTimestamps](https://opentimestamps.org) proofs anchored to the Bitcoin blockchain. Proofs are initially pending and confirm after a Bitcoin block includes the calendar commitment (typically 1-2 hours).
+
+**Proof level:** `publicly-timestamped`
+**Peer dependency:** `opentimestamps`
+
+```typescript
+import { OpenTimestampsProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new OpenTimestampsProvider({
+  calendarUrls: [                           // Default: public OTS calendars
+    'https://a.pool.opentimestamps.org',
+    'https://b.pool.opentimestamps.org',
+    'https://a.pool.eternitywall.com',
+  ],
+  timeoutMs: 30000,
+  retries: 3,
+});
+```
+
+### Ethereum Provider (On-Chain Anchor)
+
+Publishes anchor Merkle roots as calldata in Ethereum transactions. Provides cryptographic proof of existence at a specific block height.
+
+**Proof level:** `publicly-timestamped`
+**Peer dependency:** `ethers`
+
+```typescript
+import { EthereumProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new EthereumProvider({
+  rpcUrl: 'https://eth-mainnet.alchemyapi.io/v2/YOUR_KEY',  // Required
+  signerPrivateKey: '0x...',         // Required: hex private key
+  chainId: 1,                        // Default: 1 (mainnet)
+  contractAddress: '0x...',          // Optional: anchor storage contract
+  gasLimit: 100000,                  // Optional: gas limit override
+  timeoutMs: 60000,
+  retries: 3,
+});
+```
+
+## Composite Usage
+
+Use `CompositeAnchorProvider` from `@framers/agentos` to publish to multiple backends simultaneously:
+
+```typescript
+import { CompositeAnchorProvider } from '@framers/agentos';
+import { RekorProvider, WormSnapshotProvider } from '@framers/agentos-ext-anchor-providers';
+
+const provider = new CompositeAnchorProvider([
+  new WormSnapshotProvider({ bucket: 'my-bucket', region: 'us-east-1' }),
+  new RekorProvider(),
+]);
+
+// Publishes to both WORM and Rekor in parallel
+// Proof level: publicly-auditable (highest among children)
+```
+
+Or via config with the composite type:
+
+```typescript
+registerExtensionProviders();
+
+const provider = createAnchorProvider({
+  type: 'composite',
+  targets: [
+    { type: 'worm-snapshot', options: { bucket: 'my-bucket', region: 'us-east-1' } },
+    { type: 'rekor' },
+  ],
+});
+```
+
+## Architecture
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                     @framers/agentos (core)                      │
+│                                                                  │
+│  AnchorManager ──→ AnchorProvider interface                      │
+│       │                  ↑                                       │
+│       │            ┌─────┴──────┐                                │
+│       │            │NoneProvider│ (built-in, local-only)         │
+│       │            └────────────┘                                │
+│       │            ┌──────────────────┐                          │
+│       │            │CompositeProvider │ (built-in, multi-target) │
+│       │            └──────────────────┘                          │
+│       │                                                          │
+│  createAnchorProvider() ←─── registerAnchorProviderFactory()     │
+└──────────────────────┬───────────────────────────────────────────┘
+                       │ (registry pattern)
+┌──────────────────────▼───────────────────────────────────────────┐
+│            @framers/agentos-ext-anchor-providers           │
+│                                                                  │
+│  registerExtensionProviders()                                    │
+│       │                                                          │
+│       ├── WormSnapshotProvider  (externally-archived)            │
+│       ├── RekorProvider         (publicly-auditable)             │
+│       ├── OpenTimestampsProvider(publicly-timestamped)           │
+│       ├── EthereumProvider      (publicly-timestamped)           │
+│       └── SolanaProvider        (publicly-timestamped)           │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+## Writing Custom Providers
+
+Implement the `AnchorProvider` interface from `@framers/agentos`:
+
+```typescript
+import type { AnchorProvider, AnchorRecord, AnchorProviderResult, ProofLevel } from '@framers/agentos';
+
+export class MyCustomProvider implements AnchorProvider {
+  readonly id = 'my-custom';
+  readonly name = 'My Custom Provider';
+  readonly proofLevel: ProofLevel = 'externally-archived';
+
+  async publish(anchor: AnchorRecord): Promise<AnchorProviderResult> {
+    try {
+      // Your publishing logic here
+      const ref = await publishToMyBackend(anchor);
+      return { providerId: this.id, success: true, externalRef: ref };
+    } catch (e) {
+      return { providerId: this.id, success: false, error: String(e) };
+    }
+  }
+
+  async verify(anchor: AnchorRecord): Promise<boolean> {
+    // Verify the anchor against the external record
+    return verifyAgainstMyBackend(anchor);
+  }
+
+  async dispose(): Promise<void> {
+    // Cleanup resources
+  }
+}
+```
+
+Register it with the core factory:
+
+```typescript
+import { registerAnchorProviderFactory } from '@framers/agentos';
+import { MyCustomProvider } from './MyCustomProvider';
+
+registerAnchorProviderFactory('my-custom', (opts) => new MyCustomProvider(opts));
+```
+
+## Utilities
+
+### `fetchWithRetry(url, init, options)`
+
+HTTP fetch wrapper with exponential backoff retry. Used internally by providers that communicate over HTTP.
+
+```typescript
+import { fetchWithRetry } from '@framers/agentos-ext-anchor-providers';
+
+const response = await fetchWithRetry('https://api.example.com/anchor', {
+  method: 'POST',
+  body: JSON.stringify(data),
+}, { timeoutMs: 10000, retries: 3 });
+```
+
+### `canonicalizeAnchor(anchor)`
+
+Deterministic JSON serialization of an `AnchorRecord` with sorted keys. Ensures all providers hash the same byte representation.
+
+### `hashCanonicalAnchor(anchor)`
+
+Computes SHA-256 hex digest of the canonical anchor representation.
+
+## Implementation Status
+
+| Provider | Status | Notes |
+|----------|--------|-------|
+| WormSnapshotProvider | Stub | Requires `@aws-sdk/client-s3` implementation |
+| RekorProvider | Stub | Requires `sigstore` SDK implementation |
+| OpenTimestampsProvider | Stub | Requires `opentimestamps` implementation |
+| EthereumProvider | Stub | Requires `ethers` implementation |
+| SolanaProvider | Implemented | Requires `@solana/web3.js` (and a funded signer) |
+
+All providers **except SolanaProvider** currently return `{ success: false }` from `publish()` until their respective SDK integrations are implemented. SolanaProvider is functional when its optional peer dependencies are installed and the configured signer is funded.
+
+## Testing
+
+```bash
+# Run all tests
+pnpm test
+
+# Run with coverage
+pnpm test:coverage
+
+# Watch mode
+pnpm test:watch
+```
+
+### Test Structure
+
+| File | Description |
+|------|-------------|
+| `test/providers.spec.ts` | Unit tests for all 4 providers — identity, stub behavior, config |
+| `test/register.spec.ts` | Registration tests — verifies factories are registered with core |
+| `test/integration.spec.ts` | End-to-end integration — factory creation, provider identity, stub behavior |
+| `test/utils.spec.ts` | Utility tests — canonicalization, SHA-256 hashing, HTTP retry |
+| `test/types.spec.ts` | Config resolution tests — default values, overrides |
+
+## Related Packages
+
+| Package | Description | Link |
+|---------|-------------|------|
+| `@framers/agentos` | Core AgentOS framework with `AnchorProvider` interface, `AnchorManager`, registry | [packages/agentos](https://github.com/framersai/agentos) |
+| `@framers/agentos` provenance types | `AnchorProvider`, `ProofLevel`, `AnchorProviderResult` interfaces | [`src/core/provenance/types.ts`](https://github.com/framersai/agentos/blob/master/src/core/provenance/types.ts) |
+| `@framers/agentos` factory | `createAnchorProvider()`, `registerAnchorProviderFactory()` | [`src/core/provenance/anchoring/providers/createAnchorProvider.ts`](https://github.com/framersai/agentos/blob/master/src/core/provenance/anchoring/providers/createAnchorProvider.ts) |
+| `@framers/agentos` built-in providers | `NoneProvider`, `CompositeAnchorProvider` | [`src/core/provenance/anchoring/providers/`](https://github.com/framersai/agentos/blob/master/src/core/provenance/anchoring/providers/) |
+| `@framers/agentos` AnchorManager | Periodic anchoring with external provider support | [`src/core/provenance/anchoring/AnchorManager.ts`](https://github.com/framersai/agentos/blob/master/src/core/provenance/anchoring/AnchorManager.ts) |
+| `@framers/agentos` profiles | `sealedAuditable()` convenience profile | [`src/core/provenance/config/PolicyProfiles.ts`](https://github.com/framersai/agentos/blob/master/src/core/provenance/config/PolicyProfiles.ts) |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file index.ts
+ * @description Main entry point for @framers/agentos-ext-anchor-providers.
+ *
+ * External anchor providers for the AgentOS provenance system:
+ * - **WormSnapshotProvider** — S3 Object Lock / WORM storage (externally-archived)
+ * - **RekorProvider** — Sigstore Rekor transparency log (publicly-auditable)
+ * - **OpenTimestampsProvider** — Bitcoin-anchored timestamping (publicly-timestamped)
+ * - **EthereumProvider** — Ethereum on-chain anchor (publicly-timestamped)
+ * - **SolanaProvider** — Solana on-chain anchor (publicly-timestamped)
+ *
+ * ## Quick Start
+ *
+ * ### Option 1: Config-driven (via registry)
+ * ```typescript
+ * import { registerExtensionProviders } from '@framers/agentos-ext-anchor-providers';
+ * import { createAnchorProvider } from '@framers/agentos';
+ *
+ * registerExtensionProviders();
+ * const provider = createAnchorProvider({ type: 'rekor' });
+ * ```
+ *
+ * ### Option 2: Direct construction
+ * ```typescript
+ * import { RekorProvider } from '@framers/agentos-ext-anchor-providers';
+ *
+ * const provider = new RekorProvider({ serverUrl: 'https://rekor.sigstore.dev' });
+ * ```
+ *
+ * @module @framers/agentos-ext-anchor-providers
+ */
+export { registerExtensionProviders } from './register.js';
+export { WormSnapshotProvider } from './providers/WormSnapshotProvider.js';
+export type { WormSnapshotProviderConfig } from './providers/WormSnapshotProvider.js';
+export { RekorProvider } from './providers/RekorProvider.js';
+export type { RekorProviderConfig } from './providers/RekorProvider.js';
+export { OpenTimestampsProvider } from './providers/OpenTimestampsProvider.js';
+export type { OpenTimestampsProviderConfig } from './providers/OpenTimestampsProvider.js';
+export { EthereumProvider } from './providers/EthereumProvider.js';
+export type { EthereumProviderConfig } from './providers/EthereumProvider.js';
+export { SolanaProvider } from './providers/SolanaProvider.js';
+export type { SolanaProviderConfig } from './providers/SolanaProvider.js';
+export type { BaseProviderConfig } from './types.js';
+export { resolveBaseConfig } from './types.js';
+export { fetchWithRetry } from './utils/http-client.js';
+export type { HttpRequestOptions } from './utils/http-client.js';
+export { canonicalizeAnchor, hashCanonicalAnchor } from './utils/serialization.js';
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAG3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,YAAY,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAEtF,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,YAAY,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,YAAY,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAE1F,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,YAAY,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,YAAY,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAG1E,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,YAAY,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,44 @@
+/**
+ * @file index.ts
+ * @description Main entry point for @framers/agentos-ext-anchor-providers.
+ *
+ * External anchor providers for the AgentOS provenance system:
+ * - **WormSnapshotProvider** — S3 Object Lock / WORM storage (externally-archived)
+ * - **RekorProvider** — Sigstore Rekor transparency log (publicly-auditable)
+ * - **OpenTimestampsProvider** — Bitcoin-anchored timestamping (publicly-timestamped)
+ * - **EthereumProvider** — Ethereum on-chain anchor (publicly-timestamped)
+ * - **SolanaProvider** — Solana on-chain anchor (publicly-timestamped)
+ *
+ * ## Quick Start
+ *
+ * ### Option 1: Config-driven (via registry)
+ * ```typescript
+ * import { registerExtensionProviders } from '@framers/agentos-ext-anchor-providers';
+ * import { createAnchorProvider } from '@framers/agentos';
+ *
+ * registerExtensionProviders();
+ * const provider = createAnchorProvider({ type: 'rekor' });
+ * ```
+ *
+ * ### Option 2: Direct construction
+ * ```typescript
+ * import { RekorProvider } from '@framers/agentos-ext-anchor-providers';
+ *
+ * const provider = new RekorProvider({ serverUrl: 'https://rekor.sigstore.dev' });
+ * ```
+ *
+ * @module @framers/agentos-ext-anchor-providers
+ */
+// Registry
+export { registerExtensionProviders } from './register.js';
+// Providers
+export { WormSnapshotProvider } from './providers/WormSnapshotProvider.js';
+export { RekorProvider } from './providers/RekorProvider.js';
+export { OpenTimestampsProvider } from './providers/OpenTimestampsProvider.js';
+export { EthereumProvider } from './providers/EthereumProvider.js';
+export { SolanaProvider } from './providers/SolanaProvider.js';
+export { resolveBaseConfig } from './types.js';
+// Utilities
+export { fetchWithRetry } from './utils/http-client.js';
+export { canonicalizeAnchor, hashCanonicalAnchor } from './utils/serialization.js';
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,WAAW;AACX,OAAO,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAE3D,YAAY;AACZ,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAG7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAG/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAGnE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAK/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,YAAY;AACZ,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/providers/EthereumProvider.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file EthereumProvider.ts
+ * @description Ethereum on-chain anchor provider.
+ * Publishes anchor Merkle roots as calldata in Ethereum transactions.
+ *
+ * Proof level: `publicly-timestamped`
+ * Required peer dependency: `ethers`
+ *
+ * @module @framers/agentos-ext-anchor-providers
+ */
+import type { AnchorProvider, AnchorRecord, AnchorProviderResult, ProofLevel } from '@framers/agentos';
+import type { BaseProviderConfig } from '../types.js';
+export interface EthereumProviderConfig extends BaseProviderConfig {
+    /** JSON-RPC endpoint URL. */
+    rpcUrl: string;
+    /** Contract address for anchor storage (optional — can use raw calldata tx). */
+    contractAddress?: string;
+    /** Private key hex for signing transactions. */
+    signerPrivateKey?: string;
+    /** Chain ID. Default: 1 (mainnet). */
+    chainId?: number;
+    /** Gas limit override. Default: auto-estimate. */
+    gasLimit?: number;
+}
+export declare class EthereumProvider implements AnchorProvider {
+    readonly id = "ethereum";
+    readonly name = "Ethereum On-Chain Anchor";
+    readonly proofLevel: ProofLevel;
+    private readonly config;
+    private readonly baseConfig;
+    constructor(config: EthereumProviderConfig);
+    publish(anchor: AnchorRecord): Promise<AnchorProviderResult>;
+    verify(anchor: AnchorRecord): Promise<boolean>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=EthereumProvider.d.ts.map

package/dist/providers/EthereumProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumProvider.d.ts","sourceRoot":"","sources":["../../src/providers/EthereumProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACvG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,gBAAiB,YAAW,cAAc;IACrD,QAAQ,CAAC,EAAE,cAAc;IACzB,QAAQ,CAAC,IAAI,8BAA8B;IAC3C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAA0B;IAEzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyB;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;gBAE9C,MAAM,EAAE,sBAAsB;IAQpC,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA8B5D,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/providers/EthereumProvider.js

@@ -0,0 +1,66 @@
+/**
+ * @file EthereumProvider.ts
+ * @description Ethereum on-chain anchor provider.
+ * Publishes anchor Merkle roots as calldata in Ethereum transactions.
+ *
+ * Proof level: `publicly-timestamped`
+ * Required peer dependency: `ethers`
+ *
+ * @module @framers/agentos-ext-anchor-providers
+ */
+import { resolveBaseConfig } from '../types.js';
+import { hashCanonicalAnchor } from '../utils/serialization.js';
+export class EthereumProvider {
+    id = 'ethereum';
+    name = 'Ethereum On-Chain Anchor';
+    proofLevel = 'publicly-timestamped';
+    config;
+    baseConfig;
+    constructor(config) {
+        this.config = {
+            chainId: 1,
+            ...config,
+        };
+        this.baseConfig = resolveBaseConfig(config);
+    }
+    async publish(anchor) {
+        // TODO: Implement using ethers.js or viem
+        //
+        // Implementation outline:
+        //   1. Compute SHA-256 of canonical anchor: hashCanonicalAnchor(anchor)
+        //   2. Create ethers.JsonRpcProvider(this.config.rpcUrl)
+        //   3. Create ethers.Wallet(this.config.signerPrivateKey, provider)
+        //   4. If contractAddress is set:
+        //      - ABI-encode call to `anchor(bytes32 merkleRoot)` on the contract
+        //      - Send contract transaction
+        //   5. If no contractAddress (raw calldata):
+        //      - Send self-transfer with 0x + anchorHash as calldata
+        //   6. Wait for transaction receipt (1 confirmation)
+        //   7. Return { success: true, externalRef: `eth:${chainId}:${txHash}`,
+        //              metadata: { blockNumber, blockHash, gasUsed, chainId } }
+        try {
+            const _hash = await hashCanonicalAnchor(anchor);
+            throw new Error('EthereumProvider is not yet implemented. ' +
+                'Install ethers.js and implement the Ethereum on-chain anchor integration.');
+        }
+        catch (e) {
+            return {
+                providerId: this.id,
+                success: false,
+                error: e instanceof Error ? e.message : String(e),
+            };
+        }
+    }
+    async verify(anchor) {
+        // TODO: Parse txHash from externalRef, fetch transaction receipt,
+        //   decode calldata, compare with anchor hash
+        if (!anchor.externalRef)
+            return false;
+        console.warn('[EthereumProvider] verify() is not yet implemented');
+        return false;
+    }
+    async dispose() {
+        // TODO: Disconnect provider if persistent connection was established
+    }
+}
+//# sourceMappingURL=EthereumProvider.js.map

package/dist/providers/EthereumProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EthereumProvider.js","sourceRoot":"","sources":["../../src/providers/EthereumProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAehE,MAAM,OAAO,gBAAgB;IAClB,EAAE,GAAG,UAAU,CAAC;IAChB,IAAI,GAAG,0BAA0B,CAAC;IAClC,UAAU,GAAe,sBAAsB,CAAC;IAExC,MAAM,CAAyB;IAC/B,UAAU,CAA+B;IAE1D,YAAY,MAA8B;QACxC,IAAI,CAAC,MAAM,GAAG;YACZ,OAAO,EAAE,CAAC;YACV,GAAG,MAAM;SACV,CAAC;QACF,IAAI,CAAC,UAAU,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,MAAoB;QAChC,0CAA0C;QAC1C,EAAE;QACF,0BAA0B;QAC1B,wEAAwE;QACxE,yDAAyD;QACzD,oEAAoE;QACpE,kCAAkC;QAClC,yEAAyE;QACzE,mCAAmC;QACnC,6CAA6C;QAC7C,6DAA6D;QAC7D,qDAAqD;QACrD,wEAAwE;QACxE,wEAAwE;QACxE,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,mBAAmB,CAAC,MAAM,CAAC,CAAC;YAChD,MAAM,IAAI,KAAK,CACb,2CAA2C;gBAC3C,2EAA2E,CAC5E,CAAC;QACJ,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,OAAO;gBACL,UAAU,EAAE,IAAI,CAAC,EAAE;gBACnB,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;aAClD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,MAAoB;QAC/B,kEAAkE;QAClE,8CAA8C;QAC9C,IAAI,CAAC,MAAM,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QACtC,OAAO,CAAC,IAAI,CAAC,oDAAoD,CAAC,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;IAED,KAAK,CAAC,OAAO;QACX,qEAAqE;IACvE,CAAC;CACF"}

package/dist/providers/OpenTimestampsProvider.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file OpenTimestampsProvider.ts
+ * @description Bitcoin-anchored timestamping via the OpenTimestamps protocol.
+ * Creates OTS timestamps for anchor Merkle roots and submits to calendar servers.
+ *
+ * Proof level: `publicly-timestamped`
+ * Required peer dependency: `opentimestamps`
+ *
+ * @module @framers/agentos-ext-anchor-providers
+ */
+import type { AnchorProvider, AnchorRecord, AnchorProviderResult, ProofLevel } from '@framers/agentos';
+import type { BaseProviderConfig } from '../types.js';
+export interface OpenTimestampsProviderConfig extends BaseProviderConfig {
+    /** OTS calendar server URLs. Default: public OpenTimestamps calendars. */
+    calendarUrls?: string[];
+}
+export declare class OpenTimestampsProvider implements AnchorProvider {
+    readonly id = "opentimestamps";
+    readonly name = "OpenTimestamps (Bitcoin)";
+    readonly proofLevel: ProofLevel;
+    private readonly config;
+    private readonly baseConfig;
+    constructor(config?: OpenTimestampsProviderConfig);
+    publish(anchor: AnchorRecord): Promise<AnchorProviderResult>;
+    verify(anchor: AnchorRecord): Promise<boolean>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=OpenTimestampsProvider.d.ts.map

package/dist/providers/OpenTimestampsProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenTimestampsProvider.d.ts","sourceRoot":"","sources":["../../src/providers/OpenTimestampsProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACvG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD,MAAM,WAAW,4BAA6B,SAAQ,kBAAkB;IACtE,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAQD,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,QAAQ,CAAC,EAAE,oBAAoB;IAC/B,QAAQ,CAAC,IAAI,8BAA8B;IAC3C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAA0B;IAEzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA+B;gBAE9C,MAAM,GAAE,4BAAiC;IAU/C,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA6B5D,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC;IAQ9C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}