Ana içeriğe geç

DID (Merkeziyetsiz Tanımlayıcılar) 🌐

Artık bir önceki açıklamada oluşturduğumuz hesap ile Attester için DID oluşturmaya başlayabiliriz. 🚀

DID'ler bir bireyi, organizasyonu veya makineyi ifade edebilir. 🧑‍🤝‍🧑🏢🤖

DID'ler Nedir? 🤔
  • Mevcut sistemimizde, dijital kimliğimiz için merkezi bir otoriteye (örneğin devlet 👮‍♂️) veya tekelleşmiş hizmetlere (Google, Facebook vb. 🏢) güvenmek zorundayız.
  • DID, Merkezsiz Tanımlayıcı anlamına gelir. DIDs ile kendi dijital geminizin kaptanı olabilirsiniz! ⚓️🔗
  • Gizliliği ve güvenliği artırır. 🕵️‍♂️🔒

KILT DID'leri her kullanıcıya özel olarak atanan özgün kimliklerdir. 🆔 DID'lerinizi KILT zinciri içerisinde depolayabilirsiniz. 🗃️

KILT DID Şifreleme Desteği 🔐
  • Authentication Keypair 🛡️
  • Key-agreement Keypair 🤝
  • Assertion-method Keypair ✅
  • Capability-delegation Keypair 📝

Account vs DID 🤷‍♂️​

DID'ler zincir üzerinde kayıt edilmek zorundadır. 📝 Her zaman bu işlemi gerçekleştirip deposito ödeyen ve bu sayede DID'i onaylama işlemine sokan bir hesap bulunmaktadır. 💰

DID Oluşturma 🛠️​

DID'ler Hep Aynı mı?

KILT içerisinde kullandığımız 2 adet DID çeşiti bulunmaktadır. Bunlardan biri Light DID olmaktayken diğeri Full DID olmaktadır.

Light DID

Aşağıda, hafif bir KILT DID örneği bulunmaktadır:

did:kilt:light:014nv4phaKc4EcwENdRERuMF79ZSSB5xvnAk3zNySSbVbXhSwS

Standart did:kilt: önekinin ötesinde, light: bileşeni bu DID'nin hafif bir DID olduğunu gösterir. Bu nedenle, çevrimdışı olarak çözümlenebilir ve kullanılabilir.

Hafif DIDs, desteklenen anahtar türlerinden birinin şifreleme anahtarı ve hizmetleri isteğe bağlı olarak destekler. Bunlar, DID'nin sonuna serileştirilir, kodlanır ve eklenir, şu şekildedir:

did:kilt:light:014nv4phaKc4EcwENdRERuMF79ZSSB5xvnAk3zNySSbVbXhSwS:z1ERkVVjngcarMbJn6YssB1PYULescQneSSEfCTJwYbzT2aK8fzH5WPsp3G4UVuLWWfsTayketnFV74YCnyboHBUvqEs6J8jdYY5dK2XeqCCs653Sf9XVH4RN2WvPrDFZXzzKf3KigvcaE7kkaEwLZvcas3U1M2ZDZCajDG71winwaRNrDtcqkJL9V6Q5yKNWRacw7hJ58d

Full DID

Yukarıda belirtildiği gibi, tam bir DID oluşturmak KILT blockchain ile etkileşim gerektirir. Bu nedenle, DID oluşturma işlemi, işlem ücretlerini ve gerekli depozitoyu ödemek için yeterli fonu olan bir KILT adresi tarafından gönderilmelidir.

Aşağıda, tam bir KILT DID örneği bulunmaktadır:

did:kilt:4rp4rcDHP71YrBNvDhcH5iRoM3YzVoQVnCZvQPwPom9bjo2e

Burada light: bileşeni yoktur, bu da DID'nin tam bir DID olduğunu ve bu DID ile ilişkilendirilen anahtarların DID tanımlayıcısından türetilmemesi, ancak KILT blockchain'den alınması gerektiğini gösterir.

Bir kimlik doğrulama anahtarı, bir şifreleme anahtarı ve hizmetlerin yanı sıra, tam bir DID ayrıca blockchain üzerinde CTypes ve onaylamaları yazmak için kullanılması gereken bir onaylama anahtarı ve blockchain üzerinde delegasyonları yazmak için kullanılması gereken bir delegasyon anahtarı da destekler.

alternative text

Biz Attester bireyinde zincir ile etkileşime geçeceğimiz için full DID oluşuturacağız.

DID oluşturmak için daha öncesinde hesap oluşturmak için kullandığımız keyring değerlerini yeniden kullanabiliriz. 🔄 Attester oluşturmak için 4 adet anahtara ihtiyaç duymaktayız. 🔑

Anahtar Çiftleri Oluşturma​

Modüllerin İçe Aktarılması​

attester/generateKeypairs.ts
import * as Kilt from '@kiltprotocol/sdk-js'
import {
  blake2AsU8a,
  keyExtractPath,
  keyFromPath,
  mnemonicGenerate,
  mnemonicToMiniSecret,
  sr25519PairFromSeed
} from '@polkadot/util-crypto'
import { generateAccount } from './generateAccount'

Diğer kodlarda da başladığımız üzere ilk olarak paketlerin proje içerisine eklenmesi ile başlıyoruz. Paketlerimize teker teker bakacak olursak:

  • İlk olarak KILT SDK fonskiyonlarına erişmek için sdk-js paketini kodumuzun içerisine ekleriz.
  • Sonrasında keypair çiftlerini oluşturmak için polkadot kütüphanesi içerisinden birkaç methoda erişiriz.
  • Son olarak bir önceki sayfada yazdığımız hesap oluşturma kodunun içerisinden export ettiğimiz generateAccount methoduna erişiriz.

generateKeyAgreement Fonksiyonu​

attester/generateKeypairs.ts
function generateKeyAgreement(mnemonic: string) {
  const secretKeyPair = sr25519PairFromSeed(mnemonicToMiniSecret(mnemonic))
  const { path } = keyExtractPath('//did//keyAgreement//0')
  const { secretKey } = keyFromPath(secretKeyPair, path, 'sr25519')
  return Kilt.Utils.Crypto.makeEncryptionKeypairFromSeed(blake2AsU8a(secretKey))
}

Paketlerimizi yükledikten sonra bu paketleri kullanarak anahtar çiftlerimizi oluşturmaya başlayabiliriz.

Bu işlemi gerçekleştirmek için bir fonksiyon yazarak işe başlayabiliriz. Bu fonskiyon içerisine mnemonic adı altında mnemonic hesap anahtarımızı alacaktır. İçerisindeki işlemlere teker teker bakılacak olunursa:

  • secretKeyPair: Mnemonic anahtarı fonksiyon içerisine girdik ancak bu anahtarı kullanarak hem public hemde private anahtarları elde etmemiz gerekmekte. Bu işlemi gerçekleştirmek için ilk olarak mnemonic anahtarımızı mnemonicToMiniSecret() fonksiyonu içerisine gireriz. Bu fonksiyon anahtarımızdan mini bir anahtar daha elde etmemizi sağlar. Yeni oluşan bu anahtar sr25519PairFromSeed() fonksiyonu ile istediğimiz secret ve public anahtar çifti yapısı haline gelir.
  • path: Anahtar çiftimizi oluşturdurduktan sonra bir sonraki işlemde secretKey'in oluşturulabilmesi için bu anahtarın hangi konumda saklanacağı belirler. Aynı zamanda bu işlem anahtarın hangi amaçla kullanılacağını da ifade eder. Kodumuz içerisinde //did//keyAgreement//0 yapısı ile anahtarın bir key agreement olarak kullanılacağı belirtilmiştir.
  • secretKey: Bu işlem daha öncesinde tanıttığımız iki değişkeni ve cüzdan tipini alarak -ki bizim için bu değer şimdilik sr25519 bir gizli anahtar oluşturmaktadır. Bu işlemi keyFromPath methodu ile hayata geçirmektedir.
  • makeEncryptionKeypairFromSeed: Son olarak anahtar çiftlerini çıktı vermek kalıyor. Bu işlemi de KILT SDK içerisinde Utils.Crypto.makeEncryptionKeypairFromSeed() methodu ile return ederiz ve fonksiyon tamamlanmış olur.
Neden Bu Kodu Yazdık?
  1. Güvenlik: Merkezi olmayan bir kimlik sistemi oluştururken, güvenli iletişim için anahtar anlaşmaları gereklidir.
  2. Kullanıcı Kontrolü: Kullanıcılar kendi anahtarlarını oluşturarak, kimliklerini ve verilerini kontrol edebilirler.
  3. Esneklik: Bu fonksiyon, farklı anahtar türlerini destekleyebilecek şekilde tasarlanmıştır, bu da onu farklı uygulamalar için uygun kılar.
  4. Entegrasyon: Kilt ve Polkadot gibi mevcut blockchain teknolojileri ile uyumlu bir anahtar oluşturma mekanizması sağlar.

generateKeypairs Fonksiyonu​

Daha öncesinde oluşturduğumuz fonksiyonlar ile anahtar çiftlerini oluşutmak için gerekli mekanizmayı kurmuştuk. Şimdi de bu mekanizmadan anahtar çiftlerini oluşturmak için gerekli fonksiyonu tanımlayabiliriz. Bu fonksiyon içerisine gireceğimiz secret anahtarlar ile bizlere 4 adet anahtar çifti oluşturacaktır.

attester/generateKeypairs.ts
export function generateKeypairs(mnemonic = mnemonicGenerate()) {

İlk olarak fonksiyonumuzu tanımlamak ile işe başlayabiliriz. Bu fonksiyon içerisine mnemonic bir şifre almaktadır. Ancak mnemonicGenerate() yapısı kafa karışıklığı yaratabilir. Bu yapı herhangi bir mnemonic şifre girdi verilmemesi durumunda sıfırdan bir mnemonic şifre oluşturmaktadır.

attester/generateKeypairs.ts
const { account } = generateAccount(mnemonic);

Kodun içerisine girdiğimizde ilk olarak mnemonic şifreden generateAccount() fonksiyonu sayesinde hesabı oluştururuz. Bu hesabı sonrasında anahtar çiftlerini üretmek için kullanacağız.

Hadi Anahtar Çiftlerini Oluşturmaya Başlayalım

Artık 4 anahtar çiftimizi oluşturabiliriz.

Kimlik Doğrulama Anahtar Çifti (Authentication Keypair)​
attester/generateKeypairs.ts
const authentication = {
  ...account.derive('//did//0'),
  type: 'sr25519'
} as Kilt.KiltKeyringPair;

Satır satır ilerlenecek olunursa:

  • account.derive('//did//0'): Hesaptan bir kimlik doğrulama çifti türetir.
  • type: 'sr25519': Anahtar çiftinin türünü belirtir.
  • as Kilt.KiltKeyringPair: Anahtar çiftinin türünü Kilt'in anahtar çifti türünde olduğunu belirtir.
Authentication Keypair Hazır!

Doğrulama yani Authentication anahtar çiftimizi hazırladık. Artık bu anahtar ile claim'ler hazırlayabilir ve doğrulanmış credential'leri sunabiliriz.

İddia Doğrulama Anahtar Çifti (Assertion KeyPair)​
attester/generateKeypairs.ts
const assertionMethod = {
  ...account.derive('//did//assertion//0'),
  type: 'sr25519'
} as Kilt.KiltKeyringPair;

Üst fonksiyonda da ürettiğimiz üzere bu sefer de iddia beyanların doğrulanması için hesaptan sr25519 türünde Assertion anahtar çifti üretilir.

Kabiliyet Delegasyonu Anahtar Çifti (Capability Delegation Keypair)​
attester/generateKeypairs.ts
const capabilityDelegation = {
  ...account.derive('//did//delegation//0'),
  type: 'sr25519'
} as Kilt.KiltKeyringPair;

Sıradaki değişkenimiz ile yeteneklerin veya izinlerin başka tarafa devredilmesi için anahtar çifti oluşturulur. Bu anahtar çifti KILT zinciri içerisinde zincire delegation'ların yazımı için kullanılır.

Anlaşma Anahtar Çifti (Key Agreement Keypair)​
attester/generateKeypairs.ts
const keyAgreement = generateKeyAgreement(mnemonic);

Son olarak keyAgreement anahtar çifti üretilmektedir. Bu anahtar mesajları şifrelemek ve şifreleri kırmak için kullanılır.

Sonuçları Döndürme​
attester/generateKeypairs.ts
return {
  authentication: authentication,
  keyAgreement: keyAgreement,
  assertionMethod: assertionMethod,
  capabilityDelegation: capabilityDelegation
};

Son olarak oluşturduğumuz anahtar çiftlerini fonksiyon çıktısı olarak fonksiyon çıktısı olarak döndürürüz.

Anahtar Çifti Oluşturma Fonksiyonumuz Tamamlandı!

Attester için oluşturacağımız DID'lerin 4 adet anahtar çiftine ihtiyacı bulunmaktaydı. Bu anahtar çiftlerini generateKeypairs fonksiyonu ile türettik.

Kodun tamamını inceleyelim

Yazdığımız kodu bütün olarak görmemiz gerekirse:

attester/generateKeypairs.ts
import * as Kilt from '@kiltprotocol/sdk-js'
import {
  blake2AsU8a,
  keyExtractPath,
  keyFromPath,
  mnemonicGenerate,
  mnemonicToMiniSecret,
  sr25519PairFromSeed
} from '@polkadot/util-crypto'
import { generateAccount } from './generateAccount'

// Because there is no first-class support for this class of keys,
// we need to use a workaround to generate a key we can use for encryption/decryption.
function generateKeyAgreement(mnemonic: string) {
  const secretKeyPair = sr25519PairFromSeed(mnemonicToMiniSecret(mnemonic))
  const { path } = keyExtractPath('//did//keyAgreement//0')
  const { secretKey } = keyFromPath(secretKeyPair, path, 'sr25519')
  return Kilt.Utils.Crypto.makeEncryptionKeypairFromSeed(blake2AsU8a(secretKey))
}

export function generateKeypairs(mnemonic = mnemonicGenerate()) {
  const { account } = generateAccount(mnemonic)

  const authentication = {
    ...account.derive('//did//0'),
    type: 'sr25519'
  } as Kilt.KiltKeyringPair

  const assertionMethod = {
    ...account.derive('//did//assertion//0'),
    type: 'sr25519'
  } as Kilt.KiltKeyringPair

  const capabilityDelegation = {
    ...account.derive('//did//delegation//0'),
    type: 'sr25519'
  } as Kilt.KiltKeyringPair

  const keyAgreement = generateKeyAgreement(mnemonic)

  return {
    authentication: authentication,
    keyAgreement: keyAgreement,
    assertionMethod: assertionMethod,
    capabilityDelegation: capabilityDelegation
  }
}

Sırasıyla işleve bakılacak olunursa:

  • İlk olarak gerekli kütüphaneleri tanımlarız.
  • Sonrasında mnemonic şifre içerisinden bazı gizli anahtarları çıkarırız.
  • Son olarak generateKeypairs fonksiyonu ile tüm anahtar çiftlerini oluşturup fonksiyon çıktısı olarak tanımlarız.

DID oluşturmak için gerekli olan tüm anahtarları topladığımıza göre zincir üzerindeki DID'lerimizi oluşturmaya başlayabiliriz.

Anahtar Çiftlerini Kullanarak DID Oluşturma​

DID oluşturmak içim ilk olarak tüm işlemleri başlatmamız gerekmektedir. Sonrasında bir önceki kısımda (Attester Account) oluşturduğumuz hesabı kodumuz içerisine çekebiliriz. Bu hesap DID kayıt ücretlerini ödemek için oluşturulmuş bir hesaptır. Son olarak DID kaydetmek için gerekli transferi bildirebiliriz.

Modüllerin İçe Aktarılması​

attester/generateDid.ts
import { config as envConfig } from 'dotenv'
import * as Kilt from '@kiltprotocol/sdk-js'

import { generateAccount } from './generateAccount'
import { generateKeypairs } from './generateKeypairs'

Daha önce de yaptığımız şekilde kütüphaneleri kodumuz içerisine ekleriz. Buradaki yeni ve farklı kütüphanelere bakılacak olunursa:

  • dotenv: Oluşturdurğumuz ortam değişkenlerini (ki bizim durumumuzda mnemonic şifre vb.) kodumuz içerisine yüklememizi sağlamaktadır.
  • generateAccount ve generateKeypairs: Öncesinde attester klasörü içerisinde oluşturduğumuz kodlardan export edilen fonksiyonları almamızı sağlar.

createFullDid Fonksiyonu​

attester/generateDid.ts
export async function createFullDid(
  submitterAccount: Kilt.KiltKeyringPair
): Promise<{
  mnemonic: string
  fullDid: Kilt.DidDocument
}> {

İlk olarak zincir üzerinde oluşturacağımız DID'nin fonksiyonunu tanımlayarak işlemlere başlayabiliriz. Bu asenkron fonksiyon, bir Kilt.KiltKeyringPair türünde submitterAccount alır ve bir Promise döndürür. Bu Promise, bir mnemonik ve bir Kilt.DidDocument içerir.

Kilt API Bağlantısı ve Mnemonik Oluşturma​
attester/generateDid.ts
const api = Kilt.ConfigService.get('api')
const mnemonic = Kilt.Utils.Crypto.mnemonicGenerate()

Fonksiyonun içerisine girildiğinde sırasıyla api'a bağlanma ve mnemonic şifre oluşturma işlemi karşılamaktır. DID'lerin de kendine özgü mnemonic şifreleri bulunmaktadır. Bu şifre o yüzden bu kısımda oluşturulmaktadır.

Anahtar Çiftlerini Oluşturma​
attester/generateDid.ts
const {
  authentication,
  keyAgreement,
  assertionMethod,
  capabilityDelegation
} = generateKeypairs(mnemonic)

Bir önceki yazdığımız kod dosyasında DID'ler için gerekli anahtar çiftlerini oluşturmamızı sağlayan generateKeypairs fonksiyonunu yazmıştık. Bu fonskiyon 4 anahtarı çıktı vermekte olup içerisine mnemonic anahtarı almaktaydı. Bir önceki satırda oluşturduğumuz mnemonic anahtarı içerisine girerek 4 generateKeypairs() fonksiyonunu çağırabiliriz. Bu işlem sonucunda 4 adet şifremizi değişkenlere sırasıyla kaydedebiliriz.

DID Oluşturma Transferini Gerçekleştirme​
attester/generateDid.ts
  const fullDidCreationTx = await Kilt.Did.getStoreTx(
    {
      authentication: [authentication],
      keyAgreement: [keyAgreement],
      assertionMethod: [assertionMethod],
      capabilityDelegation: [capabilityDelegation]
    },
    submitterAccount.address,
    async ({ data }) => ({
      signature: authentication.sign(data),
      keyType: authentication.type
    })
  )

DID'lerimizi oluşturmak için bir transfer işlemi yapmamız gerekmekte. Bu transfer işlemini KILT SDK içerisinde bulunan getStoreTx() fonksiyonu ile gerçekleştirebiliriz. Bu fonksiyonun aldığı parametrelere bakılacak olunursa:

  • Anahtar Çiftleri: İlk parametre olarak obje halinde 4 anahtarı almaktadır.
  • Hesap: Sonraki parametre bu hesabın hangi adrese ait olduğunu ifade etmektedir.
  • İmza: Transferin gerçekleşmesi için gerekli olan imza işlemlerini gerçekleştirmektedir.

Bu şekilde göndereceğimiz transferin bilgileri hazırlanmış bir hale gelir.

İşlemi Gönderme​
attester/generateDid.ts
await Kilt.Blockchain.signAndSubmitTx(fullDidCreationTx, submitterAccount)

Transferimizi hazırladıktan sonra signAndSubmitTx fonksiyonu ile işlemimizi onaylanması için gönderebiliriz.

Oluşturduğumuz DID'nin Bilgilerini Alma​
attester/generateDid.ts
const didUri = Kilt.Did.getFullDidUriFromKey(authentication)
const encodedFullDid = await api.call.did.query(Kilt.Did.toChain(didUri))
const { document } = Kilt.Did.linkedInfoFromChain(encodedFullDid)

DID'mizi oluşturmak için transferi gönderdikten sonra artık bu transferin sonucunda oluşturulan DID için gerekli bilgileri değişkenlere kaydedebiliriz. Bu işlemler sırasıyla:

  • Oluşturulan DID için bir URI oluşturur.
  • Bu URI'yi kullanarak DID dokümanını sorgular.
URI Nedir?

DID (Decentralized Identifier) sistemlerinde, URI (Uniform Resource Identifier) genellikle bir DID'nin benzersiz bir şekilde tanımlanmasını sağlar. DID URI'leri, genellikle bir "scheme" (örneğin, did:), bir "method" (örneğin, kilt:) ve bir "method-specific identifier" (örneğin, bir blockchain adresi veya benzersiz bir kimlik) bölümlerinden oluşur.

Örneğin, bir Kilt DID URI şu şekilde olabilir:

did:kilt:4uJ7uq1Nj4kZ4qHv3yzZRBuW9D2b3ZRF

Bu URI'nin parçaları şunlardır:

  • did:: Bu, URI'nin bir DID olduğunu belirtir.
  • kilt:: Bu, DID'nin Kilt metodunu kullandığını belirtir.
  • 4uJ7uq1Nj4kZ4qHv3yzZRBuW9D2b3ZRF: Bu, DID'nin benzersiz tanımlayıcısıdır, genellikle bir blockchain adresi veya başka bir benzersiz kimlik.

Bu URI, DID'nin nasıl çözüleceğini (yani, DID Dokümanı'nın nasıl elde edileceğini) ve DID'nin hangi blockchain veya merkezsiz ağda saklandığını belirtir. Genellikle, bu URI'yi kullanarak, DID'nin sahip olduğu anahtarlar, yetenekler ve diğer özellikler hakkında bilgi alabilirsiniz.

Hata Kontrolü ve Dönüş Değeri​
attester/generateDid.ts
if (!document) {
  throw new Error('Full DID was not successfully created.')
}
return { mnemonic, fullDid: document }

İşlemlerimize devam ettiğimizde DID'nin başarılı bir şekilde oluşup oluşmadığını kontrol eden bir mekanizma bizleri karşılamaktadır. DID düzgün bir şekilde oluşturulmuşsa return ifadesi ile bu URI döndürülmektedir.

Ana Program​

Şimdi de ana program çalıştığında neler yapmamız gerektiğini belirten fonksiyonu yazabiliriz.

attester/generateDid.ts
if (require.main === module) {
  ;(async () => {
  envConfig()

Fonksiyon tanımlanıp envConfig() fonksiyonu ile.env dosyasındaki içerikler alınır.

ipucu

Yazdığımız kod dosyası hem farklı kod dosyaları tarafından çağırılarak hemde kendi başlarına çalıştırılabilir. Farklı dosyalar tarafından çalıştırılıcakken export yapısına sahip fonksiyonlar kullanılabilecek olunurken kendi başlarına çalıştırılacakken require.main yapısına ihtiyaç duyarlar.

attester/generateDid.ts
try {

    .
    .
    .
    
} catch (e)
    console.log("Error while creating attester DID")
    trow e
}

Fonksiyonları çağırmak için bir try catch yapısı kurarız. Bu sayede try yapısı içerisine yazacağımız kodlar çalışmazsa catch ifadesi hatayı yakalar ve bizlere söyler.

Şimdi try yapısı içerisine girebiliriz.

attester/generateDid.ts
const accountMnemonic = process.env.ATTESTER_ACCOUNT_MNEMONIC as string

İlk olarak .env dosyasından daha öncesinde oluşturmuş olduğumuz attester mnemonic anahtarımızı kodumuza ekleriz.

attester/generateDid.ts
const { account } = generateAccount(accountMnemonic)

const { mnemonic, fullDid } = await createFullDid(account)

Daha sonrasında ekleğimiz bu mnemonicanahtardan daha önceden sırasıyla tanımladığımız generateAccount ve createFullDid methodları ile account ve bu account değerinden fullDid değerini elde ederiz.

attester/generateDid.ts
console.log('\nsave following to .env to continue\n');
console.error(`ATTESTER_DID_MNEMONIC="${mnemonic}"\n`);
console.error(`ATTESTER_DID_URI="${fullDid.uri}"\n`);

Daha sonrasında son olarak bu bilgileri kullanıcıya vererek işlemleri tamamlarız. Kodumuz bu şekilde tamamlanmış olur.

Genel Bir bakış yapalım

Kodumuzu yazdık ancak genel bir bakış yapmamız gerekirse generateDid.ts dosyasının içerisindeki tüm kodlar şu şekilde olacaktır:

attester/generateDid.ts
import { config as envConfig } from 'dotenv'

import * as Kilt from '@kiltprotocol/sdk-js'

import { generateAccount } from './generateAccount'
import { generateKeypairs } from './generateKeypairs'

export async function createFullDid(
  submitterAccount: Kilt.KiltKeyringPair
): Promise<{
  mnemonic: string
  fullDid: Kilt.DidDocument
}> {
  const api = Kilt.ConfigService.get('api')

  const mnemonic = Kilt.Utils.Crypto.mnemonicGenerate()
  const {
    authentication,
    keyAgreement,
    assertionMethod,
    capabilityDelegation
  } = generateKeypairs(mnemonic)
  // Get tx that will create the DID on chain and DID-URI that can be used to resolve the DID Document.
  const fullDidCreationTx = await Kilt.Did.getStoreTx(
    {
      authentication: [authentication],
      keyAgreement: [keyAgreement],
      assertionMethod: [assertionMethod],
      capabilityDelegation: [capabilityDelegation]
    },
    submitterAccount.address,
    async ({ data }) => ({
      signature: authentication.sign(data),
      keyType: authentication.type
    })
  )

  await Kilt.Blockchain.signAndSubmitTx(fullDidCreationTx, submitterAccount)

  const didUri = Kilt.Did.getFullDidUriFromKey(authentication)
  const encodedFullDid = await api.call.did.query(Kilt.Did.toChain(didUri))
  const { document } = Kilt.Did.linkedInfoFromChain(encodedFullDid)

  if (!document) {
    throw new Error('Full DID was not successfully created.')
  }

  return { mnemonic, fullDid: document }
}

// Don't execute if this is imported by another file.
if (require.main === module) {
  ;(async () => {
    envConfig()

    try {
      await Kilt.connect(process.env.WSS_ADDRESS as string)

      // Load attester account
      const accountMnemonic = process.env.ATTESTER_ACCOUNT_MNEMONIC as string
      const { account } = generateAccount(accountMnemonic)
      const { mnemonic, fullDid } = await createFullDid(account)

      console.log('\nsave following to .env to continue\n')
      console.error(`ATTESTER_DID_MNEMONIC="${mnemonic}"\n`)
      console.error(`ATTESTER_DID_URI="${fullDid.uri}"\n`)
    } catch (e) {
      console.log('Error while creating attester DID')
      throw e
    }
  })()
}

Bu kodun neler yaptığına genel olarak bakıcak olursak:

  • Paketleri ve daha önce yazdığımız kodları dosyaya entegre ediyoruz.
  • createFullDid() fonksiyonunu tanımlayıp bu fonksiyon ile generateKeypairs.ts kod dosyasındaki generateKeypairs() fonksiyonunu çağırıp anahtar çiftlerimizi oluşturuyoruz.
  • Anahtar çiftlerimiz ile DID'mizin transferini zincire yazıp onaylıyoruz.
  • Transfer sonrasında DID mnemonic anahtarını ve uri değerini oluşturuyoruz.
  • Kod dosyasını çalıştırıp .env dosyası içerisinde yazdığımız attester mnemonic anahtarı için createFullDid() fonskiyonunu çağırıp sonuçları ekrana yazdırıyoruz.

Kodu Çalıştırmak​

Kodumuzu çalıştırmak için terminalde kilt-rocks konumunda olduğumuza emin olduktan sonra alt kısımdaki kodu çalıştırabiliriz.

yarn ts-node ./attester/generateDid.ts
Hata mı aldın?

Kod çalışırken birçok yerden hata almış olabilirsin ancak çokça karşılaşılan hata kullanıcının attester hesabına PILT coinlerini faucet'den almamasıdır. Hesabında yeterli miktarın olduğuna emin ol ve o şekilde devam et!

Sonuçları Alalım!​

Kodumuz çalıştığında bizlere DID'miz için yeni bir mnemonic şifre ve uri değerinin oluştuğunu görebiliriz.

Sakın Unutma

Kodumuzu çalıştırdığımızda ortaya çıkan Mnemonic ve URI değerlerini .env dosyası içerisine kaydetmemiz gerekiyor!