@daevm/cheqd-sdk
Version:
A TypeScript SDK built with CosmJS to interact with cheqd network ledger
208 lines • 9.98 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateSpecCompliantPayload = exports.createDidPayload = exports.createDidVerificationMethod = exports.createVerificationKeys = exports.createKeyPairHex = exports.createKeyPairBase64 = exports.createKeyPairRaw = exports.createSignInputsFromImportableEd25519Key = exports.isEqualKeyValuePair = void 0;
const types_1 = require("./types");
const uint8arrays_1 = require("uint8arrays");
const basics_1 = require("multiformats/basics");
const did_jwt_1 = require("did-jwt");
const ed25519_1 = require("@stablelib/ed25519");
const crypto_1 = require("@cosmjs/crypto");
const uuid_1 = require("uuid");
const v2_1 = require("@cheqd/ts-proto/cheqd/did/v2");
const MULTICODEC_ED25519_HEADER = new Uint8Array([0xed, 0x01]);
function isEqualKeyValuePair(kv1, kv2) {
return kv1.every((item, index) => item.key === kv2[index].key && item.value === kv2[index].value);
}
exports.isEqualKeyValuePair = isEqualKeyValuePair;
function createSignInputsFromImportableEd25519Key(key, verificationMethod) {
if (verificationMethod?.length === 0)
throw new Error('No verification methods provided');
const publicKey = (0, uint8arrays_1.fromString)(key.publicKeyHex, 'hex');
for (const method of verificationMethod) {
switch (method?.type) {
case types_1.VerificationMethods.Ed255192020:
const publicKeyMultibase = toMultibaseRaw(publicKey);
if (method.publicKeyMultibase === publicKeyMultibase) {
return {
verificationMethodId: method.id,
privateKeyHex: key.privateKeyHex
};
}
case types_1.VerificationMethods.Ed255192018:
const publicKeyBase58 = basics_1.bases['base58btc'].encode(publicKey).slice(1);
if (method.publicKeyBase58 === publicKeyBase58) {
return {
verificationMethodId: method.id,
privateKeyHex: key.privateKeyHex
};
}
case types_1.VerificationMethods.JWK:
const publicKeyJwk = {
crv: 'Ed25519',
kty: 'OKP',
x: (0, uint8arrays_1.toString)(publicKey, 'base64url')
};
if (JSON.stringify(method.publicKeyJwk) === JSON.stringify(publicKeyJwk)) {
return {
verificationMethodId: method.id,
privateKeyHex: key.privateKeyHex
};
}
}
}
throw new Error('No verification method type provided');
}
exports.createSignInputsFromImportableEd25519Key = createSignInputsFromImportableEd25519Key;
function createKeyPairRaw(seed) {
return seed ? (0, ed25519_1.generateKeyPairFromSeed)((0, uint8arrays_1.fromString)(seed)) : (0, ed25519_1.generateKeyPair)();
}
exports.createKeyPairRaw = createKeyPairRaw;
function createKeyPairBase64(seed) {
const keyPair = seed ? (0, ed25519_1.generateKeyPairFromSeed)((0, uint8arrays_1.fromString)(seed)) : (0, ed25519_1.generateKeyPair)();
return {
publicKey: (0, uint8arrays_1.toString)(keyPair.publicKey, 'base64'),
privateKey: (0, uint8arrays_1.toString)(keyPair.secretKey, 'base64'),
};
}
exports.createKeyPairBase64 = createKeyPairBase64;
function createKeyPairHex(seed) {
const keyPair = createKeyPairRaw(seed);
return {
publicKey: (0, uint8arrays_1.toString)(keyPair.publicKey, 'hex'),
privateKey: (0, uint8arrays_1.toString)(keyPair.secretKey, 'hex'),
};
}
exports.createKeyPairHex = createKeyPairHex;
function createVerificationKeys(publicKey, algo, key, network = types_1.CheqdNetwork.Testnet) {
let methodSpecificId;
let didUrl;
publicKey = publicKey.length == 43 ? publicKey : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publicKey, 'hex'), 'base64');
switch (algo) {
case types_1.MethodSpecificIdAlgo.Base58:
methodSpecificId = basics_1.bases['base58btc'].encode((0, did_jwt_1.base64ToBytes)(publicKey));
didUrl = `did:cheqd:${network}:${(basics_1.bases['base58btc'].encode(((0, crypto_1.sha256)((0, did_jwt_1.base64ToBytes)(publicKey))).slice(0, 16))).slice(1)}`;
return {
methodSpecificId,
didUrl,
keyId: `${didUrl}#${key}`,
publicKey,
};
case types_1.MethodSpecificIdAlgo.Uuid:
methodSpecificId = basics_1.bases['base58btc'].encode((0, did_jwt_1.base64ToBytes)(publicKey));
didUrl = `did:cheqd:${network}:${(0, uuid_1.v4)()}`;
return {
methodSpecificId,
didUrl,
keyId: `${didUrl}#${key}`,
publicKey,
};
}
}
exports.createVerificationKeys = createVerificationKeys;
function createDidVerificationMethod(verificationMethodTypes, verificationKeys) {
return verificationMethodTypes.map((type, _) => {
switch (type) {
case types_1.VerificationMethods.Ed255192020:
return {
id: verificationKeys[_].keyId,
type,
controller: verificationKeys[_].didUrl,
publicKeyMultibase: toMultibaseRaw((0, did_jwt_1.base64ToBytes)(verificationKeys[_].publicKey))
};
case types_1.VerificationMethods.Ed255192018:
return {
id: verificationKeys[_].keyId,
type,
controller: verificationKeys[_].didUrl,
publicKeyBase58: verificationKeys[_].methodSpecificId.slice(1)
};
case types_1.VerificationMethods.JWK:
return {
id: verificationKeys[_].keyId,
type,
controller: verificationKeys[_].didUrl,
publicKeyJwk: {
crv: 'Ed25519',
kty: 'OKP',
x: (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(verificationKeys[_].publicKey, 'base64pad'), 'base64url')
}
};
}
}) ?? [];
}
exports.createDidVerificationMethod = createDidVerificationMethod;
function createDidPayload(verificationMethods, verificationKeys) {
if (!verificationMethods || verificationMethods.length === 0)
throw new Error('No verification methods provided');
if (!verificationKeys || verificationKeys.length === 0)
throw new Error('No verification keys provided');
const did = verificationKeys[0].didUrl;
return {
id: did,
controller: verificationKeys.map(key => key.didUrl),
verificationMethod: verificationMethods,
authentication: verificationKeys.map(key => key.keyId),
};
}
exports.createDidPayload = createDidPayload;
function validateSpecCompliantPayload(didDocument) {
// id is required, validated on both compile and runtime
if (!didDocument?.id)
return { valid: false, error: 'id is required' };
// verificationMethod is required
if (!didDocument?.verificationMethod)
return { valid: false, error: 'verificationMethod is required' };
// verificationMethod must be an array
if (!Array.isArray(didDocument?.verificationMethod))
return { valid: false, error: 'verificationMethod must be an array' };
// verificationMethod types must be supported
const protoVerificationMethod = didDocument.verificationMethod.map((vm) => {
switch (vm?.type) {
case types_1.VerificationMethods.Ed255192020:
if (!vm.publicKeyMultibase)
throw new Error('publicKeyMultibase is required');
return v2_1.VerificationMethod.fromPartial({
id: vm.id,
controller: vm.controller,
verificationMethodType: types_1.VerificationMethods.Ed255192020,
verificationMaterial: vm.publicKeyMultibase,
});
case types_1.VerificationMethods.JWK:
if (!vm.publicKeyJwk)
throw new Error('publicKeyJwk is required');
return v2_1.VerificationMethod.fromPartial({
id: vm.id,
controller: vm.controller,
verificationMethodType: types_1.VerificationMethods.JWK,
verificationMaterial: JSON.stringify(vm.publicKeyJwk),
});
case types_1.VerificationMethods.Ed255192018:
if (!vm.publicKeyBase58)
throw new Error('publicKeyBase58 is required');
return v2_1.VerificationMethod.fromPartial({
id: vm.id,
controller: vm.controller,
verificationMethodType: types_1.VerificationMethods.Ed255192018,
verificationMaterial: vm.publicKeyBase58,
});
default:
throw new Error(`Unsupported verificationMethod type: ${vm?.type}`);
}
});
const protoService = didDocument?.service?.map((s) => {
return v2_1.Service.fromPartial({
id: s?.id,
serviceType: s?.type,
serviceEndpoint: s?.serviceEndpoint,
});
});
return { valid: true, protobufVerificationMethod: protoVerificationMethod, protobufService: protoService };
}
exports.validateSpecCompliantPayload = validateSpecCompliantPayload;
function toMultibaseRaw(key) {
const multibase = new Uint8Array(MULTICODEC_ED25519_HEADER.length + key.length);
multibase.set(MULTICODEC_ED25519_HEADER);
multibase.set(key, MULTICODEC_ED25519_HEADER.length);
return basics_1.bases['base58btc'].encode(multibase);
}
//# sourceMappingURL=utils.js.map