@originals/sdk 1.1.0

package/dist/vc/cryptosuites/eddsa.d.ts

@@ -0,0 +1,30 @@
+export interface DataIntegrityProof {
+    type: 'DataIntegrityProof';
+    cryptosuite: string;
+    created?: string;
+    verificationMethod: string;
+    proofPurpose: string;
+    proofValue: string;
+    id?: string;
+    previousProof?: string | string[];
+}
+export interface VerificationResult {
+    verified: boolean;
+    errors?: string[];
+}
+export declare class EdDSACryptosuiteManager {
+    static createProof(document: any, options: any): Promise<DataIntegrityProof>;
+    static verifyProof(document: any, proof: DataIntegrityProof, options: any): Promise<VerificationResult>;
+    private static createProofConfiguration;
+    private static transform;
+    private static hash;
+    static sign({ data, privateKey }: {
+        data: Uint8Array;
+        privateKey: Uint8Array;
+    }): Promise<Uint8Array>;
+    static verify({ data, signature, publicKey }: {
+        data: Uint8Array;
+        signature: Uint8Array;
+        publicKey: Uint8Array;
+    }): Promise<boolean>;
+}

package/dist/vc/cryptosuites/eddsa.js

@@ -0,0 +1,81 @@
+import { base58 } from '@scure/base';
+import * as ed25519 from '@noble/ed25519';
+import { canonize, canonizeProof } from '../utils/jsonld';
+import { multikey } from '../../crypto/Multikey';
+import { sha256Bytes } from '../../utils/hash';
+export class EdDSACryptosuiteManager {
+    static async createProof(document, options) {
+        const proofConfig = await this.createProofConfiguration(options);
+        const transformedData = await this.transform(document, options);
+        const hashData = await this.hash(transformedData, proofConfig, options);
+        let privateKey;
+        if (typeof options.privateKey === 'string') {
+            const dec = multikey.decodePrivateKey(options.privateKey);
+            if (dec.type !== 'Ed25519')
+                throw new Error('Invalid key type for EdDSA');
+            privateKey = dec.key;
+        }
+        else if (options.privateKey instanceof Uint8Array) {
+            privateKey = options.privateKey;
+        }
+        else {
+            throw new Error('Invalid private key format');
+        }
+        const proofValueBytes = await this.sign({ data: hashData, privateKey });
+        delete proofConfig['@context'];
+        return { ...proofConfig, proofValue: base58.encode(proofValueBytes) };
+    }
+    static async verifyProof(document, proof, options) {
+        try {
+            const documentToVerify = { ...document };
+            delete documentToVerify.proof;
+            const transformedData = await this.transform(documentToVerify, options);
+            const hashData = await this.hash(transformedData, { '@context': document['@context'], ...proof }, options);
+            const vmDoc = await options.documentLoader(proof.verificationMethod);
+            const pk = vmDoc.document.publicKeyMultibase;
+            const dec = multikey.decodePublicKey(pk);
+            if (dec.type !== 'Ed25519')
+                throw new Error('Invalid key type for EdDSA');
+            const signature = base58.decode(proof.proofValue);
+            const verified = await this.verify({ data: hashData, signature, publicKey: dec.key });
+            return verified ? { verified: true } : { verified: false, errors: ['Proof verification failed'] };
+        }
+        catch (e) {
+            return { verified: false, errors: [e?.message ?? 'Unknown verification error'] };
+        }
+    }
+    static async createProofConfiguration(options) {
+        return {
+            '@context': 'https://w3id.org/security/data-integrity/v2',
+            type: 'DataIntegrityProof',
+            cryptosuite: 'eddsa-rdfc-2022',
+            created: new Date().toISOString(),
+            verificationMethod: options.verificationMethod,
+            proofPurpose: options.proofPurpose || 'assertionMethod',
+            ...(options.challenge && { challenge: options.challenge }),
+            ...(options.domain && { domain: options.domain })
+        };
+    }
+    static async transform(document, options) {
+        return await canonize(document, { documentLoader: options.documentLoader });
+    }
+    static async hash(transformedData, proofConfig, options) {
+        const canonicalProofConfig = await canonizeProof(proofConfig, { documentLoader: options.documentLoader });
+        const proofConfigHash = await sha256Bytes(canonicalProofConfig);
+        const documentHash = await sha256Bytes(transformedData);
+        return new Uint8Array([...proofConfigHash, ...documentHash]);
+    }
+    static async sign({ data, privateKey }) {
+        if (privateKey.length !== 32) {
+            if (privateKey.length === 64)
+                privateKey = privateKey.slice(32);
+            else
+                throw new Error('Invalid private key length');
+        }
+        const signature = await ed25519.signAsync(Buffer.from(data).toString('hex'), Buffer.from(privateKey).toString('hex'));
+        return signature;
+    }
+    static async verify({ data, signature, publicKey }) {
+        return await ed25519.verifyAsync(Buffer.from(signature).toString('hex'), Buffer.from(data).toString('hex'), Buffer.from(publicKey).toString('hex'));
+    }
+}

package/dist/vc/documentLoader.d.ts

@@ -0,0 +1,16 @@
+import { DIDManager } from '../did/DIDManager';
+type LoadedDocument = {
+    document: any;
+    documentUrl: string;
+    contextUrl: string | null;
+};
+export declare class DocumentLoader {
+    private didManager;
+    constructor(didManager: DIDManager);
+    load(iri: string): Promise<LoadedDocument>;
+    private resolveDID;
+}
+export declare const createDocumentLoader: (didManager: DIDManager) => (iri: string) => Promise<LoadedDocument>;
+export declare const verificationMethodRegistry: Map<string, any>;
+export declare function registerVerificationMethod(vm: any): void;
+export {};

package/dist/vc/documentLoader.js

@@ -0,0 +1,59 @@
+const CONTEXTS = {
+    // Provide 1.1-compatible stubs for jsonld canonize
+    'https://www.w3.org/ns/credentials/v2': { '@context': { '@version': 1.1 } },
+    'https://w3id.org/security/data-integrity/v2': { '@context': { '@version': 1.1 } }
+};
+export class DocumentLoader {
+    constructor(didManager) {
+        this.didManager = didManager;
+    }
+    async load(iri) {
+        if (iri.startsWith('did:')) {
+            return this.resolveDID(iri);
+        }
+        const doc = CONTEXTS[iri];
+        if (doc) {
+            return { document: doc, documentUrl: iri, contextUrl: null };
+        }
+        throw new Error(`Document not found: ${iri}`);
+    }
+    async resolveDID(didUrl) {
+        const [did, fragment] = didUrl.split('#');
+        const didDoc = await this.didManager.resolveDID(did);
+        if (!didDoc) {
+            throw new Error(`DID not resolved: ${did}`);
+        }
+        if (fragment) {
+            // If a VM was registered explicitly, prefer it
+            const cached = verificationMethodRegistry.get(didUrl);
+            if (cached) {
+                return {
+                    document: { '@context': didDoc['@context'], ...cached },
+                    documentUrl: didUrl,
+                    contextUrl: null
+                };
+            }
+            const vms = didDoc.verificationMethod;
+            const vm = vms?.find((m) => m.id === didUrl);
+            if (vm) {
+                return {
+                    document: { '@context': didDoc['@context'], ...vm },
+                    documentUrl: didUrl,
+                    contextUrl: null
+                };
+            }
+            return {
+                document: { '@context': didDoc['@context'], id: didUrl },
+                documentUrl: didUrl,
+                contextUrl: null
+            };
+        }
+        return { document: didDoc, documentUrl: didUrl, contextUrl: null };
+    }
+}
+export const createDocumentLoader = (didManager) => (iri) => new DocumentLoader(didManager).load(iri);
+export const verificationMethodRegistry = new Map();
+export function registerVerificationMethod(vm) {
+    if (vm?.id)
+        verificationMethodRegistry.set(vm.id, vm);
+}

package/dist/vc/proofs/data-integrity.d.ts

@@ -0,0 +1,21 @@
+import { type DataIntegrityProof } from '../cryptosuites/eddsa';
+export interface VerificationResult {
+    verified: boolean;
+    errors?: string[];
+}
+export interface ProofOptions {
+    verificationMethod: string;
+    proofPurpose: string;
+    privateKey?: Uint8Array | string;
+    type: 'DataIntegrityProof';
+    created?: string;
+    cryptosuite: string;
+    documentLoader?: (url: string) => Promise<any>;
+    previousProof?: string | string[];
+    challenge?: string;
+    domain?: string;
+}
+export declare class DataIntegrityProofManager {
+    static createProof(document: any, options: ProofOptions): Promise<DataIntegrityProof>;
+    static verifyProof(document: any, proof: DataIntegrityProof, options: any): Promise<VerificationResult>;
+}

package/dist/vc/proofs/data-integrity.js

@@ -0,0 +1,15 @@
+import { EdDSACryptosuiteManager } from '../cryptosuites/eddsa';
+export class DataIntegrityProofManager {
+    static async createProof(document, options) {
+        if (options.cryptosuite !== 'eddsa-rdfc-2022') {
+            throw new Error(`Unsupported cryptosuite: ${options.cryptosuite}`);
+        }
+        return await EdDSACryptosuiteManager.createProof(document, options);
+    }
+    static async verifyProof(document, proof, options) {
+        if (proof.cryptosuite !== 'eddsa-rdfc-2022') {
+            return { verified: false, errors: [`Unsupported cryptosuite: ${proof.cryptosuite}`] };
+        }
+        return await EdDSACryptosuiteManager.verifyProof(document, proof, options);
+    }
+}

package/dist/vc/utils/jsonld.d.ts

@@ -0,0 +1,2 @@
+export declare function canonize(input: any, { documentLoader }: any): Promise<string>;
+export declare function canonizeProof(proof: any, { documentLoader }: any): Promise<string>;

package/dist/vc/utils/jsonld.js

@@ -0,0 +1,15 @@
+import jsonld from 'jsonld';
+export async function canonize(input, { documentLoader }) {
+    return await jsonld.canonize(input, {
+        algorithm: 'URDNA2015',
+        format: 'application/n-quads',
+        documentLoader,
+        safe: false,
+        useNative: false,
+        rdfDirection: 'i18n-datatype'
+    });
+}
+export async function canonizeProof(proof, { documentLoader }) {
+    const { jws, signatureValue, proofValue, ...rest } = proof;
+    return await canonize(rest, { documentLoader });
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@originals/sdk",
+  "version": "1.1.0",
+  "description": "TypeScript SDK for the Originals Protocol - creating, discovering, and transferring digital assets with cryptographically verifiable provenance",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test tests/integration && bun test tests/unit && bun test tests/security && bun test tests/stress",
+    "test:coverage": "bun test tests/integration tests/unit --coverage",
+    "check-coverage": "bun run ../../scripts/check-coverage.ts",
+    "test:ci": "bun test tests/integration tests/unit --coverage 2>&1 | bun run ../../scripts/check-coverage.ts",
+    "test:security": "bun test tests/security",
+    "test:stress": "bun test tests/stress",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts"
+  },
+  "keywords": [
+    "originals",
+    "did",
+    "verifiable-credentials",
+    "bitcoin",
+    "ordinals",
+    "digital-assets",
+    "provenance",
+    "decentralized-identity"
+  ],
+  "author": "Aviary Tech",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/onionoriginals/sdk"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@aviarytech/did-peer": "^1.1.2",
+    "@noble/curves": "^1.6.0",
+    "@noble/ed25519": "^2.0.0",
+    "@noble/hashes": "^2.0.1",
+    "@noble/secp256k1": "^2.0.0",
+    "@scure/base": "^1.1.6",
+    "@scure/bip32": "^2.0.0",
+    "@scure/btc-signer": "^1.8.0",
+    "@stablelib/ed25519": "^2.0.2",
+    "b58": "^4.0.3",
+    "bitcoinjs-lib": "^6.1.0",
+    "cbor-js": "^0.1.0",
+    "didwebvh-ts": "^2.5.5",
+    "jsonld": "^8.3.3",
+    "micro-ordinals": "^0.2.2",
+    "multiformats": "^12.0.0",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.4",
+    "@babel/preset-env": "^7.28.3",
+    "@types/bun": "^1.3.0",
+    "@types/node": "^20.19.17",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "bun-types": "^1.3.1",
+    "eslint": "^8.0.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/adapters/FeeOracleMock.ts

@@ -0,0 +1,9 @@
+import { FeeOracleAdapter } from './types';
+
+export class FeeOracleMock implements FeeOracleAdapter {
+  constructor(private feeRate = 7) {}
+  async estimateFeeRate(targetBlocks = 1): Promise<number> {
+    return Math.max(1, this.feeRate - (targetBlocks - 1));
+  }
+}
+

package/src/adapters/index.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './FeeOracleMock';
+export * from './providers/OrdMockProvider';
+export * from './providers/OrdHttpProvider';
+

package/src/adapters/providers/OrdHttpProvider.ts

@@ -0,0 +1,126 @@
+/* istanbul ignore file */
+import type { OrdinalsProvider } from '../types';
+
+interface HttpProviderOptions {
+  baseUrl: string;
+}
+
+function buildUrl(baseUrl: string, path: string): string {
+  const base = baseUrl.replace(/\/$/, '');
+  return `${base}${path.startsWith('/') ? '' : '/'}${path}`;
+}
+
+async function fetchJson<T>(url: string): Promise<T | null> {
+  const res = await (globalThis as any).fetch(url, {
+    headers: {
+      'Accept': 'application/json'
+    }
+  });
+  if (!res.ok) return null;
+  return (await res.json()) as T;
+}
+
+export class OrdHttpProvider implements OrdinalsProvider {
+  private readonly baseUrl: string;
+
+  constructor(options: HttpProviderOptions) {
+    if (!options?.baseUrl) {
+      throw new Error('OrdHttpProvider requires baseUrl');
+    }
+    this.baseUrl = options.baseUrl;
+  }
+
+  async getInscriptionById(id: string) {
+    if (!id) return null;
+    const data = await fetchJson<any>(buildUrl(this.baseUrl, `/inscription/${id}`));
+    if (!data) return null;
+    // Expecting a shape similar to Ordinals indexers; adapt minimally
+    const ownerOutput: string | undefined = data.owner_output;
+    let txid = data.txid || 'unknown';
+    let vout = typeof data.vout === 'number' ? data.vout : 0;
+    if (ownerOutput && ownerOutput.includes(':')) {
+      const [tid, v] = ownerOutput.split(':');
+      txid = tid;
+      vout = Number(v) || 0;
+    }
+
+    const contentType = data.content_type || 'application/octet-stream';
+    const contentUrl = data.content_url || buildUrl(this.baseUrl, `/content/${id}`);
+    const contentRes = await (globalThis as any).fetch(contentUrl);
+    if (!contentRes.ok) return null;
+    const buf = (globalThis as any).Buffer
+      ? (globalThis as any).Buffer.from(new Uint8Array(await contentRes.arrayBuffer()))
+      : new Uint8Array(await contentRes.arrayBuffer()) as any;
+
+    return {
+      inscriptionId: data.inscription_id || id,
+      content: buf,
+      contentType,
+      txid,
+      vout,
+      satoshi: String(data.sat ?? ''),
+      blockHeight: data.block_height
+    };
+  }
+
+  async getInscriptionsBySatoshi(satoshi: string) {
+    if (!satoshi) return [];
+    const data = await fetchJson<any>(buildUrl(this.baseUrl, `/sat/${satoshi}`));
+    const ids: string[] = Array.isArray(data?.inscription_ids) ? data.inscription_ids : [];
+    return ids.map((inscriptionId) => ({ inscriptionId }));
+  }
+
+  async broadcastTransaction(_txHexOrObj: unknown): Promise<string> {
+    // For example purposes only, return a placeholder
+    return 'broadcast-txid';
+  }
+
+  async getTransactionStatus(_txid: string) {
+    return { confirmed: false };
+  }
+
+  async estimateFee(blocks: number = 1): Promise<number> {
+    // Basic fallback: some providers expose fee estimates; for example purposes, return linear estimate
+    return 5 * Math.max(1, blocks);
+  }
+
+  async createInscription(params: { data: any; contentType: string; feeRate?: number; }) {
+    // Example placeholder: a real implementation would POST to a service
+    // Here we return a deterministic mock-like result to avoid network coupling in code
+    const inscriptionId = `insc-${Math.random().toString(36).slice(2)}`;
+    const txid = `tx-${Math.random().toString(36).slice(2)}`;
+    return {
+      inscriptionId,
+      revealTxId: txid,
+      txid,
+      vout: 0,
+      blockHeight: undefined,
+      content: params.data,
+      contentType: params.contentType,
+      feeRate: params.feeRate
+    };
+  }
+
+  async transferInscription(inscriptionId: string, _toAddress: string, _options?: { feeRate?: number }) {
+    if (!inscriptionId) throw new Error('inscriptionId required');
+    const txid = `tx-${Math.random().toString(36).slice(2)}`;
+    return {
+      txid,
+      vin: [{ txid: 'prev', vout: 0 }],
+      vout: [{ value: 546, scriptPubKey: 'script' }],
+      fee: 100,
+      confirmations: 0
+    };
+  }
+}
+
+export async function createOrdinalsProviderFromEnv(): Promise<OrdinalsProvider> {
+  const useLive = String(((globalThis as any).process?.env?.USE_LIVE_ORD_PROVIDER) || '').toLowerCase() === 'true';
+  if (useLive) {
+    const baseUrl = ((globalThis as any).process?.env?.ORD_PROVIDER_BASE_URL) || 'https://ord.example.com/api';
+    return new OrdHttpProvider({ baseUrl });
+  }
+  const mod = await import('./OrdMockProvider');
+  return new mod.OrdMockProvider();
+}
+

package/src/adapters/providers/OrdMockProvider.ts

@@ -0,0 +1,101 @@
+import { OrdinalsProvider } from '../types';
+
+export interface OrdMockState {
+  inscriptionsById: Map<string, {
+    inscriptionId: string;
+    content: Buffer;
+    contentType: string;
+    txid: string;
+    vout: number;
+    satoshi?: string;
+    blockHeight?: number;
+  }>;
+  inscriptionsBySatoshi: Map<string, string[]>;
+  feeRate: number;
+}
+
+export class OrdMockProvider implements OrdinalsProvider {
+  private state: OrdMockState;
+
+  constructor(state?: Partial<OrdMockState>) {
+    this.state = {
+      inscriptionsById: new Map(),
+      inscriptionsBySatoshi: new Map(),
+      feeRate: 5,
+      ...state
+    } as OrdMockState;
+  }
+
+  async getInscriptionById(id: string) {
+    const rec = this.state.inscriptionsById.get(id);
+    return rec ? { ...rec } : null;
+  }
+
+  async getInscriptionsBySatoshi(satoshi: string) {
+    const list = this.state.inscriptionsBySatoshi.get(satoshi) || [];
+    return list.map((inscriptionId) => ({ inscriptionId }));
+  }
+
+  async broadcastTransaction(_txHexOrObj: unknown): Promise<string> {
+    return 'mock-broadcast-txid';
+  }
+
+  async getTransactionStatus(txid: string) {
+    return { confirmed: true, blockHeight: 1, confirmations: 1 };
+  }
+
+  async estimateFee(blocks = 1): Promise<number> {
+    return Math.max(1, this.state.feeRate - (blocks - 1));
+  }
+
+  async createInscription(params: { data: Buffer; contentType: string; feeRate?: number; }) {
+    const inscriptionId = `insc-${Math.random().toString(36).slice(2)}`;
+    const txid = `tx-${Math.random().toString(36).slice(2)}`;
+    // Generate a valid numeric satoshi identifier (not sat-123 format)
+    const satoshi = `${Math.floor(Math.random() * 1e12)}`;
+    const vout = 0;
+    const record = {
+      inscriptionId,
+      content: params.data,
+      contentType: params.contentType,
+      txid,
+      vout,
+      satoshi,
+      blockHeight: 1
+    };
+    this.state.inscriptionsById.set(inscriptionId, record);
+    const list = this.state.inscriptionsBySatoshi.get(satoshi) || [];
+    list.push(inscriptionId);
+    this.state.inscriptionsBySatoshi.set(satoshi, list);
+    return {
+      inscriptionId,
+      revealTxId: txid,
+      commitTxId: undefined,
+      satoshi,
+      txid,
+      vout,
+      blockHeight: 1,
+      content: params.data,
+      contentType: params.contentType,
+      feeRate: params.feeRate
+    };
+  }
+
+  async transferInscription(inscriptionId: string, _toAddress: string, _options?: { feeRate?: number }) {
+    const rec = this.state.inscriptionsById.get(inscriptionId);
+    if (!rec) {
+      return Promise.reject(new Error('inscription not found'));
+    }
+    const txid = `tx-${Math.random().toString(36).slice(2)}`;
+    return {
+      txid,
+      vin: [{ txid: rec.txid, vout: rec.vout }],
+      vout: [{ value: 546, scriptPubKey: 'script' }],
+      fee: 100,
+      blockHeight: 1,
+      confirmations: 0,
+      satoshi: rec.satoshi
+    };
+  }
+}
+

package/src/adapters/types.ts

@@ -0,0 +1,66 @@
+export interface StoragePutOptions {
+  contentType?: string;
+  cacheControl?: string;
+}
+
+export interface StorageGetResult {
+  content: Buffer;
+  contentType: string;
+}
+
+export interface StorageAdapter {
+  put(objectKey: string, data: Buffer | string, options?: StoragePutOptions): Promise<string>;
+  get(objectKey: string): Promise<StorageGetResult | null>;
+  delete?(objectKey: string): Promise<boolean>;
+}
+
+export interface FeeOracleAdapter {
+  // Returns sats/vB (or feerate unit appropriate to the network) for the given target blocks
+  estimateFeeRate(targetBlocks?: number): Promise<number>;
+}
+
+export interface OrdinalsProvider {
+  getInscriptionById(id: string): Promise<{
+    inscriptionId: string;
+    content: Buffer;
+    contentType: string;
+    txid: string;
+    vout: number;
+    satoshi?: string;
+    blockHeight?: number;
+  } | null>;
+  getInscriptionsBySatoshi(satoshi: string): Promise<Array<{ inscriptionId: string }>>;
+  broadcastTransaction(txHexOrObj: unknown): Promise<string>;
+  getTransactionStatus(txid: string): Promise<{ confirmed: boolean; blockHeight?: number; confirmations?: number }>;
+  estimateFee(blocks?: number): Promise<number>;
+  createInscription(params: {
+    data: Buffer;
+    contentType: string;
+    feeRate?: number;
+  }): Promise<{
+    inscriptionId: string;
+    revealTxId: string;
+    commitTxId?: string;
+    satoshi?: string;
+    txid?: string;
+    vout?: number;
+    blockHeight?: number;
+    content?: Buffer;
+    contentType?: string;
+    feeRate?: number;
+  }>;
+  transferInscription(
+    inscriptionId: string,
+    toAddress: string,
+    options?: { feeRate?: number }
+  ): Promise<{
+    txid: string;
+    vin: Array<{ txid: string; vout: number }>;
+    vout: Array<{ value: number; scriptPubKey: string; address?: string }>;
+    fee: number;
+    blockHeight?: number;
+    confirmations?: number;
+    satoshi?: string;
+  }>;
+}
+