@cheqd/did-provider-cheqd 3.2.1 → 3.3.0-develop.1

package/src/did-manager/cheqd-did-provider.ts

@@ -18,9 +18,11 @@ import {
 } from '@cheqd/sdk'
 import { MsgCreateResourcePayload } from '@cheqd/ts-proto/cheqd/resource/v2/index.js'
 import { 
+	Coin,
 	DirectSecp256k1HdWallet,
 	DirectSecp256k1Wallet
 } from '@cosmjs/proto-signing'
+import { GasPrice, DeliverTxResponse } from '@cosmjs/stargate'
 import { assert } from '@cosmjs/utils'
 import { DIDDocument } from 'did-resolver'
 import {
@@ -49,17 +51,28 @@ import { v4 } from 'uuid'
 
 const debug = Debug('veramo:did-provider-cheqd')
 
-type IContext = IAgentContext<IKeyManager>
+export const DefaultRPCUrls = {
+	[CheqdNetwork.Mainnet]: 'https://rpc.cheqd.net',
+	[CheqdNetwork.Testnet]: 'https://rpc.cheqd.network'
+} as const
 
-export enum DefaultRPCUrl {
-	Mainnet = 'https://rpc.cheqd.net',
-	Testnet = 'https://rpc.cheqd.network'
-}
+export const DefaultRESTUrls = {
+	[CheqdNetwork.Mainnet]: 'https://api.cheqd.net',
+	[CheqdNetwork.Testnet]: 'https://api.cheqd.network'
+} as const
+
+export type IContext = IAgentContext<IKeyManager>
+
+export type DefaultRPCUrl = typeof DefaultRPCUrls[CheqdNetwork.Mainnet] | typeof DefaultRPCUrls[CheqdNetwork.Testnet]
+
+export type DefaultRESTUrl = typeof DefaultRESTUrls[CheqdNetwork.Mainnet] | typeof DefaultRESTUrls[CheqdNetwork.Testnet]
 
 export type LinkedResource = Omit<MsgCreateResourcePayload, 'data'> & { data?: string }
 
 export type ResourcePayload = Partial<MsgCreateResourcePayload>
 
+export type StatusList2021ResourcePayload = ResourcePayload & { resourceType: 'StatusList2021' }
+
 export type TImportableEd25519Key = Required<Pick<IKey, 'publicKeyHex' | 'privateKeyHex'>> & { kid: TImportableEd25519Key['publicKeyHex'], type: 'Ed25519' }
 
 declare const TImportableEd25519Key: {
@@ -79,16 +92,18 @@ export class EnglishMnemonic extends _ {
 export class CheqdDIDProvider extends AbstractIdentifierProvider {
 	private defaultKms: string
 	public readonly network: CheqdNetwork
-	private rpcUrl: string
+	public readonly rpcUrl: string
 	private readonly cosmosPayerWallet: Promise<DirectSecp256k1HdWallet | DirectSecp256k1Wallet>
 	private sdk?: CheqdSDK
 	private fee?: DidStdFee
 
+	static readonly defaultGasPrice = GasPrice.fromString('50ncheq')
+
 	constructor(options: { defaultKms: string, cosmosPayerSeed: string, networkType?: CheqdNetwork, rpcUrl?: string }) {
 		super()
 		this.defaultKms = options.defaultKms
 		this.network = options.networkType ? options.networkType : CheqdNetwork.Testnet
-		this.rpcUrl = options.rpcUrl ? options.rpcUrl : (this.network === CheqdNetwork.Testnet ? DefaultRPCUrl.Testnet : DefaultRPCUrl.Mainnet)
+		this.rpcUrl = options.rpcUrl ? options.rpcUrl : DefaultRPCUrls[this.network]
 
 		if (!options?.cosmosPayerSeed || options.cosmosPayerSeed === '') {
 			this.cosmosPayerWallet = DirectSecp256k1HdWallet.generate()
@@ -105,7 +120,7 @@ export class CheqdDIDProvider extends AbstractIdentifierProvider {
 			)
 	}
 
-	private async getCheqdSDK(fee?: DidStdFee): Promise<CheqdSDK> {
+	private async getCheqdSDK(fee?: DidStdFee, gasPrice?: GasPrice): Promise<CheqdSDK> {
 		if (!this.sdk) {
 			const wallet = await this.cosmosPayerWallet.catch(() => {
 				throw new Error(`[did-provider-cheqd]: network: ${this.network} valid cosmosPayerSeed is required`)
@@ -114,6 +129,7 @@ export class CheqdDIDProvider extends AbstractIdentifierProvider {
 				modules: [DIDModule as unknown as AbstractCheqdSDKModule, ResourceModule as unknown as AbstractCheqdSDKModule],
 				rpcUrl: this.rpcUrl,
 				wallet: wallet,
+				gasPrice
 			}
 
 			this.sdk = await createCheqdSDK(sdkOptions)
@@ -415,6 +431,37 @@ export class CheqdDIDProvider extends AbstractIdentifierProvider {
 		throw Error('CheqdDIDProvider removeService is not supported.')
 	}
 
+	async transactSendTokens(args: { recipientAddress: string, amount: Coin, memoNonce: string, txBytes?: Uint8Array, timeoutMs?: number, pollIntervalMs?: number }): Promise<DeliverTxResponse> {
+		const sdk = await this.getCheqdSDK(undefined, CheqdDIDProvider.defaultGasPrice)
+
+		if (args?.txBytes) {
+			// broadcast txBytes
+			const tx = await sdk.signer.broadcastTx(args.txBytes, args?.timeoutMs, args?.pollIntervalMs)
+
+			// assert tx code is 0, in other words, tx succeeded
+			assert(tx.code === 0, `cosmos_transaction: Failed to send tokens. Reason: ${tx.rawLog}`)
+
+			// keep log
+			debug('Sent tokens', 'txBytes', toString(args.txBytes, 'hex'))
+
+			return tx
+		}
+
+		const tx = await sdk.signer.sendTokens(
+			(await this.cosmosPayerWallet).getAccounts()[0],
+			args.recipientAddress,
+			[args.amount],
+			'auto',
+			args.memoNonce,
+		)
+
+		assert(tx.code === 0, `cosmos_transaction: Failed to send tokens. Reason: ${tx.rawLog}`)
+
+		debug('Sent tokens', args.amount.amount, args.amount.denom, 'to', args.recipientAddress)
+
+		return tx
+	}
+
     private async signPayload(context: IAgentContext<IKeyManager>, data: Uint8Array, verificationMethod: VerificationMethod[] = []): Promise<SignInfo[]> {
         return Promise.all(
 			verificationMethod.map(async (method) => {

package/src/did-manager/cheqd-did-resolver.ts

@@ -10,6 +10,12 @@ interface Options {
   url: string
 }
 
+/**
+ * Default resolver url.
+ * @public
+ */
+export const resolverUrl = 'https://resolver.cheqd.net/1.0/identifiers/'
+
 /**
  * Creates a CheqdDIDResolver instance that can be used with `did-resolver`.
  * @public
@@ -25,7 +31,7 @@ export function getResolver(options?: Options): Record<string, DIDResolver> {
  * @public
  */
 export class CheqdDidResolver {
-  private resolverUrl = 'https://resolver.cheqd.net/1.0/identifiers/'
+  private resolverUrl = resolverUrl
 
   constructor(options?: Options) {
     if (options?.url) this.resolverUrl = options.url

package/src/dkg-threshold/lit-protocol.ts

@@ -0,0 +1,238 @@
+import {
+    OfflineAminoSigner,
+    Secp256k1HdWallet,
+    StdSignDoc
+} from '@cosmjs/amino'
+import { toString } from 'uint8arrays/to-string'
+import { sha256 } from '@cosmjs/crypto'
+import {
+    LitNodeClientNodeJs,
+    LitNodeClient,
+    decryptString,
+    encryptString,
+} from '@lit-protocol/lit-node-client'
+import { JsonSaveEncryptionKeyRequest } from '@lit-protocol/types'
+import { randomBytes } from '../utils/helpers.js'
+import { isBrowser, isNode } from '../utils/env.js'
+import { v4 } from 'uuid'
+
+export type EncryptionResult = {
+    encryptedString: Blob
+    encryptedSymmetricKey: string
+    symmetricKey?: Uint8Array
+}
+export type AuthSignature = {
+    sig: string
+    derivedVia: 'cosmos.signArbitrary',
+    signedMessage: string
+    address: string
+}
+export type CosmosAuthSignature = {
+    cosmos: AuthSignature
+}
+export type CosmosReturnValueTest = {
+    key: string
+    comparator: string
+    value: string
+}
+export type CosmosAccessControlCondition = {
+    conditionType: 'cosmos'
+    path: string
+    chain: string
+    returnValueTest: CosmosReturnValueTest
+}
+export type SaveEncryptionKeyArgs = {
+    unifiedAccessControlConditions: CosmosAccessControlCondition[]
+    symmetricKey: CryptoKey
+    authSig: CosmosAuthSignature
+    chain: string
+}
+export type GetEncryptionKeyArgs = {
+    unifiedAccessControlConditions: CosmosAccessControlCondition[]
+    toDecrypt: string
+    authSig: CosmosAuthSignature
+    chain: string
+}
+export type EncryptStringMethodResult = { encryptedString: Blob, symmetricKey: Uint8Array }
+export type DecryptStringMethodResult = string
+export type EncryptStringMethod = (str: string) => Promise<EncryptStringMethodResult>
+export type DecryptStringMethod = (encryptedString: Blob, symmetricKey: Uint8Array) => Promise<DecryptStringMethodResult>
+export type LitNetwork = typeof LitNetworks[keyof typeof LitNetworks]
+export type LitCompatibleCosmosChain = typeof LitCompatibleCosmosChains[keyof typeof LitCompatibleCosmosChains]
+export type LitProtocolOptions = { cosmosAuthWallet: Secp256k1HdWallet, litNetwork?: LitNetwork, chain?: LitCompatibleCosmosChain }
+export type TxNonceFormat = typeof TxNonceFormats[keyof typeof TxNonceFormats]
+
+export const LitNetworks = { jalapeno: 'jalapeno', serrano: 'serrano', localhost: 'localhost', custom: 'custom' } as const
+export const LitCompatibleCosmosChains = { cosmos: 'cosmos', cheqdMainnet: 'cheqdMainnet', cheqdTestnet: 'cheqdTestnet' } as const
+export const TxNonceFormats = { entropy: 'entropy', uuid: 'uuid', timestamp: 'timestamp' } as const
+
+export class LitProtocol {
+    client: LitNodeClientNodeJs | LitNodeClient
+    litNetwork: LitNetwork = LitNetworks.serrano
+    chain: LitCompatibleCosmosChain = LitCompatibleCosmosChains.cheqdTestnet
+    private readonly cosmosAuthWallet: Secp256k1HdWallet
+
+    private constructor(options: LitProtocolOptions) {
+        // validate options
+        if (options.litNetwork && !Object.values(LitNetworks).includes(options.litNetwork)) throw new Error(`[did-provider-cheqd]: lit-protocol: Invalid LitNetwork: ${options.litNetwork}`)
+        if (options.chain && !Object.values(LitCompatibleCosmosChains).includes(options.chain)) throw new Error(`[did-provider-cheqd]: lit-protocol: Invalid LitCompatibleCosmosChain: ${options.chain}`)
+
+        // set options
+        if (options.litNetwork) this.litNetwork = options.litNetwork
+        if (options.chain) this.chain = options.chain
+        this.cosmosAuthWallet = options.cosmosAuthWallet
+
+        // set client as per environment
+        this.client = function(that: LitProtocol) {
+            if (isNode) return new LitNodeClientNodeJs({ litNetwork: that.litNetwork })
+            if (isBrowser) return new LitNodeClient({ litNetwork: that.litNetwork })
+            throw new Error('[did-provider-cheqd]: lit-protocol: Unsupported runtime environment')
+        }(this)
+    }
+
+    async connect(): Promise<void> {
+        return await this.client.connect()
+    }
+
+    async encrypt(secret: string, unifiedAccessControlConditions: NonNullable<JsonSaveEncryptionKeyRequest['unifiedAccessControlConditions']>, returnSymmetricKey = false): Promise<EncryptionResult> {
+        const authSig = await LitProtocol.generateAuthSignature(this.cosmosAuthWallet)
+        const { encryptedString, symmetricKey } = await encryptString(secret as string) as EncryptStringMethodResult
+        const encryptedSymmetricKey = await this.client.saveEncryptionKey(
+            {
+                unifiedAccessControlConditions,
+                symmetricKey,
+                authSig: authSig,
+                chain: this.chain
+            }
+        )
+
+        return {
+            encryptedString,
+            encryptedSymmetricKey: toString(encryptedSymmetricKey, 'hex'),
+            symmetricKey: returnSymmetricKey ? symmetricKey : undefined
+        }
+    }
+
+    async decrypt(encryptedString: Blob, encryptedSymmetricKey: string, unifiedAccessControlConditions: NonNullable<JsonSaveEncryptionKeyRequest['unifiedAccessControlConditions']>): Promise<string> {
+        const authSig = await LitProtocol.generateAuthSignature(this.cosmosAuthWallet)
+        const symmetricKey = await this.client.getEncryptionKey(
+            {
+                unifiedAccessControlConditions,
+                toDecrypt: encryptedSymmetricKey,
+                authSig: authSig,
+                chain: this.chain
+            }
+        )
+        return await decryptString(encryptedString, symmetricKey) as DecryptStringMethodResult
+    }
+
+    static async encryptDirect(secret: string): Promise<EncryptStringMethodResult> {
+        const { encryptedString, symmetricKey } = await encryptString(secret as string) as EncryptStringMethodResult
+        return {
+            encryptedString,
+            symmetricKey
+        }
+    }
+
+    static async decryptDirect(encryptedString: Blob, symmetricKey: Uint8Array): Promise<DecryptStringMethodResult> {
+        return await decryptString(encryptedString, symmetricKey) as DecryptStringMethodResult
+    }
+
+    static async create(options: Partial<LitProtocolOptions>): Promise<LitProtocol> {
+        // instantiate underlying cosmos auth wallet
+        if (!options.cosmosAuthWallet) options.cosmosAuthWallet = await Secp256k1HdWallet.generate(24, { prefix: await LitProtocol.getCosmosWalletPrefix(options?.chain) })
+
+        // validate top-level options chain
+        if (!options?.chain) options.chain = LitCompatibleCosmosChains.cheqdTestnet
+
+        // validate top-level options litNetwork
+        if (!options?.litNetwork) options.litNetwork = LitNetworks.serrano
+
+        const litProtocol = new LitProtocol(options as LitProtocolOptions)
+        await litProtocol.connect()
+        return litProtocol
+    }
+
+    static async getCosmosWalletPrefix(chain?: LitCompatibleCosmosChain): Promise<string> {
+        switch (chain) {
+            case LitCompatibleCosmosChains.cosmos:
+                return 'cosmos'
+            case LitCompatibleCosmosChains.cheqdMainnet:
+                return 'cheqd'
+            case LitCompatibleCosmosChains.cheqdTestnet:
+                return 'cheqd'
+            default:
+                return 'cheqd'
+        }
+    }
+
+    static async generateAuthSignature(wallet: OfflineAminoSigner): Promise<AuthSignature> {
+        const signerAddress = (await wallet.getAccounts())[0].address
+        const signData = await LitProtocol.generateSignData()
+        const signDoc = await LitProtocol.generateSignDoc(signerAddress, signData)
+        const result = await wallet.signAmino(signerAddress, signDoc)
+        return {
+            address: signerAddress,
+            derivedVia: 'cosmos.signArbitrary',
+            sig: result.signature.signature,
+            signedMessage: toString(sha256(new TextEncoder().encode(JSON.stringify(signDoc))), 'hex'), // <-- hex encoded sha256 hash of the json stringified signDoc
+        }
+    }
+
+    static async generateSignDoc(address: string, data: Uint8Array): Promise<StdSignDoc> {
+        return {
+            account_number: '0',
+            chain_id: '',
+            fee: {
+                amount: [],
+                gas: '0'
+            },
+            memo: '',
+            msgs: [
+                {
+                    type: 'sign/MsgSignData',
+                    value: {
+                        data: toString(data, 'base64'),
+                        signer: address,
+                    }
+                }
+            ],
+            sequence: '0',
+        } // <-- should be sorted alphabetically
+    }
+
+    static async generateSignData(): Promise<Uint8Array> {
+        return new TextEncoder().encode(`I am creating an account to use Lit Protocol at 2023-02-21T16:40:15.305Z`) // <-- lit nodes search for this string in the signData
+    }
+
+    static async generateTxNonce(format?: TxNonceFormat, entropyLength?: number): Promise<string> {
+        switch (format) {
+            case TxNonceFormats.entropy:
+                return toString(await randomBytes(entropyLength || 64), 'hex')
+            case TxNonceFormats.uuid:
+                return v4()
+            case TxNonceFormats.timestamp:
+                return new Date().toISOString()
+            default:
+                return v4()
+        }
+    }
+
+    static async generateCosmosAccessControlConditionBalance(returnValueTest: CosmosReturnValueTest, chain: LitCompatibleCosmosChain = LitCompatibleCosmosChains.cheqdTestnet, address = ':userAddress'): Promise<CosmosAccessControlCondition> {
+        return {
+            conditionType: 'cosmos',
+            path: `/cosmos/bank/v1beta1/balances/${address}`,
+            chain,
+            returnValueTest
+        }
+    }
+
+    static async generateCosmosAccessControlConditionTransactionMemo(returnValueTest: CosmosReturnValueTest, amount: string, sender: string, recipient = ':userAddress', chain: LitCompatibleCosmosChain = LitCompatibleCosmosChains.cheqdTestnet): Promise<CosmosAccessControlCondition> {
+        return {
+            conditionType: 'cosmos',
+            path: `/cosmos/tx/v1beta1/txs?events=transfer.recipient='${recipient}'&events=transfer.sender='${sender}'&events=transfer.amount='${amount}'&order_by=2`,
+            chain,
+            returnValueTest
+        }
+    }
+}

package/src/global.d..ts

@@ -0,0 +1 @@
+declare module '@digitalbazaar/vc-status-list'

package/src/utils/env.ts

@@ -0,0 +1,6 @@
+export const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined'
+export const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null
+export const isWebWorker = typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope'
+export const isJsDom = (typeof window !== 'undefined' && window.name === 'nodejs') || (typeof navigator !== 'undefined' && (navigator.userAgent.includes('jsdom') || navigator.userAgent.includes('Node.js')))
+export const isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative' // use wisely: limited as of react-native v0.67 + navigator.product has been deprecated
+export const isElectron = (typeof window !== 'undefined' && typeof window.process === 'object' && (window.process as NodeJS.Process & { type: 'browser' | 'renderer' | 'worker' | 'utility' }).type === 'renderer') || (typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent.indexOf('Electron') >= 0) || (typeof process === 'object' && typeof process.versions === 'object' && !!process.versions.electron)

package/src/utils/helpers.ts

@@ -0,0 +1,66 @@
+import { generate as generateSecret, type GenerateOptions } from 'generate-password'
+import { toString } from 'uint8arrays/to-string'
+
+export async function randomFromRange(min: number, max: number, notIn: number[]): Promise<number> {
+    const random = Math.floor(Math.random() * (max - min + 1) + min)
+    if (notIn.includes(random)) {
+        return await randomFromRange(min, max, notIn)
+    }
+    return random
+}
+
+export async function randomUniqueSubsetInRange(min: number, max: number, count: number): Promise<Array<number>> {
+    const subset: number[] = []
+    for (let i = 0; i < count; i++) {
+        subset.push(await randomFromRange(min, max, subset))
+    }
+    return subset
+}
+
+export async function randomBytes(length: number): Promise<Buffer> {
+    return Buffer.from(
+        Array.from(
+            { length },
+            () => Math.floor(Math.random() * 256),
+        ),
+    )
+}
+
+export async function randomUniqueSecret(options?: GenerateOptions): Promise<string> {
+    return generateSecret({
+        length: 64,
+        numbers: true,
+        symbols: true,
+        uppercase: true,
+        ...options,
+    })
+}
+
+export async function initialiseIndexArray(length: number): Promise<Array<boolean>> {
+    return Array(length).fill(true)
+}
+
+export async function shuffleArray<T>(array: Array<T>): Promise<Array<T>> {
+    const shuffled = array.sort(() => Math.random() - 0.5)
+    return shuffled
+}
+
+export async function toBlob(data: Uint8Array): Promise<Blob> {
+    return new Blob([data])
+}
+
+export async function blobToHexString(blob: Blob): Promise<string> {
+    // buffer from blob
+    const buffer = await blob.arrayBuffer()
+
+    // convert buffer to uint8Array
+    const uint8Array = new Uint8Array(buffer)
+
+    return toString(uint8Array, 'hex')
+}
+
+export function unescapeUnicode(str: string): string {
+    return str.replace(/\\u([a-fA-F0-9]{4})/g, (m, cc) => {
+        return String.fromCharCode(parseInt(cc, 16))
+    })
+}

package/tsconfig.json

@@ -9,6 +9,7 @@
     "declarationMap": true,
     "declaration": true,
     "composite": true,
+    "noImplicitAny": false,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "rootDir": "src",