fix: Consolidate utility functions and improve code clarity

- Moved base58Encode and encodeVarint functions to utils.ts for better organization and reuse.
- Updated imports in create.ts and resolve.ts to reflect the new utility function locations.
- Changed variable declarations in resolveNumAlgo2 for consistency and clarity.

Author: brianorwhatever

src/lib/create.ts

@@ -1,6 +1,6 @@
 import { Numalgo2Prefixes, VARIANT_4_PREFIX, JSON_MULTICODEC_PREFIX, SHA256_MULTIHASH_PREFIX, SHA256_HASH_LENGTH, MULTIBASE_BASE58BTC_PREFIX } from "./constants.js";
 import type { IDIDDocumentServiceDescriptor, IDIDDocumentVerificationMethod } from "./interfaces.js"
-import { encodeService } from "./utils.js";
+import { base58Encode, encodeService, encodeVarint } from "./utils.js";
 import { validateAuthentication, validateEncryption } from "./validators.js";
 import { createHash } from 'crypto';
 
@@ -123,35 +123,3 @@ export const createNumAlgo4 = async (
     // Step 3: Construct the DID
     return `did:peer:${VARIANT_4_PREFIX}${hashString}:${encodedDocument}`;
 }
-
-// Helper function to encode varint
-function encodeVarint(value: number): Uint8Array {
-    const bytes: number[] = [];
-    while (value >= 0x80) {
-        bytes.push((value & 0xFF) | 0x80);
-        value >>>= 7;
-    }
-    bytes.push(value & 0xFF);
-    return new Uint8Array(bytes);
-}
-
-// Helper function for base58 encoding
-function base58Encode(bytes: Uint8Array): string {
-    const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-    let num = BigInt('0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join(''));
-    
-    if (num === 0n) return alphabet[0];
-    
-    let result = '';
-    while (num > 0n) {
-        result = alphabet[Number(num % 58n)] + result;
-        num = num / 58n;
-    }
-    
-    // Add leading zeros
-    for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
-        result = alphabet[0] + result;
-    }
-    
-    return result;
-}

src/lib/resolve.ts

@@ -1,6 +1,6 @@
 import { Numalgo2Prefixes, VARIANT_4_PREFIX, JSON_MULTICODEC_PREFIX, SHA256_MULTIHASH_PREFIX, SHA256_HASH_LENGTH, MULTIBASE_BASE58BTC_PREFIX } from "./constants.js";
 import type { IDIDDocument, IDIDDocumentServiceDescriptor, IDIDDocumentVerificationMethod, IDIDRepository } from "./interfaces.js";
-import { assert, createDIDDocument, decodeService, isPeerDID } from "./utils.js";
+import { assert, base58Encode, createDIDDocument, decodeService, isPeerDID } from "./utils.js";
 import { createHash } from 'crypto';
 
 export const resolve = async (did: string, repository?: IDIDRepository): Promise<IDIDDocument> => {
@@ -35,11 +35,11 @@ export const resolveNumAlgo1 = async (did: string): Promise<IDIDDocument> => {
 }
 
 export const resolveNumAlgo2 = async (did: string): Promise<IDIDDocument> => {
-    let authKeys: IDIDDocumentVerificationMethod[] = [];
-    let encKeys: IDIDDocumentVerificationMethod[] = [];
-    let services: IDIDDocumentServiceDescriptor[] = [];
-    let keys = did.split('.')
-    let serviceMetadata = {index: 0};
+    const authKeys: IDIDDocumentVerificationMethod[] = [];
+    const encKeys: IDIDDocumentVerificationMethod[] = [];
+    const services: IDIDDocumentServiceDescriptor[] = [];
+    const keys = did.split('.')
+    const serviceMetadata = {index: 0};
     let keyIndex = 1;
     delete keys[0];
     keys.forEach(k => {
@@ -258,24 +258,3 @@ function decodeVarint(bytes: Uint8Array): { value: number; bytes: Uint8Array } {
         bytes: bytes.slice(index)
     };
 }
-
-// Helper function for base58 encoding (reused from create.ts)
-function base58Encode(bytes: Uint8Array): string {
-    const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-    let num = BigInt('0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join(''));
-    
-    if (num === 0n) return alphabet[0];
-    
-    let result = '';
-    while (num > 0n) {
-        result = alphabet[Number(num % 58n)] + result;
-        num = num / 58n;
-    }
-    
-    // Add leading zeros
-    for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
-        result = alphabet[0] + result;
-    }
-    
-    return result;
-}

src/lib/utils.ts

@@ -3,7 +3,7 @@ import { Numalgo2Prefixes, ServiceReplacements } from "./constants.js";
 import type { IDIDDocumentServiceDescriptor, IDIDDocumentVerificationMethod } from "./interfaces.js";
 
 export const assert = (exp: boolean, message: string) => {
-    if(!Boolean(exp)) throw new Error(message || 'unknown assertion error');
+    if(!exp) throw new Error(message || 'unknown assertion error');
 }
 
 export const base64 = {
@@ -92,7 +92,7 @@ export const decodeService = (did: string, service: string, metadata: Record<str
 export const isPeerDID = (did: string) => {
     // Updated regex to support variant 4 long form DIDs
     // Original patterns for variants 0, 1, 2
-    const variant012Pattern = '^did:peer:(([01](z)([1-9a-km-zA-HJ-NP-Z]*))|(2((\.[AEVID](z)([1-9a-km-zA-HJ-NP-Z]*))+(\.(S)[0-9a-zA-Z=]*)*)))$';
+    const variant012Pattern = '^did:peer:(([01](z)([1-9a-km-zA-HJ-NP-Z]*))|(2((.[AEVID](z)([1-9a-km-zA-HJ-NP-Z]*))+(.(S)[0-9a-zA-Z=]*)*)))$';
 
     // Variant 4 pattern - can be short form (did:peer:4z...) or long form (did:peer:4z...:z...)
     const variant4Pattern = '^did:peer:4z[1-9a-km-zA-HJ-NP-Z]*(:[a-zA-Z0-9]+)*$';
@@ -120,7 +120,7 @@ export const createDIDDocument = (
         controller: k.controller,
         publicKeyMultibase: k.publicKeyMultibase
     }))
-    let doc: any = {
+    const doc: any = {
         "id": did,
         assertionMethod: auth,
         authentication: auth,
@@ -141,3 +141,59 @@ export const createDIDDocument = (
     }
     return {"@context": contexts, ...doc};
 }
+
+// Helper function to encode varint
+export const encodeVarint = (value: number): Uint8Array => {
+    const bytes: number[] = [];
+    while (value >= 0x80) {
+        bytes.push((value & 0xFF) | 0x80);
+        value >>>= 7;
+    }
+    bytes.push(value & 0xFF);
+    return new Uint8Array(bytes);
+}
+
+// Helper to decode unsigned varints (LEB128)
+export const decodeVarint = (
+    bytes: Uint8Array
+): { value: number; bytes: Uint8Array } => {
+    let value = 0;
+    let shift = 0;
+    let index = 0;
+
+    while (index < bytes.length) {
+        const byte = bytes[index++];
+        value |= (byte & 0x7F) << shift;
+        shift += 7;
+
+        // If the continuation bit is not set, we're done
+        if ((byte & 0x80) === 0) {
+            break;
+        }
+    }
+
+    return {
+        value,
+        bytes: bytes.slice(index)
+    };
+};
+
+export const base58Encode = (bytes: Uint8Array): string => {
+    const alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    let num = BigInt('0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join(''));
+    
+    if (num === 0n) return alphabet[0];
+    
+    let result = '';
+    while (num > 0n) {
+        result = alphabet[Number(num % 58n)] + result;
+        num = num / 58n;
+    }
+    
+    // Add leading zeros
+    for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
+        result = alphabet[0] + result;
+    }
+    
+    return result;
+}