signify-ts 0.1.0 → 0.1.1

package/src/keri/app/apping.ts

@@ -0,0 +1,12 @@
+import libsodium from "libsodium-wrappers-sumo";
+import {Salter} from "../core/salter";
+
+
+export function randomPasscode(): string {
+    let raw = libsodium.randombytes_buf(16);
+    let salter = new Salter({raw: raw})
+
+    return salter.qb64.substring(2)
+}
+
+

package/src/keri/app/client.ts

@@ -0,0 +1,30 @@
+
+
+export class Client {
+    private readonly _url: string
+
+    constructor(url: string) {
+        this._url = url
+    }
+
+    url(path: string): string {
+        let url = new URL(path, this._url)
+
+        return url.href
+    }
+
+    getAccount(name: string): Promise<Response> {
+        let url = this.url(`/account/${name}`)
+        let req = new Request(url, {method: "GET"})
+        return fetch(req)
+    }
+
+    createAccount(name: string, key: string, ndig: string): Promise<Response> {
+        let url = this.url(`/account/${name}`)
+        let body = {key, ndig}
+        let req = new Request(url, {method: "POST", body: JSON.stringify(body)})
+        return fetch(req)
+    }
+
+
+}

package/src/keri/app/habery.ts

@@ -0,0 +1,152 @@
+import {Algos, Manager} from "../core/manager";
+import {MtrDex} from "../core/matter";
+import {Salter} from "../core/salter";
+import {Verfer} from "../core/verfer";
+import {Diger} from "../core/diger";
+import {incept} from "../core/eventing";
+import {Serder} from "../core/serder";
+
+
+export class TraitCodex {
+    EstOnly: string = 'EO'  // Only allow establishment events
+    DoNotDelegate: string = 'DND'  // Dot not allow delegated identifiers
+}
+
+export const TraitDex = new TraitCodex()
+
+export interface HaberyArgs {
+    name: string
+    passcode?: string
+    seed?: string | undefined
+    aeid?: string | undefined
+    pidx?: number | undefined
+    salt?: string | undefined
+    tier?: string | undefined
+
+}
+
+export interface MakeHabArgs {
+    code?: string
+    transferable?: boolean
+    isith?: string
+    icount?: number
+    nsith?: string
+    ncount?: number
+    toad?: string | number
+    wits?: Array<string>
+    delpre?: string
+    estOnly?: boolean
+    DnD?: boolean
+    data?: any
+}
+
+export class Hab {
+    public name: string
+    public serder: Serder
+
+    constructor(name: string, icp: Serder) {
+        this.name = name
+        this.serder = icp
+    }
+
+    get pre(): string {
+        return this.serder.ked["i"]
+    }
+}
+
+
+export class Habery {
+    private readonly _name: string;
+    private readonly _mgr: Manager;
+    private readonly _habs: Map<string, Hab> = new Map<string, Hab>()
+
+    constructor({name, passcode, seed, aeid, pidx, salt}: HaberyArgs) {
+        this._name = name
+        if (passcode != undefined && seed == undefined) {
+            if (passcode.length < 21) {
+                throw new Error("Bran (passcode seed material) too short.")
+            }
+
+            let bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21)  // qb64 salt for seed
+            let signer = new Salter({qb64: bran}).signer(MtrDex.Ed25519_Seed, false)
+            seed = signer.qb64
+            if (aeid == undefined) {
+                aeid = signer.verfer.qb64  // lest it remove encryption
+            }
+        }
+        let algo;
+
+        if (salt != undefined) {
+            algo = Algos.salty
+            salt = new Salter({qb64: salt}).qb64
+        } else {
+            algo = Algos.randy
+        }
+
+        this._mgr = new Manager({seed: seed, aeid: aeid, pidx: pidx, algo: algo, salt: salt})
+    }
+
+    get mgr(): Manager {
+        return this._mgr
+    }
+
+    get habs(): Array<Hab> {
+        return Array.from(this._habs.values())
+    }
+
+    habByName(name: string): Hab|undefined {
+        return this._habs.get(name)
+    }
+
+    makeHab(name:string, {code = MtrDex.Blake3_256, transferable = true, isith = undefined, icount = 1,
+                          nsith = undefined, ncount = undefined, toad = undefined, wits = undefined, delpre = undefined,
+                          estOnly = false, DnD = false, data = undefined}: MakeHabArgs): Hab {
+
+        if (nsith == undefined) {
+            nsith = isith
+        }
+        if (ncount == undefined) {
+            ncount = icount
+        }
+        if (!transferable) {
+            ncount = 0
+            nsith = "0"
+            code = MtrDex.Ed25519N
+        }
+
+        let [verfers, digers] = this._mgr.incept({
+            icount: icount, ncount: ncount, stem: this.name,
+            transferable: transferable, temp: false
+        })
+
+        icount = verfers.length
+        ncount = digers != undefined ? digers.length : 0
+        if (isith == undefined) {
+            isith = `${Math.max(1, Math.ceil(icount/2)).toString(16)}`
+        }
+        if (nsith == undefined) {
+            nsith = `${Math.max(1, Math.ceil(ncount/2)).toString(16)}`
+        }
+
+        let cnfg = new Array<string>()
+        if (estOnly) {
+            cnfg.push(TraitDex.EstOnly)
+        }
+        if(DnD) {
+            cnfg.push(TraitDex.DoNotDelegate)
+        }
+
+        let keys = Array.from(verfers, (verfer: Verfer) => verfer.qb64)
+        let ndigs = Array.from(digers, (diger: Diger) => diger.qb64)
+
+
+        const icp = incept({keys, isith, ndigs, nsith, toad, wits, cnfg, data, code, delpre})
+        const hab = new Hab(name, icp)
+        this._habs.set(name, hab)
+        return hab
+    }
+
+    get name(): string {
+        return this._name
+    }
+}

package/src/keri/app/signify.ts

@@ -0,0 +1,12 @@
+import {Habery} from "./habery";
+import {Accountant} from "./accountant";
+import {Client} from "./client";
+
+
+export class Signify {
+    private readonly _hby?: Habery
+    private readonly _act?: Accountant
+    private readonly _client?: Client
+    constructor(url:string, name:string, passcode: string) {
+    }
+}

package/src/keri/app/tsconfig.json

@@ -0,0 +1,100 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Enable incremental compilation */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./",                          /* Specify the folder for .tsbuildinfo incremental compilation files. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES2022",                                     /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */
+    // "reactNamespace": "",                             /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+
+    /* Modules */
+    "module": "commonjs",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have `@internal` in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like `__extends` in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing `const enum` declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied `any` type.. */
+    // "strictNullChecks": true,                         /* When type checking, take into account `null` and `undefined`. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when `this` is given the type `any`. */
+    // "useUnknownInCatchVariables": true,               /* Type catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when a local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  }
+}

package/src/keri/core/authing.ts

@@ -0,0 +1,129 @@
+import {Signer} from "./signer";
+import {Verfer} from "./verfer";
+import {desiginput, normalize, siginput} from "./httping";
+import {b} from "./core";
+import {parseDictionary} from "structured-headers";
+import {Signage, signature} from "../end/ending";
+import {Cigar} from "./cigar";
+import {Siger} from "./siger";
+
+import Base64 from "urlsafe-base64"
+
+export class Authenticater {
+
+    static DefaultFields = [
+        "Signify-Resource",
+        "@method",
+        "@path",
+        "Signify-Timestamp"
+    ]
+    private _verfer: Verfer;
+    private readonly _csig: Signer;
+
+    constructor(csig: Signer, aaid: string) {
+        this._csig = csig
+        this._verfer = new Verfer({qb64: aaid})
+    }
+
+    verify(headers: Headers, method: string, path: string): boolean {
+        let siginput = headers.get("Signature-Input")
+        if (siginput == null) {
+            return false
+        }
+        let signature = headers.get("Signature")
+        if (signature == null) {
+            return false
+        }
+
+        let inputs = desiginput(siginput)
+        inputs = inputs.filter((input) => input.name == "signify")
+
+        if (inputs.length == 0) {
+            return false
+        }
+
+        inputs.forEach((input) => {
+            let items = new Array<string>()
+            input.fields!.forEach((field: string) => {
+                if (field.startsWith("@")) {
+                    if (field == "@method") {
+                        items.push(`"${field}": ${method}`)
+                    } else if (field == "@path") {
+                        items.push(`"${field}": ${path}`)
+                    }
+                } else {
+                    if (headers.has(field)) {
+                        let value = normalize(headers.get(field) as string)
+                        items.push(`"${field}": ${value}`)
+                    }
+                }
+            })
+
+            let values = new Array<string>()
+            values.push(`(${input.fields!.join(" ")})`)
+            values.push(`created=${input.created}`)
+
+            if (input.expires != undefined) {
+                values.push(`expires=${input.expires}`)
+            }
+            if (input.nonce != undefined) {
+                values.push(`nonce=${input.nonce}`)
+            }
+            if (input.keyid != undefined) {
+                values.push(`keyid=${input.keyid}`)
+            }
+            if (input.context != undefined) {
+                values.push(`context=${input.context}`)
+            }
+            if (input.alg != undefined) {
+                values.push(`alg=${input.alg}`)
+            }
+
+            let params = values.join(";")
+
+            items.push(`"@signature-params: ${params}"`)
+            let ser = b(items.join("\n"))
+
+            let signage = parseDictionary(signature!)
+            if (!signage.has("indexed")) {
+                throw new Error(`invalid signate ${signage}`)
+            }
+
+            let item = signage.get("indexed")!
+            let raw = Base64.decode(item[1].get(input.name) as string)
+
+            if (!this._verfer.verify(raw, ser)) {
+                throw new Error(`Signature for {inputage} invalid.`)
+            }
+        })
+
+        return true
+    }
+
+    sign(headers: Headers, method: string, path: string, fields?: Array<string>): Headers {
+        if (fields == undefined) {
+            fields = Authenticater.DefaultFields
+        }
+
+        let [header, sig] = siginput(this._csig, {
+            name: "signify", method, path, headers, fields, alg: "ed25519",
+            keyid: this._csig.verfer.qb64
+        })
+
+        header.forEach((value, key) => {
+            headers.append(key, value)
+        })
+
+        let markers = new Map<string, Siger|Cigar>()
+        markers.set("signify", sig)
+        let signage = new Signage(markers, false)
+        let signed = signature([signage])
+        signed.forEach((value, key) => {
+            headers.append(key, value)
+        })
+
+        return headers
+    }
+
+
+}

package/src/keri/core/cigar.ts

@@ -3,17 +3,17 @@ import {Matter, MatterArgs} from "./matter";
 
 
 export class Cigar extends Matter {
-    private _verfer: Verfer
-    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs, verfer: Verfer) {
+    private _verfer: Verfer | undefined
+    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs, verfer?: Verfer) {
         super({raw, code, qb64, qb64b, qb2});
         this._verfer = verfer
     }
 
-    get verfer(): Verfer {
+    get verfer(): Verfer | undefined {
         return this._verfer
     }
 
-    set verfer(verfer:Verfer) {
+    set verfer(verfer:Verfer|undefined) {
         this._verfer = verfer
     }
 }

package/src/keri/core/core.ts

@@ -1,16 +1,26 @@
-const util = require('./utils');
 import {TextEncoder, TextDecoder} from 'util'
 
-export const VERRAWSIZE = 6;
-export const Versionage = {major: 1, minor: 0};
-export const Serialage = {json: '', mgpk: '', cbor: ''};
-export const Vstrings = Serialage;
-export const Serials = {json: 'JSON', mgpk: 'MGPK', cbor: 'CBOR'};
+export enum Serials {
+    JSON = "JSON",
+}
+
+export enum Ident {
+    KERI = "KERI"
+}
+
+export class Version {
+    public major: number
+    public minor: number
+
+    constructor(major: number = 1, minor: number = 0) {
+        this.major = major
+        this.minor = minor
+    }
+}
+
+export const Versionage = new Version()
+
 
-// # element labels to exclude in digest or signature derivation from inception icp
-export const IcpExcludes = ['pre'];
-// # element labels to exclude in digest or signature derivation from delegated inception dip
-export const DipExcludes = ['pre'];
 export const Ilks = {
     icp: 'icp',
     rot: 'rot',
@@ -45,47 +55,27 @@ export const VERFULLSIZE = 17;
 export const MINSNIFFSIZE = 12 + VERFULLSIZE;
 export const MINSIGSIZE = 4;
 
-/**
- * @description  It will return version string
- */
-export function versify(version: { major: number, minor: number }, kind = Serials.json, size: number) {
-    if (!(Object.values(Serials).indexOf(kind) > -1)) {
-        throw new Error('Invalid serialization kind =' + kind);
-    }
-
-    if (!version) {
-        version = Versionage;
-    }
-
-    const hex1 = version.major.toString(16);
-    const hex2 = version.minor.toString(16);
-    const kindHex = kind;
-    const hex3 = util.pad(size.toString(16), VERRAWSIZE);
-
-    return `KERI${hex1}${hex2}${kindHex}${hex3}_`;
-}
-
-Vstrings.json = versify(Versionage, Serials.json, 0);
-Vstrings.mgpk = versify(Versionage, Serials.mgpk, 0);
-Vstrings.cbor = versify(Versionage, Serials.cbor, 0);
-
 // const version_pattern = 'KERI(?P<major>[0-9a-f])(?P<minor>[0-9a-f])
 // (?P<kind>[A-Z]{4})(?P<size>[0-9a-f]{6})'
 // const version_pattern1 = `KERI\(\?P<major>\[0\-9a\-f\]\)\(\?P<minor>\[0\-9a\-f\]\)\
 // (\?P<kind>\[A\-Z\]\{4\}\)\(\?P<size>\[0\-9a\-f\]\{6\}\)_`
 
-export const VEREX = 'KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})';
+export const VEREX = 'KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_';
+
+export interface Dict<TValue> {
+    [id: string]: TValue;
+}
 
 // Regex pattern matching
 
 /**
  * @description This function is use to deversify the version
  * Here we will use regex to  to validate and extract serialization kind,size and version
- * @param {string} vs   version string
+ * @param {string} versionString   version string
  * @return {Object}  contaning kind of serialization like cbor,json,mgpk
  *                    version = version of object ,size = raw size integer
  */
-export function deversify(versionString: string) {
+export function deversify(versionString: string): [Serials, Version, string] {
     let kind;
     let size;
     const version = Versionage;
@@ -102,14 +92,25 @@ export function deversify(versionString: string) {
             match[3],
             match[4],
         ];
-        if (!Object.values(Serials).includes(kind)) {
+        if (!Object.values(Serials).includes(kind as Serials)) {
             throw new Error(`Invalid serialization kind = ${kind}`);
         }
+
+        let ta = kind as keyof typeof Serials
+        kind = Serials[ta]
+
         return [kind, version, size];
     }
     throw new Error(`Invalid version string = ${versionString}`);
 }
 
+export function versify(ident: Ident = Ident.KERI, version?: Version, kind: Serials=Serials.JSON, size:number = 0) {
+    version = version == undefined ? Versionage : version
+
+    return  `${ident}${version.major.toString(16)}${version.minor.toString()}${kind}${size.toString(16).padStart(6, '0')}_`
+}
+
+
 export const B64ChrByIdx = new Map<number, string>([[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D'], [4, 'E'], [5, 'F'],
     [6, 'G'], [7, 'H'], [8, 'I'], [9, 'J'], [10, 'K'], [11, 'L'], [12, 'M'], [13, 'N'], [14, 'O'], [15, 'P'],
     [16, 'Q'], [17, 'R'], [18, 'S'], [19, 'T'], [20, 'U'], [21, 'V'], [22, 'W'], [23, 'X'], [24, 'Y'], [25, 'Z'],
@@ -120,17 +121,19 @@ export const B64ChrByIdx = new Map<number, string>([[0, 'A'], [1, 'B'], [2, 'C']
 
 export const B64IdxByChr = new Map<string, number>(Array.from(B64ChrByIdx, entry => [entry[1], entry[0]]))
 
-export function intToB64(i:number | undefined, l=1): string {
+
+export function intToB64(i:number, l=1): string {
     let out = ""
     while(l != 0) {
-        out = B64ChrByIdx.get(i! % 64) + out
-        i = Math.floor(i! / 64)
+        out = B64ChrByIdx.get(i % 64) + out
+        i = Math.floor(i / 64)
         if (i == 0) {
             break
         }
     }
 
-    for(let i = 0; i < (l - out.length); i++) {
+    let x = (l - out.length)
+    for(let i = 0; i < x; i++) {
         out = "A" + out
     }
 
@@ -164,6 +167,13 @@ export function d(u? :Uint8Array): string {
     return decoder.decode(u)
 }
 
+export function concat(one: Uint8Array, two: Uint8Array): Uint8Array {
+    let out = new Uint8Array(one.length + two.length)
+    out.set(one)
+    out.set(two, one.length)
+    return out
+}
+
 
 export function readInt(array: Uint8Array) {
     let value = 0;
@@ -171,4 +181,4 @@ export function readInt(array: Uint8Array) {
         value = (value * 256) + array[i];
     }
     return value;
-}
+}