@cheqd/sdk 1.5.0-develop.3 → 2.0.0-develop.1

package/tests/modules/resource.test.ts

@@ -4,10 +4,11 @@ import { fromString, toString } from 'uint8arrays'
 import { DIDModule, ResourceModule } from "../../src"
 import { createDefaultCheqdRegistry } from "../../src/registry"
 import { CheqdSigningStargateClient } from "../../src/signer"
-import { DidStdFee, ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from '../../src/types';
-import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, exampleCheqdNetwork, faucet } from "../testutils.test"
+import { ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from '../../src/types';
+import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys } from "../../src/utils"
+import { localnet, faucet, image_content, default_content } from "../testutils.test"
 import { MsgCreateResourcePayload } from '@cheqd/ts-proto/cheqd/resource/v2';
-import { randomUUID } from "crypto"
+import { v4 } from "uuid"
 
 const defaultAsyncTxTimeout = 30000
 
@@ -15,50 +16,41 @@ describe('ResourceModule', () => {
     describe('constructor', () => {
         it('should instantiate standalone module', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const resourceModule = new ResourceModule(signer)
             expect(resourceModule).toBeInstanceOf(ResourceModule)
         })
     })
 
     describe('createResourceTx', () => {
-        it('should create a new Resource', async () => {
-            // Creating a DID
+        it('should create a new Resource - case: json', async () => {
+            // create an associated did document
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
 
             const registry = createDefaultCheqdRegistry(Array.from(DIDModule.registryTypes).concat(Array.from(ResourceModule.registryTypes)))
 
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet, { registry })
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet, { registry })
             
             const didModule = new DIDModule(signer)
 
             const keyPair = createKeyPairBase64()
-            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
             const didPayload = createDidPayload(verificationMethods, [verificationKeys])
 
             const signInputs: ISignInputs[] = [
                 {
-                    verificationMethodId: didPayload.verificationMethod[0].id,
+                    verificationMethodId: didPayload.verificationMethod![0].id,
                     privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
                 }
             ]
 
-            const fee: DidStdFee = {
-                amount: [
-                    {
-                        denom: 'ncheq',
-                        amount: '2500000000'
-                    }
-                ],
-                gas: '200000',
-                payer: (await wallet.getAccounts())[0].address
-            } 
-            
+            const feePayer = (await wallet.getAccounts())[0].address
+            const fee = await DIDModule.generateCreateDidDocFees(feePayer)
             const didTx: DeliverTxResponse = await didModule.createDidTx(
                 signInputs,
                 didPayload,
-                (await wallet.getAccounts())[0].address,
+                feePayer,
                 fee
             )
 
@@ -67,37 +59,178 @@ describe('ResourceModule', () => {
 
             expect(didTx.code).toBe(0)
 
-            // Creating a resource
-
+            // create a did linked resource
             const resourceModule = new ResourceModule(signer)
 
             const resourcePayload: MsgCreateResourcePayload = {
                 collectionId: didPayload.id.split(":").reverse()[0],
-                id: randomUUID(),
+                id: v4(),
                 version: "1.0",
                 alsoKnownAs: [],
                 name: 'Test Resource',
                 resourceType: 'test-resource-type',
-                data: new TextEncoder().encode("{ \"message\": \"hello world\"}")
+                data: new TextEncoder().encode("{\"message\": \"hello world\"}")
             }
 
+            const resourceSignInputs: ISignInputs[] = [
+                {
+                    verificationMethodId: didPayload.verificationMethod![0].id,
+                    keyType: 'Ed25519',
+                    privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
+                }
+            ]
+
+            const feeResourceJson = await ResourceModule.generateCreateResourceJsonFees(feePayer)
+            const resourceTx = await resourceModule.createResourceTx(
+                resourceSignInputs,
+                resourcePayload,
+                feePayer,
+                feeResourceJson
+            )
+
             console.warn(`Using payload: ${JSON.stringify(resourcePayload)}`)
+            console.warn(`DID Tx: ${JSON.stringify(resourceTx)}`)
+
+            expect(resourceTx.code).toBe(0)
+        }, defaultAsyncTxTimeout)
+
+        it('should create a new Resource - case: image', async () => {
+            // create an associated did document
+            const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
+
+            const registry = createDefaultCheqdRegistry(Array.from(DIDModule.registryTypes).concat(Array.from(ResourceModule.registryTypes)))
+
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet, { registry })
+            
+            const didModule = new DIDModule(signer)
+
+            const keyPair = createKeyPairBase64()
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+
+            const signInputs: ISignInputs[] = [
+                {
+                    verificationMethodId: didPayload.verificationMethod![0].id,
+                    privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
+                }
+            ]
+
+            const feePayer = (await wallet.getAccounts())[0].address
+            const fee = await DIDModule.generateCreateDidDocFees(feePayer)
+            const didTx: DeliverTxResponse = await didModule.createDidTx(
+                signInputs,
+                didPayload,
+                feePayer,
+                fee
+            )
+
+            console.warn(`Using payload: ${JSON.stringify(didPayload)}`)
+            console.warn(`DID Tx: ${JSON.stringify(didTx)}`)
+
+            expect(didTx.code).toBe(0)
+
+            // create a did linked resource
+            const resourceModule = new ResourceModule(signer)
+
+            const resourcePayload: MsgCreateResourcePayload = {
+                collectionId: didPayload.id.split(":").reverse()[0],
+                id: v4(),
+                version: "1.0",
+                alsoKnownAs: [],
+                name: 'Test Resource',
+                resourceType: 'test-resource-type',
+                data: fromString(image_content, 'base64')
+            }
 
             const resourceSignInputs: ISignInputs[] = [
                 {
-                    verificationMethodId: didPayload.verificationMethod[0].id,
+                    verificationMethodId: didPayload.verificationMethod![0].id,
                     keyType: 'Ed25519',
                     privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
                 }
             ]
 
+            const feeResourceImage = await ResourceModule.generateCreateResourceImageFees(feePayer)
             const resourceTx = await resourceModule.createResourceTx(
                 resourceSignInputs,
                 resourcePayload,
-                (await wallet.getAccounts())[0].address,
+                feePayer,
+                feeResourceImage
+            )
+
+            console.warn(`Using payload: ${JSON.stringify(resourcePayload)}`)
+            console.warn(`DID Tx: ${JSON.stringify(resourceTx)}`)
+
+            expect(resourceTx.code).toBe(0)
+        }, defaultAsyncTxTimeout)
+
+        it('should create a new Resource - case: default', async () => {
+            // create an associated did document
+            const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic, {prefix: faucet.prefix})
+
+            const registry = createDefaultCheqdRegistry(Array.from(DIDModule.registryTypes).concat(Array.from(ResourceModule.registryTypes)))
+
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet, { registry })
+            
+            const didModule = new DIDModule(signer)
+
+            const keyPair = createKeyPairBase64()
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
+            const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
+            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+
+            const signInputs: ISignInputs[] = [
+                {
+                    verificationMethodId: didPayload.verificationMethod![0].id,
+                    privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
+                }
+            ]
+
+            const feePayer = (await wallet.getAccounts())[0].address
+            const fee = await DIDModule.generateCreateDidDocFees(feePayer)
+            const didTx: DeliverTxResponse = await didModule.createDidTx(
+                signInputs,
+                didPayload,
+                feePayer,
                 fee
             )
 
+            console.warn(`Using payload: ${JSON.stringify(didPayload)}`)
+            console.warn(`DID Tx: ${JSON.stringify(didTx)}`)
+
+            expect(didTx.code).toBe(0)
+
+            // create a did linked resource
+            const resourceModule = new ResourceModule(signer)
+
+            const resourcePayload: MsgCreateResourcePayload = {
+                collectionId: didPayload.id.split(":").reverse()[0],
+                id: v4(),
+                version: "1.0",
+                alsoKnownAs: [],
+                name: 'Test Resource',
+                resourceType: 'test-resource-type',
+                data: new TextEncoder().encode(default_content)
+            }
+
+            const resourceSignInputs: ISignInputs[] = [
+                {
+                    verificationMethodId: didPayload.verificationMethod![0].id,
+                    keyType: 'Ed25519',
+                    privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
+                }
+            ]
+
+            const feeResourceDefault = await ResourceModule.generateCreateResourceDefaultFees(feePayer)
+            const resourceTx = await resourceModule.createResourceTx(
+                resourceSignInputs,
+                resourcePayload,
+                feePayer,
+                feeResourceDefault
+            )
+
+            console.warn(`Using payload: ${JSON.stringify(resourcePayload)}`)
             console.warn(`DID Tx: ${JSON.stringify(resourceTx)}`)
 
             expect(resourceTx.code).toBe(0)

package/tests/signer.test.ts

@@ -3,10 +3,12 @@ import { DirectSecp256k1HdWallet, Registry } from "@cosmjs/proto-signing"
 import { EdDSASigner } from "did-jwt"
 import { typeUrlMsgCreateDidDoc } from '../src/modules/did'
 import { CheqdSigningStargateClient } from "../src/signer"
-import { ISignInputs, MethodSpecificIdAlgo, MsgCreateDidPayload, VerificationMethods } from "../src/types"
+import { ISignInputs, MethodSpecificIdAlgo, VerificationMethods } from "../src/types"
 import { fromString, toString } from 'uint8arrays'
-import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, exampleCheqdNetwork, faucet } from "./testutils.test"
+import { createDidPayload, createDidVerificationMethod, createKeyPairBase64, createVerificationKeys, validateSpecCompliantPayload } from '../src/utils';
+import { localnet, faucet } from "./testutils.test"
 import { verify } from "@stablelib/ed25519"
+import { v4 } from "uuid"
 
 const nonExistingDid = "did:cHeQd:fantasticnet:123"
 const nonExistingKeyId = 'did:cHeQd:fantasticnet:123#key-678'
@@ -34,7 +36,7 @@ describe('CheqdSigningStargateClient', () => {
     describe('constructor', () => {
         it('can be instantiated & works for cheqd networks', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             expect(signer).toBeInstanceOf(CheqdSigningStargateClient)
         })
 
@@ -42,7 +44,7 @@ describe('CheqdSigningStargateClient', () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
             const registry = new Registry()
             registry.register(typeUrlMsgCreateDidDoc, MsgCreateDidDoc)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet, { registry })
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet, { registry })
             expect(signer.registry.lookupType(typeUrlMsgCreateDidDoc)).toBe(MsgCreateDidDoc)
         })
     })
@@ -50,61 +52,67 @@ describe('CheqdSigningStargateClient', () => {
     describe('getDidSigner', () => {
         it('can get a signer for a did', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
-            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
-            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys]))
-            const didSigner = await signer.getDidSigner(didPayload.verificationMethod[0].id, didPayload.verificationMethod)
+            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
+            const { protobufVerificationMethod } = validateSpecCompliantPayload(didPayload)
+
+            const didSigner = await signer.getDidSigner(didPayload.verificationMethod![0].id, protobufVerificationMethod!)
 
             expect(didSigner).toBe(EdDSASigner)
         })
 
         it('should throw for a non-supported verification method', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
 
             await expect(signer.getDidSigner(nonExistingVerificationDidDocument.verificationMethod[0].id, nonExistingVerificationDidDocument.verificationMethod)).rejects.toThrow()
         })
 
         it('should throw for non-matching verification method id', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
-            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
-            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
-            await expect(signer.getDidSigner(nonExistingKeyId, didPayload.verificationMethod)).rejects.toThrow()
+            const payload = createDidPayload(verificationMethods, [verificationKeys])
+            const { protobufVerificationMethod } = validateSpecCompliantPayload(payload)
+
+            await expect(signer.getDidSigner(nonExistingKeyId, protobufVerificationMethod!)).rejects.toThrow()
         })
     })
 
     describe('checkDidSigners', () => {
         it('it should instantiate a signer for a did', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
-            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
-            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys]))
-
-            const didSigners = await signer.checkDidSigners(didPayload.verificationMethod)
+            const payload = createDidPayload(verificationMethods, [verificationKeys])
+            const { protobufVerificationMethod } = validateSpecCompliantPayload(payload)
+            const didSigners = await signer.checkDidSigners(protobufVerificationMethod)
 
             expect(didSigners[VerificationMethods.Ed255192020]).toBe(EdDSASigner)
         })
 
         it('should instantiate multiple signers for a did with multiple verification methods', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const keyPair1 = createKeyPairBase64()
             const keyPair2 = createKeyPairBase64()
             const keyPair3 = createKeyPairBase64()
-            const verificationKeys1 = createVerificationKeys(keyPair1, MethodSpecificIdAlgo.Base58, 'key-1', 16)
-            const verificationKeys2 = createVerificationKeys(keyPair2, MethodSpecificIdAlgo.Base58, 'key-2', 16)
-            const verificationKeys3 = createVerificationKeys(keyPair3, MethodSpecificIdAlgo.Base58, 'key-3', 16)
+            const verificationKeys1 = createVerificationKeys(keyPair1.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
+            const verificationKeys2 = createVerificationKeys(keyPair2.publicKey, MethodSpecificIdAlgo.Base58, 'key-2')
+            const verificationKeys3 = createVerificationKeys(keyPair3.publicKey, MethodSpecificIdAlgo.Base58, 'key-3')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020, VerificationMethods.JWK, VerificationMethods.Ed255192018], [verificationKeys1, verificationKeys2, verificationKeys3])
-            const didPayload = MsgCreateDidPayload.transformPayload(createDidPayload(verificationMethods, [verificationKeys1, verificationKeys2, verificationKeys3]))
 
-            const didSigners = await signer.checkDidSigners(didPayload.verificationMethod)
+            const payload = createDidPayload(verificationMethods, [verificationKeys1, verificationKeys2, verificationKeys3])
+            const { protobufVerificationMethod } = validateSpecCompliantPayload(payload)
+
+            const didSigners = await signer.checkDidSigners(protobufVerificationMethod)
 
             expect(didSigners[VerificationMethods.Ed255192020]).toBe(EdDSASigner)
             expect(didSigners[VerificationMethods.JWK]).toBe(EdDSASigner)
@@ -113,7 +121,7 @@ describe('CheqdSigningStargateClient', () => {
 
         it('should throw for non-supported verification method', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const verificationMethod: Partial<VerificationMethod> = {
                 id: nonExistingKeyId,
                 verificationMethodType: nonExistingVerificationMethod,
@@ -128,20 +136,36 @@ describe('CheqdSigningStargateClient', () => {
     describe('signCreateDidTx', () => {
         it('should sign a did tx with valid signature', async () => {
             const wallet = await DirectSecp256k1HdWallet.fromMnemonic(faucet.mnemonic)
-            const signer = await CheqdSigningStargateClient.connectWithSigner(exampleCheqdNetwork.rpcUrl, wallet)
+            const signer = await CheqdSigningStargateClient.connectWithSigner(localnet.rpcUrl, wallet)
             const keyPair = createKeyPairBase64()
-            const verificationKeys = createVerificationKeys(keyPair, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+            const verificationKeys = createVerificationKeys(keyPair.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
             const verificationMethods = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
-            const didPayload = MsgCreateDidPayload.transformPayload(MsgCreateDidPayload.fromPartial(createDidPayload(verificationMethods, [verificationKeys])))
+            const didPayload = createDidPayload(verificationMethods, [verificationKeys])
             const signInputs: ISignInputs[] = [
                 {
-                    verificationMethodId: didPayload.verificationMethod[0].id,
+                    verificationMethodId: didPayload.verificationMethod![0].id,
                     privateKeyHex: toString(fromString(keyPair.privateKey, 'base64'), 'hex')
                 }
             ]
-            const signInfos = await signer.signCreateDidTx(signInputs, didPayload)
+            const { protobufVerificationMethod, protobufService } = validateSpecCompliantPayload(didPayload)
+            const versionId = v4()
+            const payload = MsgCreateDidDocPayload.fromPartial({
+                context: <string[]>didPayload?.['@context'],
+                id: didPayload.id,
+                controller: <string[]>didPayload.controller,
+                verificationMethod: protobufVerificationMethod,
+                authentication: <string[]>didPayload.authentication,
+                assertionMethod: <string[]>didPayload.assertionMethod,
+                capabilityInvocation: <string[]>didPayload.capabilityInvocation,
+                capabilityDelegation: <string[]>didPayload.capabilityDelegation,
+                keyAgreement: <string[]>didPayload.keyAgreement,
+                service: protobufService,
+                alsoKnownAs: <string[]>didPayload.alsoKnownAs,
+                versionId: versionId
+            })
+            const signInfos = await signer.signCreateDidTx(signInputs, payload)
             const publicKeyRaw = fromString(keyPair.publicKey, 'base64')
-            const messageRaw = MsgCreateDidDocPayload.encode(didPayload).finish()
+            const messageRaw = MsgCreateDidDocPayload.encode(payload).finish()
 
             const verified = verify(
                 publicKeyRaw,

package/tests/testutils.test.ts

@@ -1,11 +1,4 @@
-import { CheqdNetwork, IKeyPair, IVerificationKeys, MethodSpecificIdAlgo, MsgCreateDidPayload, TMethodSpecificId, TVerificationKey, TVerificationKeyPrefix, VerificationMethodPayload, VerificationMethods } from "../src/types"
-import { bases } from 'multiformats/basics'
-import { base64ToBytes } from "did-jwt"
-import { fromString, toString } from 'uint8arrays'
-import { generateKeyPair, KeyPair } from '@stablelib/ed25519'
 import { GasPrice } from "@cosmjs/stargate"
-import { v4 } from 'uuid'
-import { createHash } from 'crypto'
 
 export const faucet = {
     prefix: 'cheqd',
@@ -14,150 +7,12 @@ export const faucet = {
     address: 'cheqd1rnr5jrt4exl0samwj0yegv99jeskl0hsxmcz96',
 }
 
-export const exampleCheqdNetwork = {
+export const localnet = {
     network: 'testnet',
     rpcUrl: 'http://localhost:26657',
     gasPrice: GasPrice.fromString( `50${faucet.minimalDenom}` )
 }
 
-// multicodec ed25519-pub header as varint
-const MULTICODEC_ED25519_PUB_HEADER = new Uint8Array([0xed, 0x01]);
+export const image_content = 'iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAAQMAAABmvDolAAAAA1BMVEW10NBjBBbqAAAAH0lEQVRoge3BAQ0AAADCoPdPbQ43oAAAAAAAAAAAvg0hAAABmmDh1QAAAABJRU5ErkJggg' as const
 
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
-export function createKeyPairRaw(): KeyPair {
-    return generateKeyPair()
-}
-
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
-export function createKeyPairBase64(): IKeyPair {
-    const keyPair = generateKeyPair()
-    return {
-        publicKey: toString(keyPair.publicKey, 'base64'),
-        privateKey: toString(keyPair.secretKey, 'base64'),
-    }
-}
-
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
-export function createKeyPairHex(): IKeyPair {
-    const keyPair = generateKeyPair()
-    return {
-        publicKey: toString(keyPair.publicKey, 'hex'),
-        privateKey: toString(keyPair.secretKey, 'hex'),
-    }
-}
-
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
-export function createVerificationKeys(keyPair: IKeyPair, algo: MethodSpecificIdAlgo, key: TVerificationKey<TVerificationKeyPrefix, number>, length: number = 32, network: CheqdNetwork = CheqdNetwork.Testnet): IVerificationKeys {
-    let methodSpecificId: TMethodSpecificId
-    let didUrl: IVerificationKeys['didUrl']
-    switch (algo) {
-        case MethodSpecificIdAlgo.Base58:
-            methodSpecificId = bases['base58btc'].encode(base64ToBytes(keyPair.publicKey))
-            didUrl = `did:cheqd:${network}:${(bases['base58btc'].encode((fromString(sha256(keyPair.publicKey))).slice(0,16))).slice(1)}`
-            return {
-                methodSpecificId,
-                didUrl,
-                keyId: `${didUrl}#${key}`,
-                publicKey: keyPair.publicKey,
-            }
-        case MethodSpecificIdAlgo.Uuid:
-            methodSpecificId = bases['base58btc'].encode(base64ToBytes(keyPair.publicKey))
-            didUrl = `did:cheqd:${network}:${v4()}`
-            return {
-                methodSpecificId,
-                didUrl,
-                keyId: `${didUrl}#${key}`,
-                publicKey: keyPair.publicKey,
-            }
-    }
-}
-
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
- export function createDidVerificationMethod(verificationMethodTypes: VerificationMethods[], verificationKeys: IVerificationKeys[]): VerificationMethodPayload[] {
-    return verificationMethodTypes.map((type, _) => {
-        switch (type) {
-            case VerificationMethods.Ed255192020:
-                return {
-                    id: verificationKeys[_].keyId,
-                    type,
-                    controller: verificationKeys[_].didUrl,
-                    publicKeyMultibase: _encodeMbKey(MULTICODEC_ED25519_PUB_HEADER, base64ToBytes(verificationKeys[_].publicKey))
-                }
-            
-            case VerificationMethods.Ed255192018:
-                return {
-                    id: verificationKeys[_].keyId,
-                    type,
-                    controller: verificationKeys[_].didUrl,
-                    publicKeyBase58: verificationKeys[_].methodSpecificId.slice(1)
-                }
-
-            case VerificationMethods.JWK:
-                return {
-                    id: verificationKeys[_].keyId,
-                    type,
-                    controller: verificationKeys[_].didUrl,
-                    publicKeyJWK: {
-                        crv: 'Ed25519',
-                        kty: 'OKP',
-                        x: toString( fromString( verificationKeys[_].publicKey, 'base64pad' ), 'base64url' )
-                    }
-                }
-        }
-    }) ?? []
-}
-
-/**
- *? General test utils. Look for src/utils.ts for stable utils exports.
- *? Used for testing purposes.
- ** NOTE: The following utils are stable but subject to change at any given moment.
- */
-export function createDidPayload(verificationMethods: VerificationMethodPayload[], verificationKeys: IVerificationKeys[]): MsgCreateDidPayload {
-    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 MsgCreateDidPayload.fromPartial(
-        {
-            id: did,
-            controller: verificationKeys.map(key => key.didUrl),
-            verificationMethod: verificationMethods,
-            authentication: verificationKeys.map(key => key.keyId),
-            versionId: v4()
-        }
-    )
-}
-
-function sha256(message: string) {
-    return createHash('sha256').update(message).digest('hex')
-  }
-
-  function _encodeMbKey(header: any, key: Uint8Array) {
-    const mbKey = new Uint8Array(header.length + key.length);
-  
-    mbKey.set(header);
-    mbKey.set(key, header.length);
-  
-    return bases['base58btc'].encode(mbKey);
-  }
+export const default_content = '<p>Test file content</p>'

package/tests/utils.test.ts

@@ -1,5 +1,5 @@
 import { TImportableEd25519Key, createSignInputsFromImportableEd25519Key } from '../src/utils'
-import { createDidVerificationMethod, createVerificationKeys, createKeyPairRaw } from './testutils.test'
+import { createDidVerificationMethod, createVerificationKeys, createKeyPairRaw } from '../src/utils'
 import { toString } from 'uint8arrays'
 import { IKeyPair, MethodSpecificIdAlgo, VerificationMethods } from '../src/types'
 
@@ -17,7 +17,7 @@ describe('createSignInputsFromImportableEd25519Key', () => {
             privateKey: toString(keyPair.secretKey, 'base64'),
         }
 
-        const verificationKeys = createVerificationKeys(keyPairBase64, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+        const verificationKeys = createVerificationKeys(keyPairBase64.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
         const verificationMethod = createDidVerificationMethod([VerificationMethods.Ed255192020], [verificationKeys])
         const signInput = createSignInputsFromImportableEd25519Key(importableEd25519Key, verificationMethod)
 
@@ -37,7 +37,7 @@ describe('createSignInputsFromImportableEd25519Key', () => {
             privateKey: toString(keyPair.secretKey, 'base64'),
         }
 
-        const verificationKeys = createVerificationKeys(keyPairBase64, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+        const verificationKeys = createVerificationKeys(keyPairBase64.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
         const verificationMethod = createDidVerificationMethod([VerificationMethods.Ed255192018], [verificationKeys])
         const signInput = createSignInputsFromImportableEd25519Key(importableEd25519Key, verificationMethod)
 
@@ -57,7 +57,7 @@ describe('createSignInputsFromImportableEd25519Key', () => {
             privateKey: toString(keyPair.secretKey, 'base64'),
         }
 
-        const verificationKeys = createVerificationKeys(keyPairBase64, MethodSpecificIdAlgo.Base58, 'key-1', 16)
+        const verificationKeys = createVerificationKeys(keyPairBase64.publicKey, MethodSpecificIdAlgo.Base58, 'key-1')
         const verificationMethod = createDidVerificationMethod([VerificationMethods.JWK], [verificationKeys])
         const signInput = createSignInputsFromImportableEd25519Key(importableEd25519Key, verificationMethod)