Better still
I think this code will create so called "deterministic key" that will always be the same,
so no point migrating nothing when you can create key from password each time user logs in.
Same idea behind this: https://keybase.io/warp/

// cdn.jsdelivr.net/npm/node-forge@1.3.0/dist/forge.min.js
// unpkg.com/ipfs@0.55.4/dist/index.min.js
// unpkg.com/orbit-db@0.26.1/dist/orbitdb.js

var password = 'mystrongpassword';
var md = forge.md.sha256.create();
md.update(password);
var seed = md.digest().data
var ed25519 = forge.pki.ed25519;
var keypair = ed25519.generateKeyPair({seed: seed});

class MyIdentityProvider extends OrbitDB.Identities.IdentityProvider {
  static get type () { return 'MyIdentityType' } // return type
  async getId () {

    return Buffer.from(keypair.publicKey).toString('hex')
   } // return identifier of external id (eg. a public key)
    async signIdentity (data) {

    var signature = ed25519.sign({
      message: data,
      // also accepts `binary` if you want to pass a binary string
      encoding: 'utf8',
      // node.js Buffer, Uint8Array, forge ByteBuffer, binary string
      privateKey: keypair.privateKey
    });

    signature = forge.util.bytesToHex(signature)

    return signature

   } //return a signature of data (signature of the OrbtiDB public key)
  static async verifyIdentity (identity) {

    // verify a signature on a UTF-8 message
    return ed25519.verify({
      message: identity.publicKey + identity.signatures.id,
      encoding: 'utf8',
      signature: forge.util.hexToBytes(identity.signatures.publicKey),
      publicKey: forge.util.hexToBytes(identity.id)
    })
    // `verified` is true/false

  } //return true if identity.sigantures are valid
}

OrbitDB.Identities.addIdentityProvider(MyIdentityProvider)

OrbitDB.Identities.createIdentity({ type: `MyIdentityType`, id: 'myId' }).then(function(e){
  
})

importing identity #54

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions