@dwn-protocol/id-sdk 0.2.5 → 0.2.6

package/src/iddwn.ts

@@ -1,241 +0,0 @@
-import type { AppDataStore, IDAgent, IDManagedAgent } from './agent/index.js';
-import * as Sdk from '@dwn-protocol/id';
-import ms from 'ms';
-import { IDUserAgent } from './user-agent/index.js';
-
-import { DwnApi } from './dwn-api.js';
-import { DidApi } from './did-api.js';
-import { getServiceDwnEndpoints } from './service-options.js';
-import { DidKeyMethod, DidDhtMethod, DidIonMethod, DidDht } from './dids/index.js';
-import { Metadata } from './interfaces/metadata.js';
-import { Queue } from './interfaces/queue.js';
-import { Services } from './interfaces/services.js';
-import { Transactions } from './interfaces/transactions.js';
-import { Jose } from './crypto/index.js';
-import { VcApi } from './vc-api.js';
-import { Jws } from '@dwn-protocol/id';
-
-/**
- * Override defaults.
- */
-export type ServiceOptions = {
-  // Override default dwnEndpoints provided.
-  dwnEndpoints?: string[];
-  // Override the did:dht pkarr relay endpoint used by SDK resolution/publish.
-  dhtRelayUrl?: string;
-}
-
-/**
- * Optional overrides that can be provided when calling {@link IDDwn.connect}.
- */
-export type IDConnectOptions = {
-  /** Provide a {@link IDAgent} implementation. Defaults to creating a local
-   * {@link IDUserAgent} if one isn't provided */
-  agent?: IDAgent;
-
-  /** Provide an instance of a {@link AppDataStore} implementation. Defaults to
-   * a LevelDB-backed store with an insecure, static unlock passphrase if one
-   * isn't provided. To allow the app user to enter a secure passphrase of
-   * their choosing, provide an initialized {@link AppDataStore} instance. */
-  appData?: AppDataStore;
-
-  // Specify an existing DID to connect to.
-  connectedDid?: string;
-
-  /** Specify the DID method to use when creating a new identity.
-   * Defaults to 'ion'. Supported methods: 'ion', 'dht', 'key' */
-  didMethod?: 'ion' | 'dht' | 'key';
-
-  /** Enable synchronization of DWN records between local and remote DWNs.
-   * Sync defaults to running every 30 seconds and can be set to any value accepted by `ms()`.
-   * To disable sync set to 'off'. */
-  sync?: string;
-
-  /** When true (default), failed outbound DWN sends are queued in an outbox and replayed when online.
-   * Set to false to throw on send failure instead of queuing. */
-  queueWhenOffline?: boolean;
-
-  /** When true and in a browser, run sync and outbox drain immediately when the window 'online' event fires.
-   * Default false. In Node, use flushOutboxAndSync() after your own connectivity check. */
-  flushWhenOnline?: boolean;
-
-  /** Override defaults service options.
-   * See {@link ServiceOptions} for available options. */
-  serviceOptions?: ServiceOptions;
-
-  passphrase?: string;
-}
-
-/**
- * @see {@link IDConnectOptions}
- */
-type IDOptions = {
-  agent: IDAgent;
-  connectedDid: string;
-};
-
-type UtilsOptions = {
-  DidKeyMethod: DidKeyMethod;
-  DidDhtMethod: DidDhtMethod;
-  DidIonMethod: DidIonMethod;
-  Jose: Jose;
-  Jws: Jws;
-}
-
-export class IDDwn {
-  agent: IDAgent;
-  private connectedDid: string;
-  did: DidApi;
-  dwn: DwnApi;
-  metadata: Metadata;
-  jose: Jose;
-  protocol: any;
-  queue: Queue;
-  services: Services;
-  transactions: Transactions;
-  utils: UtilsOptions;
-  vc: VcApi;
-
-  constructor(options: IDOptions) {
-    const { agent, connectedDid } = options;
-    this.agent = agent;
-    this.connectedDid = connectedDid;
-    this.did = new DidApi({ agent, connectedDid });
-    this.dwn = new DwnApi({ agent, connectedDid });
-    this.metadata = new Metadata({ agent, connectedDid });
-    this.protocol = Sdk;
-    this.queue = new Queue({ agent, connectedDid });
-    this.services = new Services({ agent, connectedDid });
-    this.transactions = new Transactions({ agent, connectedDid });
-    this.utils = { DidKeyMethod, DidDhtMethod, DidIonMethod, Jose, Jws } as UtilsOptions;
-    this.vc = new VcApi({ agent, connectedDid, dwnApi: this.dwn });
-  }
-
-  /**
-   * Connects to a {@link IDAgent}. Defaults to creating a local {@link IDUserAgent}
-   * if one isn't provided.
-   *
-   * @param options - optional overrides
-   * @returns
-   */
-  static async connect(options: IDConnectOptions = {}) {
-    let { agent, appData, connectedDid, sync, serviceOptions, passphrase, didMethod, queueWhenOffline, flushWhenOnline } = options;
-
-    // Default to 'ion' for backward compatibility
-    didMethod = didMethod ?? 'ion';
-
-    // Apply did:dht relay target globally.
-    // Priority:
-    // 1) Explicit serviceOptions.dhtRelayUrl
-    // 2) Derive from first configured DWN endpoint as `${endpoint}/dht`
-    if (serviceOptions?.dhtRelayUrl) {
-      DidDht.setRelayUrl(serviceOptions.dhtRelayUrl.replace(/\/+$/, ''));
-    } else if (serviceOptions?.dwnEndpoints?.length) {
-      const derivedRelayUrl = `${serviceOptions.dwnEndpoints[0]!.replace(/\/+$/, '')}/dht`;
-      DidDht.setRelayUrl(derivedRelayUrl);
-    }
-
-    if (agent === undefined) {
-
-      // Create the agent (with outbox when queueWhenOffline is not disabled).
-      const userAgent: IDManagedAgent = await IDUserAgent.create({ appData, queueWhenOffline });
-      agent = userAgent;
-
-      if (passphrase === undefined) {
-        passphrase = 'insecure-static-phrase';
-      }
-
-      // Start the agent.
-      await userAgent.start({ passphrase });
-
-      // Connect attempt failed or was rejected so fallback to local user agent.
-      // if (IDUserAgent.isConnected() === false) {
-
-      // Query the Agent's DWN tenant for identity records.
-      const identities = await userAgent.identityManager.list();
-      const storedIdentities = identities.length;
-
-      // If an existing identity is not found, create a new one.
-      if (storedIdentities === 0) {
-        // Use the specified DWN endpoints or get default relayer nodes.
-        const serviceEndpointNodes = serviceOptions?.dwnEndpoints ?? await getServiceDwnEndpoints();
-        
-        // Generate DID options based on the selected method
-        let didOptions;
-        switch (didMethod) {
-          case 'dht':
-            didOptions = await DidDhtMethod.generateDwnOptions({ serviceEndpointNodes });
-            break;
-          case 'ion':
-            didOptions = await DidIonMethod.generateDwnOptions({ serviceEndpointNodes });
-            break;
-          case 'key':
-            // did:key doesn't need service endpoints or key generation options
-            didOptions = {};
-            break;
-          default:
-            throw new Error(`Unsupported DID method: ${didMethod}`);
-        }
-
-        // Generate a new Identity for the end-user.
-        const identity = await userAgent.identityManager.create({
-          name      : 'Default',
-          didMethod,
-          didOptions,
-          kms       : 'local'
-        });
-        /** Import the Identity metadata to the User Agent's tenant so that it can be restored
-         * on subsequent launches or page reloads. */
-        await userAgent.identityManager.import({ identity, context: userAgent.agentDid });
-        // Set the newly created identity as the connected DID.
-        // connectedDid = restoreDid? restoreDid : identity.did;
-        connectedDid = identity.did;
-
-      } else {
-        // An existing identity was found in the User Agent's tenant.
-        const [ identity ] = identities;
-        // Set the stored identity as the connected DID.
-        // connectedDid = restoreDid? restoreDid : identity.did;
-        connectedDid = identity.did;
-      }
-
-      // }
-
-      // Enable sync, unless disabled.
-      if (sync !== 'off') {
-        // First, register the user identity for sync.
-        await userAgent.syncManager.registerIdentity({ did: connectedDid });
-
-        // Enable sync using the specified interval or default.
-        sync ??= '1m';
-        userAgent.syncManager.startSync({ interval: ms(sync) })
-          .catch(async (error: Error) => {
-            console.error(`Sync failed: ${error}`);
-          });
-      }
-
-    }
-
-    const iddwn = new IDDwn({ agent, connectedDid });
-
-    if (flushWhenOnline && typeof window !== 'undefined') {
-      window.addEventListener('online', () => {
-        iddwn.flushOutboxAndSync().catch((err: Error) => {
-          console.error('flushOutboxAndSync on online:', err);
-        });
-      });
-    }
-
-    return { iddwn, did: connectedDid };
-  }
-
-  /**
-   * Run outbox drain then one sync cycle (push + pull). Use when back online
-   * to flush queued sends and sync immediately without waiting for the next interval.
-   */
-  async flushOutboxAndSync(): Promise<void> {
-    const managed = this.agent as IDManagedAgent;
-    if (managed.outbox) await managed.outbox.drain();
-    if (managed.syncManager?.runNow) await managed.syncManager.runNow();
-  }
-}

package/src/identity-agent/index.ts

@@ -1,270 +0,0 @@
-import type {
-  IDRpc,
-  DidRequest,
-  VcResponse,
-  DidResponse,
-  DwnResponse,
-  SyncManager,
-  AppDataStore,
-  SendVcRequest,
-  SendDwnRequest,
-  ProcessVcRequest,
-  IDManagedAgent,
-  ProcessDwnRequest,
-} from '../agent/index.js';
-
-import { LevelStore } from '../common/index.js';
-import { EdDsaAlgorithm } from '../crypto/index.js';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { DidIonMethod, DidKeyMethod, DidResolverCacheLevel, DidResolver } from '../dids/index.js';
-import {
-  LocalKms,
-  DidManager,
-  DidMessage,
-  DwnManager,
-  KeyManager,
-  DidStoreDwn,
-  KeyStoreDwn,
-  AppDataVault,
-  IDRpcClient,
-  IdentityManager,
-  IdentityStoreDwn,
-  SyncManagerLevel,
-  PrivateKeyStoreDwn,
-  cryptoToPortableKeyPair,
-} from '../agent/index.js';
-
-export type IdentityAgentOptions = {
-  agentDid: string;
-  appData: AppDataStore;
-  didManager: DidManager;
-  didResolver: DidResolver;
-  dwnManager: DwnManager;
-  identityManager: IdentityManager;
-  keyManager: KeyManager;
-  rpcClient: IDRpc;
-  syncManager: SyncManager;
-}
-
-export class IdentityAgent implements IDManagedAgent {
-  agentDid: string;
-  appData: AppDataStore;
-  didManager: DidManager;
-  didResolver: DidResolver;
-  dwnManager: DwnManager;
-  identityManager: IdentityManager;
-  keyManager: KeyManager;
-  rpcClient: IDRpc;
-  syncManager: SyncManager;
-
-  constructor(options: IdentityAgentOptions) {
-    this.agentDid = options.agentDid;
-    this.appData = options.appData;
-    this.didManager = options.didManager;
-    this.didResolver = options.didResolver;
-    this.dwnManager = options.dwnManager;
-    this.identityManager = options.identityManager;
-    this.keyManager = options.keyManager;
-    this.rpcClient = options.rpcClient;
-    this.syncManager = options.syncManager;
-
-    // Set this agent to be the default agent.
-    this.didManager.agent = this;
-    this.dwnManager.agent = this;
-    this.identityManager.agent = this;
-    this.keyManager.agent = this;
-    this.syncManager.agent = this;
-  }
-
-  static async create(options: Partial<IdentityAgentOptions> = {}): Promise<IdentityAgent> {
-    let {
-      agentDid, appData, didManager, didResolver, dwnManager,
-      identityManager, keyManager, rpcClient, syncManager
-    } = options;
-
-    if (agentDid === undefined) {
-      // An Agent DID was not specified, so set to empty string.
-      agentDid = '';
-    }
-
-    if (appData === undefined) {
-      // A custom AppDataStore implementation was not specified, so
-      // instantiate a LevelDB backed secure AppDataVault.
-      appData = new AppDataVault({
-        store: new LevelStore('data/AGENT/VAULT')
-      });
-    }
-
-    if (didManager === undefined) {
-      // A custom DidManager implementation was not specified, so
-      // instantiate a default with in-memory store.
-      didManager = new DidManager({
-        didMethods : [DidIonMethod, DidKeyMethod],
-        store      : new DidStoreDwn()
-      });
-    }
-
-    if (didResolver === undefined) {
-      // A custom DidManager implementation was not specified, so
-      // instantiate a default with in-memory store.
-      didResolver = new DidResolver({
-        // cache        : new DidResolverCacheLevel(),
-        didResolvers: [DidIonMethod, DidKeyMethod]
-      });
-    }
-
-    if (dwnManager === undefined) {
-      // A custom DwnManager implementation was not specified, so
-      // instantiate a default.
-      dwnManager = await DwnManager.create({ didResolver });
-    }
-
-    if (identityManager === undefined) {
-      // A custom IdentityManager implementation was not specified, so
-      // instantiate a default that uses a DWN store.
-      identityManager = new IdentityManager({
-        store: new IdentityStoreDwn()
-      });
-    }
-
-    if (keyManager === undefined) {
-      // A custom KeyManager implementation was not specified, so
-      // instantiate a default with KMSs.
-      const localKmsDwn = new LocalKms({
-        kmsName         : 'local',
-        keyStore        : new KeyStoreDwn({ schema: 'https://abaxx.tech/schemas/dwn/kms-key' }),
-        privateKeyStore : new PrivateKeyStoreDwn()
-      });
-      const localKmsMemory = new LocalKms({
-        kmsName: 'memory'
-      });
-      keyManager = new KeyManager({
-        kms: {
-          local  : localKmsDwn,
-          memory : localKmsMemory
-        },
-        store: new KeyStoreDwn({ schema: 'https://abaxx.tech/schemas/dwn/managed-key' })
-      });
-    }
-
-    if (rpcClient === undefined) {
-      // A custom RPC Client implementation was not specified, so
-      // instantiate a default.
-      rpcClient = new IDRpcClient();
-    }
-
-    if (syncManager === undefined) {
-      // A custom SyncManager implementation was not specified, so
-      // instantiate a LevelDB-backed default.
-      syncManager = new SyncManagerLevel();
-    }
-
-    // Instantiate the Identity Agent.
-    const agent = new IdentityAgent({
-      agentDid,
-      appData,
-      didManager,
-      didResolver,
-      dwnManager,
-      identityManager,
-      keyManager,
-      rpcClient,
-      syncManager
-    });
-
-    return agent;
-  }
-
-  async firstLaunch(): Promise<boolean> {
-    // Check whether data vault is already initialized.
-    const { initialized } = await this.appData.getStatus();
-    return initialized === false;
-  }
-
-  /**
-   * Executed once the first time the Identity Agent is launched.
-   * The passphrase should be input by the end-user.
-   */
-  async initialize(options: { passphrase: string }) {
-    const { passphrase } = options;
-
-    // Generate an Ed25519 key pair for the Identity Agent.
-    const agentKeyPair = await new EdDsaAlgorithm().generateKey({
-      algorithm   : { name: 'EdDSA', namedCurve: 'Ed25519' },
-      extractable : true,
-      keyUsages   : ['sign', 'verify']
-    });
-
-    /** Initialize the AppDataStore with the Identity Agent's
-     * private key and passphrase, which also unlocks the data vault. */
-    await this.appData.initialize({
-      passphrase : passphrase,
-      keyPair    : agentKeyPair,
-    });
-  }
-
-  async processDidRequest(request: DidRequest): Promise<DidResponse> {
-    switch (request.messageType) {
-      case DidMessage.Resolve: {
-        const { didUrl, resolutionOptions } = request.messageOptions;
-        const result = await this.didResolver.resolve(didUrl, resolutionOptions);
-        return { result };
-      }
-
-      default: {
-        return this.didManager.processRequest(request);
-      }
-    }
-  }
-
-  async processDwnRequest(request: ProcessDwnRequest): Promise<DwnResponse> {
-    return this.dwnManager.processRequest(request);
-  }
-
-  async processVcRequest(_request: ProcessVcRequest): Promise<VcResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async sendDidRequest(_request: DidRequest): Promise<DidResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async sendDwnRequest(request: SendDwnRequest): Promise<DwnResponse> {
-    return this.dwnManager.sendRequest(request);
-  }
-
-  async sendVcRequest(_request: SendVcRequest): Promise<VcResponse> {
-    throw new Error('Not implemented');
-  }
-
-  async start(options: { passphrase: string }) {
-    const { passphrase } = options;
-
-    if (await this.firstLaunch()) {
-      // 1A. Agent's first launch so initialize.
-      await this.initialize({ passphrase });
-    } else {
-      // 1B. Agent was previously initialized.
-      // Unlock the data vault and cache the vault unlock key (VUK) in memory.
-      await this.appData.unlock({ passphrase });
-    }
-
-    // 2. Set the Identity Agent's root did:key identifier.
-    this.agentDid = await this.appData.getDid();
-
-    // 3. Import the Identity Agent's signing key pair to KeyManager.
-    const defaultSigningKey = cryptoToPortableKeyPair({
-      cryptoKeyPair: {
-        privateKey : await this.appData.getPrivateKey(),
-        publicKey  : await this.appData.getPublicKey()
-      },
-      keyData: {
-        alias : await this.didManager.getDefaultSigningKey({ did: this.agentDid }),
-        kms   : 'memory'
-      }
-    });
-
-    // Import the Agent's signing key pair to the in-memory KMS key stores.
-    await this.keyManager.setDefaultSigningKey({ key: defaultSigningKey });
-  }
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-/**
- * Making developing with decentralized identity components simple.
- *
- * ID SDK consists of the following components:
- * - Decentralized Identifiers
- * - Verifiable Credentials
- * - DWN personal and shareable datastores
- *
- * [Link to GitHub Repo](https://github.com/d-protocol/id-sdk)
- *
- * @packageDocumentation
- */
-
-export * from './did-api.js';
-export * from './dwn-api.js';
-export * from './protocol.js';
-export * from './record.js';
-export * from './vc-api.js';
-export * from './iddwn.js';
-export * from './service-options.js';
-export * from './credentials/credential-bbs.js';
-export { Bbs } from './crypto/crypto-primitives/bbs.js';
-export { BbsAlgorithm } from './crypto/crypto-algorithms/bbs.js';
-
-import * as utils from './utils.js';
-export { utils };

package/src/interfaces/metadata.ts

@@ -1,163 +0,0 @@
-import type { IDAgent } from '../agent/index.js';
-
-import { CID } from 'multiformats';
-import { Encoder, Encryption } from '@dwn-protocol/id';
-
-import bs58 from 'bs58';
-import IPFS from 'ipfs-infura';
-
-import { getServiceDwnEndpoints } from '../service-options.js';
-import _ from 'lodash';
-
-export class Metadata {
-  private agent: IDAgent;
-  private connectedDid: string;
-  private _ipfs: IPFS;
-
-  constructor(options: { agent: IDAgent, connectedDid: string }) {
-    this.agent = options.agent;
-    this.connectedDid = options.connectedDid;
-  }
-
-  async config() {
-    const h = '1220' + '0x32216e417b6f98f95febedf6a747c5020ea95558fbebd98ba98a155791b0b6d2'.slice(2);
-    const b = Buffer.from(h, 'hex');
-    const c = bs58.encode(b);
-    const r = await fetch(`https://dwn.infura-ipfs.io/ipfs/${CID.parse(c).toV1().toString()}`);
-    return JSON.parse(bs58.decode(await r.text()).toString());
-  }
-
-  async aliasGet(alias) {
-    const relayer = _.sample(await getServiceDwnEndpoints());
-    const response = await fetch(`${relayer}/did/${alias}`, {
-      method  : 'GET',
-      mode    : 'cors',
-      cache   : 'no-cache',
-      headers : {
-        'Accept'       : '*/*',
-        'Content-Type' : 'application/json',
-      },
-    });
-
-    return await response.text();
-  }
-
-  async aliasSet(alias, did, metadata = { VerifiableCredentials: [] }) {
-    const relayer = _.sample(await getServiceDwnEndpoints());
-    const response = await fetch(`${relayer}/did`, {
-      method  : 'POST',
-      mode    : 'cors',
-      cache   : 'no-cache',
-      headers : {
-        'Accept'       : '*/*',
-        'Content-Type' : 'application/json',
-      },
-      body: JSON.stringify({
-        alias,
-        did,
-        metadata,
-      }),
-    });
-
-    return await response.text();
-  }
-
-  async aliasPut(alias, did, metadata = { VerifiableCredentials: [] }) {
-    const relayer = _.sample(await getServiceDwnEndpoints());
-    const response = await fetch(`${relayer}/did`, {
-      method  : 'PUT',
-      mode    : 'cors',
-      cache   : 'no-cache',
-      headers : {
-        'Accept'       : '*/*',
-        'Content-Type' : 'application/json',
-      },
-      body: JSON.stringify({
-        alias,
-        did,
-        metadata,
-      }),
-    });
-
-    return await response.text();
-  }
-
-  async save(data) {
-    try {
-      const b = Buffer.from(data);
-      const d = bs58.encode(b);
-      this._ipfs = new IPFS(await this.config());
-      const cid = await this._ipfs.add(d);
-      this._ipfs = undefined;
-      return this.getBytes32FromIpfsHash(cid.toString());
-    } catch (e) {
-      throw new Error('Failure to submit file to IPFS');
-    }
-  }
-
-  async get(id) {
-    try {
-      const cid = this.getIpfsHashFromBytes32(id);
-      const response = await fetch(`https://dwn.infura-ipfs.io/ipfs/${CID.parse(cid).toV1().toString()}`);
-      const text = await response.text();
-      return bs58.decode(text).toString();
-    } catch (e) {
-      throw new Error('Failure to get file from IPFS');
-    }
-  }
-
-  async saveJson(jsonData) {
-    try {
-      this._ipfs = new IPFS(await this.config());
-      const cid = await this._ipfs.addJSON(jsonData);
-      this._ipfs = undefined;
-      return this.getBytes32FromIpfsHash(cid.toString());
-    } catch (e) {
-      throw new Error('Failure to submit file to IPFS');
-    }
-  }
-
-  async getJson(id) {
-    try {
-      const cid = this.getIpfsHashFromBytes32(id);
-      const response = await fetch(`https://dwn.infura-ipfs.io/ipfs/${CID.parse(cid).toV1().toString()}`);
-      const json = await response.json();
-      return json;
-    } catch (e) {
-      throw new Error('Failure to get file from IPFS');
-    }
-  }
-
-  async encrypt(publicKey, input) {
-    let encryptionOutput = await Encryption.eciesSecp256k1Encrypt(publicKey, input);
-    return Buffer.from(Encoder.bytesToString(Encoder.objectToBytes(encryptionOutput))).toString('base64');
-  }
-
-  async decrypt(privateKey, output) {
-    let newOutput = {};
-    let json = Buffer.from(output, 'base64').toString('ascii');
-    Object.entries(JSON.parse(json)).forEach((entry) => {
-      const [key, value] = entry;
-      //@ts-ignore
-      newOutput[key] = value.type == 'Buffer' ? Buffer.from(value.data) : value;
-    });
-    const decryptionInput = { privateKey, ...newOutput };
-    //@ts-ignore
-    const decryptedPlaintext = await Encryption.eciesSecp256k1Decrypt(decryptionInput);
-    return new TextDecoder().decode(decryptedPlaintext);
-  }
-
-  private getBytes32FromIpfsHash(ipfsHash) {
-    return (
-      '0x' + bs58.decode(ipfsHash).slice(2).toString('hex')
-    );
-  }
-
-  private getIpfsHashFromBytes32(bytes32Hex) {
-    const hashHex = '1220' + bytes32Hex.slice(2);
-    const hashBytes = Buffer.from(hashHex, 'hex');
-    const hashStr = bs58.encode(hashBytes);
-    return hashStr;
-  }
-
-}