saro-dat 0.0.0 → 0.0.1

package/README.md

@@ -1,24 +1,86 @@
+# DAT - Distributed Access Token
+
+# NPM
+```
+saro-dat
+```
+
 # DAT
-- Distributed Access Token
+```
+# Example
+signature_algorithm: P256
+crypto_algorithm: AES128GCMN
+plain: 123
+secure: asdf
+
+# DAT result Example
+1776530737.11.MTIz.8yKUvzs7mg3tDwdeA9I2gNOliewpTgm9OVbEY3Qh6io.qfnqmXKuNE3MfRr576rxNMCchxbY1iqC07-woJcbCudt2O0BAyK_86ypaSfLJjkGq9FZxpGrsgBDkk-xQhGvmA
+```
 
-## Package
-- https://www.npmjs.com/package/saro-dat
+> ```expire```.```kid```.```plain```.```secure```.```sign```
 
+- ```expire```: number
+    - Unix-Timestamp (sec)
+- ```kid```: stringifiable
+    - key id
+- ```plain```: base64 url no pad
+    - Text Data
+- ```secure```: base64 url no pad
+    - Encrypted Text Data
+- ```sign```: base64 url no pad
+    - dat-bank\[kid\].sign(expire.kid.plain.secure)
+
+# DAT KEY
 ```
-"saro-dat": "not-yet"
+# Example
+1.2.P256.DErFl-U5h4fdbnAXTTs2GikkJgZwYXV25v2EdFeXIXs.AES128GCMN.5VEziIzCu2LRsK1XS6OYxA.1776541326.1776544626.1800
 ```
+> ```version```.```kid```.```signature-algorithm```.```signature-key```.```crypto-algorithm```.```crypto-key```.```issue-begin```.```issue-end```.```token-ttl```
+
+- ```version```: number
+    - dat-key format version
+- ```kid```: stringifiable
+    - key id
+- ```signature-algorithm```: text
+    - sign algorithm
+- ```signature-key```: base64 url no pad
+  > The signature-key is categorized into three types: FULL (signing-key~verifying-key), SIGNING (signing-key), and VERIFYING (~verifying-key).
+  >
+  > Whether a key is for sign or verify can be distinguished by the presence of a leading tilde (~). Generally, if you output the sign key alone, the public key can be derived from it (using the private key). However, depending on the platform, this derivation feature may not be available; in such cases, you should output the full key and parse it for use.
+    - FULL: \<signing key base64\>~\<verifying key base64\>
+    - SIGNING: \<signing key base64\>
+    - VERIFYING: ~\<verifying key base64\>
+- ```crypto-algorithm```: text
+    - crypto algorithm,
+- ```crypto-key```: base64 url no pad
+    - crypto key
+- ```issue-begin```: number
+    - issue begin time
+- ```issue-end```: number
+    - issue end time
+- ```token-ttl```: number
+    - token(dat) TTL
+
+
+## support signature algorithm
+| name   | algorithm  |
+|--------|------------|
+| P256   | secp256r1  |
+| P384   | secp384r1  |
+| P521   | secp521r1  |
+
+## support crypto algorithm
+| name       | algorithm                   |
+|------------|-----------------------------|
+| AES128GCMN | aes-128-gcm n(nonce + body) |
+| AES256GCMN | aes-256-cbc n(nonce + body) |
+
 
-## Document
-- Class
-  - Date Format
-  - Locate
-  - SingleLock
-  - [Scroll Loader](./document/scroll-loader.md)
-- Instance
-  - cookies
-  - ko
+### See Also
+- Libraries
+    - [Rust](https://github.com/saro-lab/dat-rust)
+    - [Java, Kotlin](https://github.com/saro-lab/dat-maven)
+- DatKey Generate Service
+    - [DAT Bank: Binary Docker, Kubernetes](https://github.com/saro-lab/dat-bank)
 
 
-## Project Info
-- typescript
-- yarn 3.x

package/dist/crypto.d.ts

@@ -0,0 +1,12 @@
+export type DatCryptoAlgorithm = "AES128GCMN" | "AES256GCMN";
+export declare class DatCryptoKey {
+    private readonly config;
+    readonly algorithm: DatCryptoAlgorithm;
+    readonly key: CryptoKey;
+    constructor(algorithm: DatCryptoAlgorithm, key: CryptoKey);
+    static generate(algorithm: DatCryptoAlgorithm): Promise<DatCryptoKey>;
+    static import(algorithmString: string, base64: string): Promise<DatCryptoKey>;
+    export(): Promise<string>;
+    encrypt(data: string | ArrayBuffer | Uint8Array | Buffer | null | undefined): Promise<ArrayBuffer>;
+    decrypt(data: ArrayBuffer | null | undefined): Promise<ArrayBuffer>;
+}

package/dist/crypto.js

@@ -0,0 +1,66 @@
+// @ts-ignore
+import { concatArrayBufferLike, decodeBase64, encodeBase64Url, toArrayBuffer } from "./index.ts";
+const allAlgorithms = ["AES128GCMN", "AES256GCMN"];
+const CRYPTO_CONFIG = {
+    AES128GCMN: { name: "AES-GCM", length: 128 },
+    AES256GCMN: { name: "AES-GCM", length: 256 },
+};
+export class DatCryptoKey {
+    config;
+    algorithm;
+    key;
+    constructor(algorithm, key) {
+        this.algorithm = algorithm;
+        this.key = key;
+        this.config = CRYPTO_CONFIG[algorithm];
+    }
+    static async generate(algorithm) {
+        const config = CRYPTO_CONFIG[algorithm];
+        if (!config)
+            throw new Error(`Unsupported algorithm: ${algorithm}`);
+        const key = await crypto.subtle.generateKey({ name: config.name, length: config.length }, true, ["encrypt", "decrypt"]);
+        return new DatCryptoKey(algorithm, key);
+    }
+    static async import(algorithmString, base64) {
+        if (!allAlgorithms.includes(algorithmString)) {
+            throw new Error(`Unsupported algorithm: ${algorithmString}`);
+        }
+        const algorithm = algorithmString;
+        const config = CRYPTO_CONFIG[algorithm];
+        if (!config)
+            throw new Error(`Unsupported algorithm: ${algorithm}`);
+        const bytes = new Uint8Array(decodeBase64(base64));
+        const key = await crypto.subtle.importKey("raw", bytes, { name: config.name }, true, ["encrypt", "decrypt"]);
+        return new DatCryptoKey(algorithm, key);
+    }
+    async export() {
+        return encodeBase64Url(await crypto.subtle.exportKey("raw", this.key));
+    }
+    async encrypt(data) {
+        const bytes = toArrayBuffer(data);
+        if (!bytes) {
+            return new ArrayBuffer(0);
+        }
+        if (this.config.name == "AES-GCM") {
+            const nonce = new Uint8Array(12);
+            crypto.getRandomValues(nonce);
+            const encrypt = await crypto.subtle.encrypt({ name: this.config.name, iv: nonce }, this.key, bytes);
+            return concatArrayBufferLike(nonce.buffer, encrypt);
+        }
+        throw new Error("Unsupported algorithm");
+    }
+    async decrypt(data) {
+        const bytes = toArrayBuffer(data);
+        if (!bytes) {
+            return new ArrayBuffer(0);
+        }
+        if (this.config.name == "AES-GCM") {
+            if (bytes.byteLength <= 12) {
+                throw new Error("Invalid data length");
+            }
+            const nonce = bytes.slice(0, 12);
+            return await crypto.subtle.decrypt({ name: this.config.name, iv: nonce }, this.key, bytes.slice(12));
+        }
+        throw new Error("Unsupported algorithm");
+    }
+}

package/dist/dat.bank.d.ts

@@ -0,0 +1,12 @@
+import { DatKey } from "./index.ts";
+import type { DatSignatureKeyOutOption } from "./index.ts";
+export declare class DatBank {
+    private issueKey;
+    private verifyKeys;
+    constructor(issueKey?: DatKey | null, verifyKeys?: DatKey[]);
+    static import(format: string): Promise<DatBank>;
+    export(datSignatureKeyOutOption: DatSignatureKeyOutOption): Promise<string>;
+    findKey(kid: string): DatKey | null;
+    toDat(plain: ArrayBuffer | null | undefined, secure: ArrayBuffer | null | undefined): Promise<ArrayBuffer>;
+    toPayload(dat: string): Promise<ArrayBuffer>;
+}

package/dist/dat.bank.js

@@ -0,0 +1,50 @@
+// @ts-ignore
+import { DatKey, } from "./index.ts";
+export class DatBank {
+    issueKey;
+    verifyKeys;
+    constructor(issueKey = null, verifyKeys = []) {
+        this.issueKey = issueKey;
+        this.verifyKeys = verifyKeys;
+    }
+    static async import(format) {
+        const now = Math.floor(new Date().getTime() / 1000);
+        const lines = format.split('\n').map(e => e.trim()).filter(e => !!e);
+        let keys = [];
+        for (const line of lines) {
+            keys.push(await DatKey.import(line));
+        }
+        keys.sort((a, b) => a.issueBegin - b.issueBegin);
+        const issueKey = keys.findLast(e => e.issueBegin <= now && e.issueEnd > now) || null;
+        return new DatBank(issueKey, keys);
+    }
+    async export(datSignatureKeyOutOption) {
+        let lines = [];
+        for (const key of this.verifyKeys) {
+            lines.push(await key.export(datSignatureKeyOutOption));
+        }
+        return lines.join('\n');
+    }
+    findKey(kid) {
+        return this.verifyKeys.find(e => e.kid === kid) || null;
+    }
+    async toDat(plain, secure) {
+        if (this.issueKey) {
+            return this.issueKey.toDat(plain, secure);
+        }
+        throw new Error("issue key does not exist");
+    }
+    async toPayload(dat) {
+        if (!dat) {
+            throw new Error("dat is required");
+        }
+        const kid = dat.split('.')?.[1] || null;
+        if (kid != null) {
+            const key = this.findKey(kid);
+            if (key) {
+                return key.toPayload(dat);
+            }
+        }
+        throw new Error("invalid dat");
+    }
+}

package/dist/dat.d.ts

@@ -0,0 +1 @@
+export declare function dat(key: string): string;

package/dist/dat.js

@@ -0,0 +1,3 @@
+export function dat(key) {
+    return `dat:${key}`;
+}

package/dist/dat.key.d.ts

@@ -0,0 +1,16 @@
+import { DatCryptoKey, DatSignatureKey } from "./index.ts";
+import type { DatSignatureKeyOutOption } from "./index.ts";
+export declare class DatKey {
+    readonly kid: string;
+    readonly signatureKey: DatSignatureKey;
+    readonly cryptoKey: DatCryptoKey;
+    readonly issueBegin: number;
+    readonly issueEnd: number;
+    readonly tokenTtl: number;
+    constructor(kid: string, signatureKey: DatSignatureKey, cryptoKey: DatCryptoKey, issueBegin: number, issueEnd: number, tokenTtl: number);
+    export(datSignatureKeyOutOption: DatSignatureKeyOutOption): Promise<string>;
+    static import(format: string): Promise<DatKey>;
+    private static _import_ver_2;
+    toDat(plain: ArrayBuffer | null | undefined, secure: ArrayBuffer | null | undefined): Promise<ArrayBuffer>;
+    toPayload(dat: string): Promise<ArrayBuffer>;
+}

package/dist/dat.key.js

@@ -0,0 +1,68 @@
+// @ts-ignore
+import { DAT_VERSION, DatCryptoKey, DatSignatureKey, toArrayBuffer, } from "./index.ts";
+export class DatKey {
+    kid;
+    signatureKey;
+    cryptoKey;
+    issueBegin;
+    issueEnd;
+    tokenTtl;
+    constructor(kid, signatureKey, cryptoKey, issueBegin, issueEnd, tokenTtl) {
+        if (kid.match(/[.\r\n]/) != null) {
+            throw new Error(`Invalid kid: ${kid}`);
+        }
+        if (isNaN(issueBegin) || isNaN(issueEnd) || isNaN(tokenTtl)) {
+            throw new Error(`Invalid issueBegin, issueEnd, tokenTtl: ${issueBegin}, ${issueEnd}, ${tokenTtl}`);
+        }
+        this.kid = kid;
+        this.signatureKey = signatureKey;
+        this.cryptoKey = cryptoKey;
+        this.issueBegin = Math.floor(issueBegin);
+        this.issueEnd = Math.floor(issueEnd);
+        this.tokenTtl = Math.floor(tokenTtl);
+    }
+    async export(datSignatureKeyOutOption) {
+        const kid = this.kid;
+        const signAlg = this.signatureKey.algorithm;
+        const signKey = await this.signatureKey.export(datSignatureKeyOutOption);
+        const cryptoAlg = this.cryptoKey.algorithm;
+        const cryptoKey = await this.cryptoKey.export();
+        const issueBegin = this.issueBegin;
+        const issueEnd = this.issueEnd;
+        const tokenTtl = this.tokenTtl;
+        return `${DAT_VERSION}.${kid}.${signAlg}.${signKey}.${cryptoAlg}.${cryptoKey}.${issueBegin}.${issueEnd}.${tokenTtl}`;
+    }
+    static async import(format) {
+        const split = format.split(".");
+        switch (split[0] || '0') {
+            case '2':
+            case '1':
+                if (split.length == 9) {
+                    return await DatKey._import_ver_2(split);
+                }
+        }
+        throw new Error("Invalid format");
+    }
+    static async _import_ver_2(split) {
+        const kid = split[1];
+        const signKey = await DatSignatureKey.import(split[2], split[3]);
+        const cryptoKey = await DatCryptoKey.import(split[4], split[5]);
+        const issueBegin = Number(split[6]);
+        const issueEnd = Number(split[7]);
+        const tokenTtl = Number(split[8]);
+        return new DatKey(kid, signKey, cryptoKey, issueBegin, issueEnd, tokenTtl);
+    }
+    async toDat(plain, secure) {
+        const bytes = toArrayBuffer(plain);
+        if (!bytes) {
+            return new ArrayBuffer(0);
+        }
+        throw new Error("Unsupported algorithm");
+    }
+    async toPayload(dat) {
+        if (!dat) {
+            throw new Error("dat is required");
+        }
+        throw new Error("Unsupported algorithm");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export declare const DAT_VERSION = "2";
+export * from './crypto.ts';
+export * from './dat.key.ts';
+export * from './dat.bank.ts';
+export * from './signature.ts';
+export * from './util.ts';

package/dist/index.js

@@ -0,0 +1,11 @@
+export const DAT_VERSION = '2';
+// @ts-ignore
+export * from './crypto.ts';
+// @ts-ignore
+export * from './dat.key.ts';
+// @ts-ignore
+export * from './dat.bank.ts';
+// @ts-ignore
+export * from './signature.ts';
+// @ts-ignore
+export * from './util.ts';

package/dist/signature.d.ts

@@ -0,0 +1,14 @@
+export type DatSignatureAlgorithm = "P256" | "P384" | "P521";
+export type DatSignatureKeyOutOption = "FULL" | "SIGNING" | "VERIFYING";
+export declare class DatSignatureKey {
+    private readonly config;
+    readonly algorithm: DatSignatureAlgorithm;
+    readonly signingKey: CryptoKey | null;
+    readonly verifyingKey: CryptoKey;
+    constructor(algorithm: DatSignatureAlgorithm, SigningKey: CryptoKey | null, VerifyingKey: CryptoKey);
+    static generate(algorithm: DatSignatureAlgorithm): Promise<DatSignatureKey>;
+    static import(algorithmString: string, format: string): Promise<DatSignatureKey>;
+    export(option: DatSignatureKeyOutOption): Promise<string>;
+    sign(data: ArrayBuffer | null | undefined): Promise<ArrayBuffer>;
+    verify(data: ArrayBuffer | null | undefined, signature: ArrayBuffer | null | undefined): Promise<boolean>;
+}

package/dist/signature.js

@@ -0,0 +1,137 @@
+// @ts-ignore
+import { decodeBase64, encodeBase64Url, normalizeBase64Url } from "./index.ts";
+import { p256, p384, p521 } from '@noble/curves/nist.js';
+const allAlgorithms = ["P256", "P384", "P521"];
+const SIGNATURE_CONFIG = {
+    P256: { name: "ECDSA", curve: 'P-256', hash: 'SHA-256' },
+    P384: { name: "ECDSA", curve: 'P-384', hash: 'SHA-384' },
+    P521: { name: "ECDSA", curve: 'P-521', hash: 'SHA-512' },
+};
+export class DatSignatureKey {
+    config;
+    algorithm;
+    signingKey;
+    verifyingKey;
+    constructor(algorithm, SigningKey, VerifyingKey) {
+        this.algorithm = algorithm;
+        this.signingKey = SigningKey;
+        this.verifyingKey = VerifyingKey;
+        this.config = SIGNATURE_CONFIG[algorithm];
+    }
+    static async generate(algorithm) {
+        const config = SIGNATURE_CONFIG[algorithm];
+        if (!config)
+            throw new Error(`Unsupported algorithm: ${algorithm}`);
+        const { publicKey, privateKey } = await crypto.subtle.generateKey({ name: config.name, namedCurve: config.curve, }, true, ["sign", "verify"]);
+        return new DatSignatureKey(algorithm, privateKey, publicKey);
+    }
+    static async import(algorithmString, format) {
+        if (!allAlgorithms.includes(algorithmString)) {
+            throw new Error(`Unsupported algorithm: ${algorithmString}`);
+        }
+        const algorithm = algorithmString;
+        const config = SIGNATURE_CONFIG[algorithm];
+        if (!config)
+            throw new Error(`Unsupported algorithm: ${algorithm}`);
+        if (!format) {
+            throw new Error("Invalid format");
+        }
+        const split = format.split("~");
+        let signingKeyBase64 = '';
+        let signingKey = null;
+        let verifyingKeyBytes = null;
+        let verifyingKey = null;
+        let ecdsa;
+        switch (algorithm) {
+            case "P256":
+                ecdsa = p256;
+                break;
+            case "P384":
+                ecdsa = p384;
+                break;
+            case "P521":
+                ecdsa = p521;
+                break;
+            default:
+                throw new Error(`Unsupported algorithm: ${algorithm}`);
+        }
+        if (split.length == 1) {
+            if (split[0]) {
+                signingKeyBase64 = split[0];
+            }
+        }
+        else if (split.length == 2) {
+            if (split[0]) {
+                signingKeyBase64 = split[0];
+            }
+            if (split[1]) {
+                verifyingKeyBytes = new Uint8Array(decodeBase64(split[1]));
+            }
+        }
+        if (signingKeyBase64) {
+            const dBytes = decodeBase64(signingKeyBase64);
+            // d로부터 공개 키(Point) 계산
+            const publicPoint = ecdsa.getPublicKey(dBytes, false);
+            // 곡선별 좌표 길이 계산: (전체 길이 - 1) / 2 - 좌표 추출
+            const coordinateLen = (publicPoint.length - 1) / 2;
+            const xBytes = publicPoint.slice(1, 1 + coordinateLen);
+            const yBytes = publicPoint.slice(1 + coordinateLen, 1 + 2 * coordinateLen);
+            const jwk = {
+                kty: "EC",
+                crv: config.curve,
+                d: signingKeyBase64,
+                x: Buffer.from(xBytes).toString('base64'),
+                y: Buffer.from(yBytes).toString('base64'),
+                ext: true,
+            };
+            signingKey = await crypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: config.curve }, true, ["sign"]);
+        }
+        if (!verifyingKeyBytes && signingKeyBase64) {
+            verifyingKeyBytes = ecdsa.getPublicKey(decodeBase64(signingKeyBase64), false);
+        }
+        if (verifyingKeyBytes) {
+            verifyingKey = await crypto.subtle.importKey("raw", verifyingKeyBytes, { name: config.name, namedCurve: config.curve }, true, ["verify"]);
+        }
+        else {
+            throw new Error("Invalid format");
+        }
+        return new DatSignatureKey(algorithm, signingKey, verifyingKey);
+    }
+    async export(option) {
+        let rv = "";
+        if (option == "FULL" || option == "SIGNING") {
+            if (this.signingKey) {
+                let jwk = await crypto.subtle.exportKey("jwk", this.signingKey);
+                rv += normalizeBase64Url(jwk.d);
+            }
+            else {
+                throw new Error("this key is verifying only");
+            }
+        }
+        if (option == "FULL" || option == "VERIFYING") {
+            rv += '~' + encodeBase64Url(await crypto.subtle.exportKey("raw", this.verifyingKey));
+        }
+        return rv;
+    }
+    async sign(data) {
+        if (!this.signingKey) {
+            throw new Error("this key is verifying only");
+        }
+        if (!data) {
+            throw new Error("data is required");
+        }
+        return crypto.subtle.sign({
+            name: this.config.name,
+            hash: { name: this.config.hash },
+        }, this.signingKey, data);
+    }
+    async verify(data, signature) {
+        if (!data || !signature) {
+            return false;
+        }
+        return crypto.subtle.verify({
+            name: this.config.name,
+            hash: { name: this.config.hash },
+        }, this.verifyingKey, signature, data);
+    }
+}

package/dist/util.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeBase64Url(base64: string): string;
+export declare function encodeBase64Url(data: any): string;
+export declare function decodeBase64String(b64: string | ArrayBuffer | null | undefined): string;
+export declare function decodeBase64(b64: string | ArrayBuffer | null | undefined): Buffer;
+export declare function concatArrayBufferLike(arr1: ArrayBufferLike, arr2: ArrayBufferLike): ArrayBuffer;
+export declare function toArrayBuffer(data: string | ArrayBuffer | Uint8Array | SharedArrayBuffer | Buffer | null | undefined): ArrayBuffer;
+export declare function randomString(length: number, mold: string): string;
+export declare function randomBase62(length: number): string;

package/dist/util.js

@@ -0,0 +1,83 @@
+const asciiDecoder = new TextDecoder('ascii');
+const textEncoder = new TextEncoder();
+const base62arr = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+export function normalizeBase64Url(base64) {
+    return base64.replace(/[+\/=]/g, (ch) => {
+        switch (ch) {
+            case '+': return '-';
+            case '/': return '_';
+        }
+        return '';
+    });
+}
+export function encodeBase64Url(data) {
+    if (!data) {
+        return '';
+    }
+    if (typeof data === 'string') {
+        return normalizeBase64Url(Buffer.from(data).toString('base64'));
+    }
+    else if (data instanceof ArrayBuffer) {
+        return normalizeBase64Url(Buffer.from(data).toString('base64'));
+    }
+    else if (data instanceof Uint8Array) {
+        return normalizeBase64Url(Buffer.from(data).toString('base64'));
+    }
+    else if (data instanceof Buffer) {
+        return normalizeBase64Url(data.toString('base64'));
+    }
+    throw new Error('Unsupported data type');
+}
+export function decodeBase64String(b64) {
+    return decodeBase64(b64).toString('utf-8');
+}
+// @ts-ignore
+export function decodeBase64(b64) {
+    if (!b64) {
+        return Buffer.alloc(0);
+    }
+    if (typeof b64 === 'string') {
+        return Buffer.from(b64, 'base64');
+    }
+    if (b64 instanceof ArrayBuffer) {
+        return Buffer.from(asciiDecoder.decode(b64), 'base64');
+    }
+    throw new Error('Unsupported data type');
+}
+export function concatArrayBufferLike(arr1, arr2) {
+    const buf = new Uint8Array(arr1.byteLength + arr2.byteLength);
+    buf.set(new Uint8Array(arr1), 0);
+    buf.set(new Uint8Array(arr2), arr1.byteLength);
+    return buf.buffer;
+}
+export function toArrayBuffer(data) {
+    if (!data) {
+        return new ArrayBuffer(0);
+    }
+    if (typeof data === 'string') {
+        return textEncoder.encode(data).buffer;
+    }
+    if (Buffer.isBuffer(data)) {
+        return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (data instanceof Uint8Array) {
+        return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (data instanceof ArrayBuffer) {
+        return data;
+    }
+    if (data instanceof SharedArrayBuffer) {
+        const buffer = new Uint8Array(data.byteLength);
+        buffer.set(new Uint8Array(data));
+        return buffer.buffer;
+    }
+    throw new Error('Unsupported data type');
+}
+export function randomString(length, mold) {
+    return [...Array(length)]
+        .map(() => mold[Math.floor(Math.random() * mold.length)])
+        .join('');
+}
+export function randomBase62(length) {
+    return randomString(length, base62arr);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saro-dat",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Distributed Access Token",
   "keywords": [
     "dat",
@@ -18,13 +18,21 @@
   },
   "license": "MIT",
   "author": "marker",
-  "type": "commonjs",
-  "main": "index.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
   "scripts": {
     "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "--test": "node --test dist/**/*.test.js",
+    "pretest": "npm run build"
   },
   "devDependencies": {
+    "@types/node": "^25.6.0",
     "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@noble/curves": "^2.2.0"
   }
 }

package/.editorconfig

@@ -1,10 +0,0 @@
-root = true
-
-[*]
-end_of_line = lf
-insert_final_newline = true
-
-[*.{js,json,yml}]
-charset = utf-8
-indent_style = space
-indent_size = 2

package/PUBLISH.md

@@ -1,22 +0,0 @@
-# build & publish
-
-## build
-``` shell
-npm install
-```
-
-``` shell
-npm run build
-```
-
-## login
-``` shell
-npm login
-```
-
-## publish
-1. build
-2. update next version in README.md and commit
-``` shell
-npm publish
-```

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES6",
-    "allowJs": true,
-    "declaration": true,
-    "strict": true,
-    "outDir": "dist",
-    "rootDir": "src",
-  },
-  "include": ["src/**/*"]
-}