• Stars
    star
    139
  • Rank 262,954 (Top 6 %)
  • Language
    JavaScript
  • License
    Apache License 2.0
  • Created over 3 years ago
  • Updated 8 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Tools and utilities to make working with the ION network and using ION DIDs easy peasy lemon squeezy

ION Tools

This repo includes tools and utilities to make working with the ION network and using ION DIDs easy for developers integrating DIDs into their apps and services. The packages within are geared toward making interactions with ION maximally accessible for developers, with a primary focus on making their functionality dually available in both client Web and server environments.

Installation

npm install @decentralized-identity/ion-tools

πŸ’‘ Note: Browser bundles are included in package under dist/browser.

Additional Setup

This package depends on the @noble/ed25519 and @noble/secp256k1 v2, thus additional steps are needed for some environments:

// node.js 18 and earlier, needs globalThis.crypto polyfill
import { webcrypto } from 'node:crypto';
// @ts-ignore
if (!globalThis.crypto) globalThis.crypto = webcrypto;

// React Native needs crypto.getRandomValues polyfill and sha256 for `@noble/secp256k1`
import 'react-native-get-random-values';
import { hmac } from '@noble/hashes/hmac';
import { sha256 } from '@noble/hashes/sha256';
secp.etc.hmacSha256Sync = (k, ...m) => hmac(sha256, k, secp.etc.concatBytes(...m));
secp.etc.hmacSha256Async = (k, ...m) => Promise.resolve(secp.etc.hmacSha256Sync(k, ...m));

// React Native needs crypto.getRandomValues polyfill and sha512 for `@noble/ed25519`
import 'react-native-get-random-values';
import { sha512 } from '@noble/hashes/sha512';
ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
ed.etc.sha512Async = (...m) => Promise.resolve(ed.etc.sha512Sync(...m));

Usage

Create ION DID

import { anchor, DID, generateKeyPair } from '@decentralized-identity/ion-tools';
import { writeFile } from 'fs/promises';

// Generate keys and ION DID
let authnKeys = await generateKeyPair();
let did = new DID({
  content: {
    publicKeys: [
      {
        id: 'key-1',
        type: 'EcdsaSecp256k1VerificationKey2019',
        publicKeyJwk: authnKeys.publicJwk,
        purposes: [ 'authentication' ]
      }
    ],
    services: [
      {
        id: 'domain-1',
        type: 'LinkedDomains',
        serviceEndpoint: 'https://foo.example.com'
      }
    ]
  }
});

// Generate and publish create request to an ION node
let createRequest = await did.generateRequest(0);
let anchorResponse = await anchor(createRequest);

// Store the key material and source data of all operations that have been created for the DID
let ionOps = await did.getAllOperations();
await writeFile('./ion-did-ops-v1.json', JSON.stringify({ ops: ionOps }));

Update ION DID

import { anchor, DID, generateKeyPair } from '@decentralized-identity/ion-tools';
import { readFile, writeFile } from 'fs/promises';

// Generate new keys
let authnKeys2 = await generateKeyPair();

// Instantiate DID using previously saved state
let ionOps;
await readFile('./ion-did-ops-v1.json', { encoding: 'utf8' })
  .then((data) => {
    ionOps = JSON.parse(data);
  })
  .catch((error) => {
    console.log(error);
    process.exit(1);
  });
let did = new DID(ionOps);

// Generate update operation to remove key-1, add key-2, remove some-service-1, and add some-service-2.
let updateOperation = await did.generateOperation('update', {
  removePublicKeys: ['key-1'],
  addPublicKeys: [
    {
      id: 'key-2',
      type: 'EcdsaSecp256k1VerificationKey2019',
      publicKeyJwk: authnKeys2.publicJwk,
      purposes: [ 'authentication' ]
    }
  ],
  removeServices: ['some-service-1'],
  addServices: [
    {
      'id': 'some-service-2',
      'type': 'SomeServiceType',
      'serviceEndpoint': 'http://www.example.com'
    }
  ]
});

// Generate and publish update request to an ION node
let updateRequest = await did.generateRequest(updateOperation);
let anchorRespons = await anchor(updateRequest);

// Store the revised key material and source data for the DID
ionOps = await did.getAllOperations();
await writeFile('./ion-did-ops-v2.json', JSON.stringify({ ops: ionOps }), { encoding: 'utf8' });

Contributing

git clone https://github.com/decentralized-identity/ion-tools
cd ion-tools
npm install

Available npm scripts

run npm run <script_name> to use any of the scripts listed in the table below:

script description
bundle generates and saves browser bundle to dist/browser-bundle.js
lint runs linter without auto-fixing
lint:fix runs linter and automatically fixes issues

API Reference

ION is a high-level library that wraps the lower-level ION SDK to make interfacing with ION components as simple as possible.

new DID()

The ION.DID class enables you to generate a fully usable ION DID in a single line of code. The class is invoked as follows:

import { DID, generateKeyPair } from '@decentralized-identity/ion-tools';

let authnKeys = await generateKeyPair();
let did = new DID({
  content: {
    publicKeys: [
      {
        id: 'key-1',
        type: 'EcdsaSecp256k1VerificationKey2019',
        publicKeyJwk: authnKeys.publicJwk,
        purposes: [ 'authentication' ]
      }
    ],
    services: [
      {
        id: 'domain-1',
        type: 'LinkedDomains',
        serviceEndpoint: 'https://foo.example.com'
      }
    ]
  }
});

The DID class provides the following methods:

getURI() async

The getURI method of the DID class is an async function that returns the URI string for the DID the class instance represents. There are two forms of ION DID URI, the Long-Form URI, which can be used instantly without anchoring an ION DID, and the Short-Form URI, which is only resolvable after a DID has been published to the ION network.

let did = new DID();
let longFormURI = await did.getURI();
let shortFormURI = await did.getURI('short');

getSuffix() async

The getSuffix method of the DID class is an async function that returns the suffix portion of the DID string for the DID URI the class instance represents.

let did = new DID();
// Example DID URI --> "did:ion:EiCZws6U61LV3YmvxmOIlt4Ap5RSJdIkb_lJXhuUPqQYBg"
let suffix = await did.getSuffix();
// Example suffix value --> "EiCZws6U61LV3YmvxmOIlt4Ap5RSJdIkb_lJXhuUPqQYBg"

generateOperation(TYPE, CONTENTS, COMMIT) async

The generateOperation method of the DID class is an async function that generates update, recover, and deactivate operations based on the current lineage of the DID instance. The method returns an operation entry that is appended to the DID operation lineage managed within the class. The function takes the following arguments:

  • type - String, required: the type of operation you want to generate. Supported operations are update, recover, deactivate.
  • contents - Object, optional: the content of a given operation type that should be reflected in the new DID state (examples below).
  • commit - Boolean, default: true: generated operations are automatically appended to the operation chain of the DID instance. If you do not want the operation added to the DID's chain of retained operations, pass an explicit false to leave the operation uncommitted.
let did = new DID();
let authnKeys2 = await generateKeyPair();

// UPDATE EXAMPLE

let updateOperation = await did.generateOperation('update', {
  removePublicKeys: ["key-1"],
  addPublicKeys: [
    {
      id: 'key-2',
      type: 'EcdsaSecp256k1VerificationKey2019',
      publicKeyJwk: authnKeys2.publicJwk,
      purposes: [ 'authentication' ]
    }
  ],
  removeServices: ['some-service-1'],
  addServices: [
    {
      'id': 'some-service-2',
      'type': 'SomeServiceType',
      'serviceEndpoint': 'http://www.example.com'
    }
  ]
});

// RECOVERY EXAMPLE

let authnKeys3 = await generateKeyPair();
let recoverOperation = await did.generateOperation('recover', {
  removePublicKeys: ['key-2'],
  addPublicKeys: [
    {
      id: 'key-3',
      type: 'EcdsaSecp256k1VerificationKey2019',
      publicKeyJwk: authnKeys3.publicJwk,
      purposes: [ 'authentication' ]
    }
  ],
  removeServices: ['some-service-2'],
  addServices: [
    {
      'id': 'some-service-3',
      'type': 'SomeServiceType',
      'serviceEndpoint': 'http://www.example.com'
    }
  ]
});

// DEACTIVATE EXAMPLE

let deactivateOperation = await did.generateOperation('deactivate');

generateRequest() async

The generateRequest method of the DID class is an async function that takes either a number, in reference to an operation index, or a direct operation payload and returns an operation request object that can be published via an ION node.

let did = new DID({ ... });
let request = await did.generateRequest(0); // 0 = Create, same as did.#ops[0]

RETURN VALUE:
{
  "type": "create",
  "suffixData": {
    "deltaHash": "EiDuQtYw8kc30k5nnIHcv870qkTCmCC6a4ghcXRjsgZQpw",
    "recoveryCommitment": "EiD9AtwEsDH7p963JPMk2CAzQyu-bT-V49j3_pyw-amSCg"
  },
  "delta": {
    "updateCommitment": "EiDEiLHSm7lcsVmk47wmVNUZASRcv49mSgr4KmW6tG37-w",
    "patches": [
      {
        "action": "replace",
        "document": {
          "publicKeys": [
            {
              "id": "key-1",
              "type": "EcdsaSecp256k1VerificationKey2019",
              "publicKeyJwk": {
                "kty": "EC",
                "crv": "secp256k1",
                "x": "bk7ApbCTcBAcRtfLK8bVFMQyhwLb6Rw47KoYnDeOq90",
                "y": "T8ElVBOT81E_E5jSg0U1iVqCj--brrjROedXFkehDv8"
              },
              "purposes": [
                "authentication"
              ]
            }
          ],
          "services": [
            {
              "id": "domain-1",
              "type": "LinkedDomains",
              "serviceEndpoint": "https://foo.example.com"
            }
          ]
        }
      }
    ]
  }
}

getState() async

The getState method of the DID class is an async function that returns the exported state of the DID instance, a JSON object composed of the following values:

  • shortForm - String: Short hash-based version of the DID URI string (only resolvable when anchored).
  • longForm - String: Fully self-resolving payload-embedded version of the DID URI string.
  • ops - Array: Exported array of all operations that have been included in the state chain of the DID (NOTE: reflection of operations in the network subject to inclusion via broadcast and anchoring).

getAllOperations() async

The getAllOperations method of the DID class is an async function that returns all operations that have been created for the DID the class instance represents. This is useful in storing the key material and source data of operation. (e.g. for wallets that need to output a static data representation of a DID's state)

let did = new DID({ ... });
let operations = await did.getAllOperations();

generateKeyPair() async

The generateKeyPair method is an async function that makes generation of keys effortless. The currently supported key types are secp256k1 and Ed25519 (more are in the process of being added).

Example:

let secp256k1KeyPair = await generateKeyPair('secp256k1');

RETURN VALUE:
{
  "publicJwk": {
    "crv": "secp256k1",
    "kty": "EC",
    "x": "L60Mcg_4uhbAO4RaL1eAJ5CKVqBD8cm6PrBuua4gyGA",
    "y": "wwVm2dFCamLZkpGTlRMhdASmPtWuPW9Eg1wLfziwEAs"
  },
  "privateJwk": {
    "crv": "secp256k1",
    "d": "kbnyOrsZGaslyeofzDYqMCibWzsRLJb7ZnnQ2rbdJLA",
    "kty": "EC",
    "x": "L60Mcg_4uhbAO4RaL1eAJ5CKVqBD8cm6PrBuua4gyGA",
    "y": "wwVm2dFCamLZkpGTlRMhdASmPtWuPW9Eg1wLfziwEAs"
  }
}

let Ed25519KeyPair = await generateKeyPair('Ed25519');

RETURN VALUE:
{
  "publicJwk": {
    "crv": "Ed25519",
    "x": "WfrBXcm2vliqsQtHBr6xIBXZHEtangbUnmxs2KT0VD0",
    "kty": "OKP"
  },
  "privateJwk": {
    "crv": "Ed25519",
    "d": "CsUUtvDcTM7EmoNuhLyeGQqSBmrpml1bUdjUAVJvj1I",
    "x": "WfrBXcm2vliqsQtHBr6xIBXZHEtangbUnmxs2KT0VD0",
    "kty": "OKP"
  }
}

sign(PARAMS)

The sign method generates a signed JWS output of a provided payload, and accepts the following parameters:

  1. PARAMS - Object, required: An object for passing the following properties used in the resolution request:
    • payload - required: The payload to be signed
    • privateJwk - Object, required: The JWK object for the private key that will be used to sign
    • header - Object, optional: Additional JWK header values.
import { generateKeyPair, sign } from '@decentralized-identity/ion-tools';

const { privateJwk } = await generateKeyPair();

const jws = await sign({ payload: 'hello world', privateJwk });

// RESULT
// eyJhbGciOiJFUzI1NksifQ.ImhlbGxvIHdvcmxkIg.NKRJVCjK2...

verify(PARAMS)

The verify method verifies a signed JWS output, and accepts the following parameters:

  1. PARAMS - Object, required: An object for passing the following properties used in the resolution request:
    • jws - String, required: The JWS to be verified.
    • publicJwk - Object, required: The JWK object for the public key that will be used to verify the JWS.
import { generateKeyPair, sign, verify } from '@decentralized-identity/ion-tools';

const { privateJwk, publicJwk } = await generateKeyPair();

const jws = await sign({ payload: 'hello world', privateJwk });
const isLegit = await verify({ jws, publicJwk }); // true/false

resolve(DID_URI, OPTIONS) async

The resolve library method resolves a DID URI string and returns the associated DID resolution response object. The method arguments are as follows:

  1. DID_URI - URI String, required
  2. OPTIONS - Object, optional: An object for passing the following options used in the resolution request:
    • nodeEndpoint - String, optional: URI of the node you desire to contact for resolution. If you are running your own node, use this to pass in your node's resolution endpoint.
import { DID, resolve } from '@decentralized-identity/ion-tools';

const did = new DID();
const longFormDID = await did.getURI();

const didDoc = await resolve(longFormDID);
console.log(didDoc);

/*
RETURN VALUE: 
{
  '@context': 'https://w3id.org/did-resolution/v1',
  didDocument: {
    id: 'did:ion:EiDERULqAU2ndqI2ha1RRrdJUf6Un0HpVqKhbNMJNUm0Rw:eyJkZWx0YSI6eyJwYXRjaGVzIjpbeyJhY3Rpb24iOiJyZXBsYWNlIiwiZG9jdW1lbnQiOnt9fV0sInVwZGF0ZUNvbW1pdG1lbnQiOiJFaUMtUHptOGpPcFh6TGJtbDNWdmNBcUVzOUFXRTQxSEF0WWdLXzd1Qm95R013In0sInN1ZmZpeERhdGEiOnsiZGVsdGFIYXNoIjoiRWlCSzFITU1rVmhoSkxpQ3k3OWFUd0tnam9mRDBOOHViQ19McmU2c2ZxZDRHdyIsInJlY292ZXJ5Q29tbWl0bWVudCI6IkVpQkhPU0hxZmFFaERjRDNtcFFLd0Y2aV9WTl9XclNwRmhlQlFyZ3ZCQ3FSVVEifX0',
    '@context': [ 'https://www.w3.org/ns/did/v1', [Object] ]
  },
  didDocumentMetadata: {
    method: {
      published: false,
      recoveryCommitment: 'EiBHOSHqfaEhDcD3mpQKwF6i_VN_WrSpFheBQrgvBCqRUQ',
      updateCommitment: 'EiC-Pzm8jOpXzLbml3VvcAqEs9AWE41HAtYgK_7uBoyGMw'
    },
    equivalentId: [ 'did:ion:EiDERULqAU2ndqI2ha1RRrdJUf6Un0HpVqKhbNMJNUm0Rw' ]
  }
}
*/

anchor(REQUEST_BODY, OPTIONS)

The anchor function is used to submit an ION operation for anchoring with an ION node that implements a challenge and response gated ION node endpoint. The class instantiation arguments are as follows:

  1. REQUEST_BODY - Object, required
  2. OPTIONS - Object, optional: An object for passing the following options used in the resolution request:
    • challengeEndpoint - URI String, optional: URI of the challenge endpoint for the ION node you are submitting to.
    • solutionEndpoint - URI String, optional: URI of the solution endpoint for the ION node you are submitting your completed challenge to.

NOTE: Endpoint URIs will default to https://beta.ion.msidentity.com if not supplied

const did = new DID();
const anchorRequest = await did.generateRequest();
const respone = await anchor(anchorRequest);

NOTE: The requestBody value above is the JSON representation of the ION operation produced by the DID class's generateRequest() function.

More Repositories

1

ion

The Identity Overlay Network (ION) is a DID Method implementation using the Sidetree protocol atop Bitcoin
HTML
1,225
star
2

universal-resolver

Universal Resolver implementation and drivers.
Java
545
star
3

sidetree

Sidetree Specification and Reference Implementation
HTML
438
star
4

decentralized-web-node

Decentralized data storage and message relay for decentralized identity and apps.
HTML
402
star
5

did-jwt

Create and verify DID verifiable JWT's in Javascript
TypeScript
335
star
6

did-resolver

Universal did-resolver for javascript environments
TypeScript
213
star
7

did-jwt-vc

Create and verify W3C Verifiable Credentials and Presentations in JWT format
TypeScript
179
star
8

ethr-did-resolver

DID resolver for Ethereum Addresses with support for key management
TypeScript
168
star
9

didcomm-messaging

JavaScript
163
star
10

github-did

Decentralized Identity with Github
JavaScript
139
star
11

element

DID Method implementation using the Sidetree protocol on top of Ethereum and IPFS
JavaScript
100
star
12

decentralized-identity.github.io

Site for the open source, community-driven group of dev and organizations working toward an interoperable, decentralized identity ecosystem
HTML
98
star
13

interoperability

The archive and information hub for the cross-community interoperability project. Focus is on education and familiarity for various efforts across multiple groups for interoperable decentralized identity infrastructure.
93
star
14

presentation-exchange

Specification that codifies an inter-related pair of data formats for defining proof presentations (Presentation Definition) and subsequent proof submissions (Presentation Submission)
JavaScript
85
star
15

confidential-storage

Confidential Storage Specification and Implementation
TypeScript
80
star
16

bbs-signature

The BBS Signature Scheme
Rust
76
star
17

keri

Key Event Receipt Infrastructure - the spec and implementation of the KERI protocol
HTML
72
star
18

web-did-resolver

DID resolver for HTTPS domains
TypeScript
70
star
19

universal-registrar

Universal Registrar implementation and drivers.
Java
64
star
20

DIDComm-js

JS implementation of pack and unpack
TypeScript
55
star
21

.well-known

Specs and documentation for all DID-related /.well-known resources
HTML
53
star
22

fuzzy-encryption

A variant of a Fuzzy Vault cryptographic scheme designed for encrypting data with better human recovery features.
C++
49
star
23

did-key.rs

Rust implementation of the did:key method
Rust
47
star
24

didcomm-rs

DIDComm messaging specifications implementation: https://identity.foundation/didcomm-messaging/spec/
Rust
46
star
25

keriox

Rust Implementation of the KERI Core Library
Rust
43
star
26

papers

Notes, ideas, and write-ups from DIF members and collaborators
40
star
27

org

DIF docs, wiki, and organizational material
Rich Text Format
39
star
28

did-auth-jose

JOSE-based implementation of DID Authenticated Encryption
TypeScript
39
star
29

did-common-java

Shared DID Java library.
Java
37
star
30

didcomm.org

TypeScript
36
star
31

did-siop

TypeScript
35
star
32

spec-up

Create beautiful, feature-rich technical specifications in markdown
HTML
32
star
33

credential-manifest

Format that normalizes the definition of requirements for the issuance of a credential
JavaScript
30
star
34

ion-sdk

TypeScript SDK for ION
TypeScript
29
star
35

keripy

Python Implementation of the KERI Core Libraries
Python
28
star
36

sidetree-ethereum

Blockchain-specific code for the Sidetree-based DID Method implementation on Ethereum
TypeScript
28
star
37

peer-did-method-spec

A rich DID method that has no blockchain dependencies. The verifiable data registry is a synchronization protocol between peers.
JavaScript
27
star
38

universal-resolver-frontend

Frontend web UI for Universal Resolver.
JavaScript
25
star
39

snark-credentials

25
star
40

identifiers-discovery

Identifiers & Discovery WG operating repo
21
star
41

trustdidweb

Trust DID Web (did:tdw)
18
star
42

waci-presentation-exchange

Wallet And Credential Interactions for Presentation Exchange (Work continues at decentralized-identity/waci-didcomm#1 )
HTML
17
star
43

did-common-dotnet

C#
17
star
44

did-methods

DID Method specs, docs, and materials
17
star
45

hub-node-core

Node.js implementation of the Identity Hub interfaces, business logic, and replication protocol.
TypeScript
17
star
46

lds-ecdsa-secp256k1-2019.js

EcdsaSecp256k1Signature2019 JSON-LD Signature Suite
TypeScript
17
star
47

vc-marketplace

To establish the reference architecture for a Verifiable Credentials Marketplace
HTML
16
star
48

didcomm-bluetooth

a specification that describes discovery and transport over Bluetooth for DIDcomm
16
star
49

horcrux

Horcrux Protocol
16
star
50

kerigo

Go implementation of KERI (Key Event Receipt Infrastructure)
Go
16
star
51

did-security-csharp

C# implementation of DID security and privacy controls
C#
15
star
52

claims-credentials

Claims and Credentials WG operations repo
15
star
53

uni-resolver-driver-did-ccp

A Universal Resolver driver for Baidu did:ccp identifiers.
Java
15
star
54

jwt-vc-presentation-profile

HTML
15
star
55

hub-reference

The official Identity Hub reference implementation bundle for Node.js
JavaScript
15
star
56

c19-vc.com

(DEMO) COVID-19 VC Issuer
JavaScript
14
star
57

didcomm-demo

In browser DIDComm v2 demo.
TypeScript
14
star
58

attestations

Attestation API implementations for various languages and platforms.
JavaScript
14
star
59

hub-sdk-js

JavaScript SDK for interacting with Identity Hubs
TypeScript
14
star
60

wallet-security

Define a common terminology for understanding the security requirements applicable to wallet architectures and wallet-to-wallet and wallet-to-issuer/verifier protocols.
14
star
61

crypto-wg

Meeting notes, transcripts previous agendas and active working group items
13
star
62

edv-spec

Encrypted Data Vault Spec
HTML
13
star
63

veramo-agent-deploy

Generic @veramo/cli agent deployment configuration https://veramo-agent.herokuapp.com
Dockerfile
12
star
64

waci-didcomm

Wallet And Credential Interactions for DIDComm
HTML
12
star
65

agent-explorer

Explore data accross multiple DID agents
TypeScript
12
star
66

uni-resolver-driver-did-ion

Universal Resolver Driver for Identity Overlay Network (ION) DIDs
C#
11
star
67

ion-cli

ION Command Line Interface to make working with the ION network and using ION DIDs easy peasy lemon squeezy
TypeScript
11
star
68

didcomm

11
star
69

did-siop-browser-ext

DID based SIOP
TypeScript
10
star
70

did-registration

A specification for DID create/update/deactivate operations.
HTML
10
star
71

kerijs

JavaScript (nodes) Implementation of the KERI core library.
JavaScript
10
star
72

go-ipfs-ds-azure

Go implementation of ipfs Azure datastore
Go
10
star
73

trust-establishment

https://identity.foundation/trust-establishment
10
star
74

dwn-user-guide

TypeScript
9
star
75

EcdsaSecp256k1RecoverySignature2020

EcdsaSecp256k1RecoverySignature2020
JavaScript
9
star
76

vc-spec-map

Verifiable Credentials Specification Relationship Map
9
star
77

JWS-Test-Suite

JsonWebSignature2020 Test Suite
JavaScript
9
star
78

universal-registrar-frontend

Frontend web UI for Universal Registrar.
JavaScript
8
star
79

presentation-exchange-implementations

Multi-language implementation of the Presentation Exchange protocol.
Go
8
star
80

jsonld-document-loader

TypeScript
8
star
81

wallet-rendering

Specifications for rendering DID and Credential-centric data in wallet applications
JavaScript
8
star
82

jsonld-common-java

Shared JSON-LD Java library.
Java
7
star
83

OpenPgpSignature2019

OpenPgpSignature2019 Linked Data Cryptographic Suite in JavaScript
JavaScript
7
star
84

didcomm-usergroup

DIDComm User Group
7
star
85

wallet-and-credential-interactions

QR Codes and Button for Claiming and Sharing Credentials (and more!)
HTML
7
star
86

schema-directory

A work item of the Claims and Credentials WG at DIF
HTML
7
star
87

did-common-typescript

A common bundle of shared code and modules for working with DIDs, DID Documents, and other DID-related activities
TypeScript
7
star
88

hub-sdk-js-sample

Sample app demonstrating use of the DIF Identity Hub JavaScript SDK.
TypeScript
7
star
89

authentication-wg

6
star
90

presentation-request

Requirements Analysis and Protocol Design for a VC Presentation Request Format
6
star
91

did-crypto-typescript

Crypto library to handle key management for DIDs
TypeScript
6
star
92

universal-wallet-backup-containers

A work Item within the DIF Wallet Security WG aimed to develop a specification for wallet containers
HTML
6
star
93

didcomm-book

5
star
94

universal-resolver-java

5
star
95

did-spec-extensions

Extension parameters, properties, and values for the DID spec registries.
JavaScript
5
star
96

sidetree-reference-impl

Sidetree Reference Implementation
TypeScript
5
star
97

linked-vp

Linked Verifiable Presentation
JavaScript
5
star
98

uni-resolver-driver-dns

A Universal Resolver driver for domain names.
Java
4
star
99

schema-forms

JSON Schema-driven form generator for the input and construction of credentials based on user input
JavaScript
4
star
100

SIG-IoT

DIF IoT Special Interest Group (Open Group)
CSS
4
star