@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/account/neutral/index.mjs

@@ -0,0 +1,547 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/register.ts
+import { addressTo20Bytes, registerVerifier } from "../../account-model/neutral/index.mjs";
+import { Elliptic } from "../../elliptic/neutral/index.mjs";
+registerVerifier("secp256k1", async (address, hash, signature) => {
+  await Elliptic.initialize();
+  return await Elliptic.verify(hash, signature, addressTo20Bytes(address));
+});
+
+// src/Account.ts
+import {
+  asAddress,
+  asHash,
+  assertEx as assertEx3,
+  globallyUnique,
+  isDefined as isDefined2,
+  isHash,
+  isString,
+  staticImplements as staticImplements4,
+  toArrayBuffer as toArrayBuffer3,
+  toHex as toHex3,
+  toUint8Array as toUint8Array3
+} from "@xylabs/sdk";
+import {
+  isMnemonicInitializationConfig,
+  isPhraseInitializationConfig,
+  isPrivateKeyInitializationConfig
+} from "../../account-model/neutral/index.mjs";
+import { Elliptic as Elliptic5 } from "../../elliptic/neutral/index.mjs";
+import { Mutex } from "async-mutex";
+import {
+  HDNodeWallet,
+  Mnemonic,
+  randomBytes
+} from "ethers";
+
+// src/Jwt/createJwt.ts
+import { toHex } from "@xylabs/sdk";
+import {
+  JwtAlg,
+  JwtSchema,
+  JwtTyp
+} from "../../account-model/neutral/index.mjs";
+
+// src/Jwt/base64url.ts
+import { base64urlnopad } from "@scure/base";
+function base64urlEncode(bytes) {
+  return base64urlnopad.encode(bytes);
+}
+function base64urlDecode(value) {
+  return base64urlnopad.decode(value);
+}
+function base64urlEncodeJson(value) {
+  const encoder = new TextEncoder();
+  return base64urlEncode(encoder.encode(JSON.stringify(value)));
+}
+function base64urlDecodeJson(value) {
+  const decoder = new TextDecoder();
+  return JSON.parse(decoder.decode(base64urlDecode(value)));
+}
+
+// src/Jwt/digest.ts
+import { toUint8Array } from "@xylabs/sdk";
+import { sha256 } from "ethers";
+function sha256Bytes(input) {
+  return toUint8Array(sha256(input));
+}
+function stripHexPrefix(value) {
+  return value.startsWith("0x") ? value.slice(2) : value;
+}
+function normalizeAddress(value) {
+  return stripHexPrefix(value).toLowerCase();
+}
+
+// src/Jwt/createJwt.ts
+function publicKeyHex(account) {
+  const publicKey = account.public;
+  if (!publicKey) throw new Error("Account is missing public key");
+  return toHex(publicKey.bytes, { prefix: false });
+}
+async function createJwt(account, options) {
+  if (!options.audience || options.audience.length === 0) {
+    throw new Error("audience is required");
+  }
+  if (options.ttl !== void 0 && options.exp !== void 0) {
+    throw new Error("Specify only one of ttl or exp");
+  }
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  const ttl = options.ttl ?? 3600;
+  const exp = options.exp ?? now + ttl;
+  if (exp <= now) throw new Error(`exp (${exp}) must be greater than now (${now})`);
+  const merged = { ...options.claims };
+  const schemaValue = options.schema ?? (typeof merged.schema === "string" ? merged.schema : JwtSchema.Signin);
+  delete merged.schema;
+  const iss = normalizeAddress(String(account.address));
+  const payload = {
+    ...merged,
+    schema: schemaValue,
+    iss,
+    aud: options.audience,
+    iat: now,
+    exp
+  };
+  const header = {
+    alg: JwtAlg.ES256K,
+    typ: JwtTyp.JWT,
+    kid: iss,
+    pub: publicKeyHex(account)
+  };
+  const headerB64 = base64urlEncodeJson(header);
+  const payloadB64 = base64urlEncodeJson(payload);
+  const encoder = new TextEncoder();
+  const signingInput = encoder.encode(`${headerB64}.${payloadB64}`);
+  const digest = sha256Bytes(signingInput);
+  const digestBuffer = digest.buffer.slice(digest.byteOffset, digest.byteOffset + digest.byteLength);
+  const [sigBuffer] = await account.sign(digestBuffer);
+  const signature = new Uint8Array(sigBuffer);
+  const signatureB64 = base64urlEncode(signature);
+  const token = `${headerB64}.${payloadB64}.${signatureB64}`;
+  return {
+    token,
+    header,
+    payload
+  };
+}
+
+// src/Jwt/decodeJwt.ts
+function decodeJwt(token) {
+  const parts = token.trim().split(".");
+  if (parts.length !== 3) {
+    throw new Error(`Malformed JWT: expected 3 segments, got ${parts.length}`);
+  }
+  const [headerB64, payloadB64, signatureB64] = parts;
+  const header = base64urlDecodeJson(headerB64);
+  const payload = base64urlDecodeJson(payloadB64);
+  const signature = base64urlDecode(signatureB64);
+  return {
+    header,
+    payload,
+    signature,
+    headerB64,
+    payloadB64,
+    signatureB64
+  };
+}
+
+// src/Jwt/verifyJwt.ts
+import { toHex as toHex2, toUint8Array as toUint8Array2 } from "@xylabs/sdk";
+import { JwtAlg as JwtAlg2, JwtTyp as JwtTyp2 } from "../../account-model/neutral/index.mjs";
+
+// src/Key/PublicKey.ts
+import {
+  assertEx,
+  staticImplements as staticImplements2,
+  toArrayBuffer
+} from "@xylabs/sdk";
+import { Elliptic as Elliptic3 } from "../../elliptic/neutral/index.mjs";
+
+// src/Key/AddressValue.ts
+import { isDefined, staticImplements } from "@xylabs/sdk";
+import { Data as Data2 } from "../../data/neutral/index.mjs";
+import { Elliptic as Elliptic2 } from "../../elliptic/neutral/index.mjs";
+
+// src/Key/EllipticKey.ts
+import { Data } from "../../data/neutral/index.mjs";
+var EllipticKey = class extends Data {
+  // we do this to allow node to import without problem
+};
+
+// src/Key/AddressValue.ts
+var AddressValue = class extends EllipticKey {
+  _isAddress = true;
+  constructor(address) {
+    super(20, AddressValue.addressFromAddressOrPublicKey(address));
+  }
+  static addressFromAddressOrPublicKey(bytes) {
+    return bytes.byteLength === 20 ? bytes : this.addressFromPublicKey(bytes);
+  }
+  static addressFromPublicKey(key) {
+    const data = new Data2(64, key);
+    return data.keccak256.slice(12);
+  }
+  static async initialize() {
+    return isDefined(await Elliptic2.secp256k1());
+  }
+  static isAddress(value) {
+    return value._isAddress;
+  }
+};
+AddressValue = __decorateClass([
+  staticImplements()
+], AddressValue);
+
+// src/Key/PublicKey.ts
+var PublicKey = class extends EllipticKey {
+  _address;
+  _isPublicKey = true;
+  constructor(privateConstructorKey, bytes) {
+    assertEx(PublicKey.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    super(64, bytes);
+    const address = Elliptic3.addressFromPublicKey(bytes);
+    const addressValue = new AddressValue(address);
+    this._address = addressValue;
+  }
+  static async create(bytes) {
+    return await Promise.resolve(new PublicKey(this.privateConstructorKey, bytes));
+  }
+  static async fromPrivate(bytes) {
+    const publicKey = await Elliptic3.publicKeyFromPrivateKey(toArrayBuffer(bytes));
+    return new PublicKey(this.privateConstructorKey, publicKey);
+  }
+  static isPublicKey(value) {
+    return value._isPublicKey;
+  }
+  get address() {
+    return this._address;
+  }
+  async verify(msg, signature) {
+    return await Elliptic3.verify(msg, signature, this.address.bytes);
+  }
+};
+__publicField(PublicKey, "privateConstructorKey", Date.now().toString());
+PublicKey = __decorateClass([
+  staticImplements2()
+], PublicKey);
+
+// src/Jwt/verifyJwt.ts
+function checkHeader(header, reasons) {
+  if (header.alg !== JwtAlg2.ES256K) reasons.push(`unsupported alg: ${header.alg}`);
+  if (header.typ !== JwtTyp2.JWT) reasons.push(`unsupported typ: ${header.typ}`);
+  if (typeof header.pub !== "string" || header.pub.length === 0) reasons.push("header.pub missing");
+  if (typeof header.kid !== "string" || header.kid.length === 0) reasons.push("header.kid missing");
+}
+function checkPayloadShape(payload, reasons) {
+  if (typeof payload.schema !== "string" || payload.schema.length === 0) reasons.push("payload.schema missing");
+  if (typeof payload.iss !== "string") reasons.push("payload.iss missing");
+  if (typeof payload.aud !== "string") reasons.push("payload.aud missing");
+  if (typeof payload.iat !== "number") reasons.push("payload.iat missing");
+  if (typeof payload.exp !== "number") reasons.push("payload.exp missing");
+}
+function checkClaims(payload, options, reasons) {
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  if (payload.exp <= now) reasons.push(`expired: exp=${payload.exp} now=${now}`);
+  if (typeof payload.nbf === "number" && payload.nbf > now) reasons.push(`not yet valid: nbf=${payload.nbf} now=${now}`);
+  if (options.audience !== void 0 && payload.aud !== options.audience) {
+    reasons.push(`audience mismatch: expected ${options.audience}, got ${payload.aud}`);
+  }
+}
+async function checkSignature(header, signature, signingInputB64, reasons) {
+  let publicKey;
+  try {
+    const pubBytes = toUint8Array2(header.pub);
+    publicKey = await PublicKey.create(pubBytes.buffer.slice(pubBytes.byteOffset, pubBytes.byteOffset + pubBytes.byteLength));
+  } catch (error) {
+    reasons.push(`invalid public key: ${error.message}`);
+    return;
+  }
+  const derivedAddress = normalizeAddress(toHex2(publicKey.address.bytes, { prefix: false }));
+  const expectedAddress = normalizeAddress(header.kid);
+  if (derivedAddress !== expectedAddress) {
+    reasons.push(`public key does not derive to kid: derived=${derivedAddress} kid=${expectedAddress}`);
+  }
+  const encoder = new TextEncoder();
+  const signingInput = encoder.encode(signingInputB64);
+  const digest = sha256Bytes(signingInput);
+  const digestBuffer = digest.buffer.slice(digest.byteOffset, digest.byteOffset + digest.byteLength);
+  const sigBuffer = signature.buffer.slice(signature.byteOffset, signature.byteOffset + signature.byteLength);
+  const valid = await publicKey.verify(digestBuffer, sigBuffer);
+  if (!valid) reasons.push("signature verification failed");
+}
+async function verifyJwt(token, options = {}) {
+  const reasons = [];
+  const parts = decodeJwt(token);
+  const {
+    header,
+    payload,
+    signature,
+    headerB64,
+    payloadB64
+  } = parts;
+  checkHeader(header, reasons);
+  checkPayloadShape(payload, reasons);
+  if (reasons.length > 0) {
+    return {
+      ok: false,
+      reasons,
+      header,
+      payload
+    };
+  }
+  checkClaims(payload, options, reasons);
+  if (normalizeAddress(header.kid) !== normalizeAddress(payload.iss)) {
+    reasons.push("header.kid does not match payload.iss");
+  }
+  await checkSignature(header, signature, `${headerB64}.${payloadB64}`, reasons);
+  if (reasons.length > 0) {
+    return {
+      ok: false,
+      reasons,
+      header,
+      payload
+    };
+  }
+  return {
+    ok: true,
+    header,
+    payload
+  };
+}
+
+// src/Key/PrivateKey.ts
+import {
+  assertEx as assertEx2,
+  staticImplements as staticImplements3,
+  toArrayBuffer as toArrayBuffer2
+} from "@xylabs/sdk";
+import { Elliptic as Elliptic4 } from "../../elliptic/neutral/index.mjs";
+var PrivateKey = class extends EllipticKey {
+  _isPrivateKey = true;
+  _public;
+  constructor(privateConstructorKey, value, publicKey) {
+    assertEx2(PrivateKey.privateConstructorKey === privateConstructorKey, () => "Use create function instead of constructor");
+    super(32, value);
+    this._public = publicKey;
+  }
+  static async create(value) {
+    return new PrivateKey(this.privateConstructorKey, toArrayBuffer2(value), await PublicKey.fromPrivate(value));
+  }
+  static isPrivateKey(value) {
+    return value._isPrivateKey;
+  }
+  get public() {
+    return this._public;
+  }
+  async sign(hash) {
+    return await Elliptic4.sign(hash, this.bytes);
+  }
+  async verify(msg, signature) {
+    return await Elliptic4.verify(msg, signature, this.public.address.bytes);
+  }
+};
+__publicField(PrivateKey, "privateConstructorKey", Date.now().toString());
+PrivateKey = __decorateClass([
+  staticImplements3()
+], PrivateKey);
+
+// src/Account.ts
+function getPrivateKeyFromMnemonic(mnemonic, path) {
+  const node = HDNodeWallet.fromMnemonic(mnemonic);
+  const wallet = isString(path) ? node.derivePath?.(path) : node;
+  return wallet.privateKey.padStart(64, "0").toLowerCase();
+}
+function getPrivateKeyFromPhrase(phrase, path) {
+  const node = HDNodeWallet.fromMnemonic(Mnemonic.fromPhrase(phrase));
+  const wallet = isString(path) ? node.derivePath?.(path) : node;
+  return wallet.privateKey.padStart(64, "0").toLowerCase();
+}
+var Account = class extends EllipticKey {
+  _privateKey;
+  _signingMutex = new Mutex();
+  _node = void 0;
+  _previousHash;
+  algorithm = "secp256k1";
+  constructor(key, privateKey, node) {
+    assertEx3(key === Account._protectedConstructorKey, () => "Do not call this protected constructor");
+    super(32, privateKey.bytes);
+    this._privateKey = privateKey;
+    this._node = node;
+  }
+  static async create(opts) {
+    let privateKeyToUse;
+    let node;
+    if (opts) {
+      if (isPhraseInitializationConfig(opts)) {
+        privateKeyToUse = toUint8Array3(getPrivateKeyFromPhrase(opts.phrase));
+      } else if (isPrivateKeyInitializationConfig(opts)) {
+        privateKeyToUse = toUint8Array3(opts.privateKey);
+      } else if (isMnemonicInitializationConfig(opts)) {
+        privateKeyToUse = toUint8Array3(getPrivateKeyFromMnemonic(Mnemonic.fromPhrase(opts.mnemonic), opts?.path));
+        node = isString(opts?.path) ? HDNodeWallet.fromPhrase(opts.mnemonic).derivePath?.(opts.path) : HDNodeWallet.fromPhrase(opts.mnemonic);
+      }
+    }
+    privateKeyToUse = privateKeyToUse ?? randomBytes(32);
+    const privateKey = await PrivateKey.create(privateKeyToUse.buffer);
+    const account = new Account(this._protectedConstructorKey, privateKey, node);
+    const loaded = await account.loadPreviousHash(opts?.previousHash);
+    return loaded.verifyUniqueAddress();
+  }
+  static decodeJwt(token) {
+    return decodeJwt(token);
+  }
+  static async fromPrivateKey(key) {
+    const privateKey = toUint8Array3(key, 32)?.buffer;
+    return await this.create({ privateKey });
+  }
+  static isAddress(address) {
+    return address.length === 40;
+  }
+  static async random() {
+    return await this.create();
+  }
+  static async verifyJwt(token, options) {
+    return await verifyJwt(token, options);
+  }
+  get address() {
+    return asAddress(this.public.address.hex, true);
+  }
+  get addressBytes() {
+    return this.public.address.bytes;
+  }
+  get previousHash() {
+    return this.previousHashBytes ? toHex3(this.previousHashBytes, { prefix: false }).toLowerCase() : void 0;
+  }
+  get previousHashBytes() {
+    return this._previousHash;
+  }
+  get private() {
+    return this._privateKey;
+  }
+  get public() {
+    return this.private.public;
+  }
+  async initialize() {
+    return await Promise.resolve(this);
+  }
+  async loadPreviousHash(previousHash) {
+    return await this._signingMutex.runExclusive(async () => {
+      if (isDefined2(previousHash)) {
+        this._previousHash = toUint8Array3(previousHash, 32).buffer;
+      } else {
+        const previousHashStoreValue = await Account.previousHashStore?.getItem(this.address);
+        if (isHash(previousHashStoreValue)) {
+          this._previousHash = toUint8Array3(previousHashStoreValue, 32).buffer;
+        }
+      }
+      return this;
+    });
+  }
+  async sign(hash, previousHash) {
+    await Elliptic5.initialize();
+    return await this._signingMutex.runExclusive(async () => {
+      if (Account.previousHashStore) {
+        const storedPreviousHash = await Account.previousHashStore.getItem(this.address);
+        this._previousHash = isHash(storedPreviousHash) ? toArrayBuffer3(storedPreviousHash, 32) : void 0;
+      }
+      const currentPreviousHash = this.previousHash;
+      const passedCurrentHash = previousHash === void 0 ? this.previousHash : toHex3(previousHash, { prefix: false });
+      assertEx3(
+        currentPreviousHash === passedCurrentHash,
+        () => `Used and current previous hashes do not match [${currentPreviousHash} !== ${passedCurrentHash}]`
+      );
+      const signature = await this.private.sign(hash);
+      const newPreviousHash = toUint8Array3(hash, 32).buffer;
+      this._previousHash = newPreviousHash;
+      if (Account.previousHashStore) {
+        await Account.previousHashStore.setItem(this.address, asHash(toHex3(newPreviousHash, { prefix: false }), true));
+      }
+      return [signature, currentPreviousHash];
+    });
+  }
+  async signJwt(options) {
+    return await createJwt(this, options);
+  }
+  async verify(msg, signature) {
+    await Elliptic5.initialize();
+    return await Elliptic5.verify(msg, signature, this.addressBytes);
+  }
+  verifyUniqueAddress() {
+    const address = this.address;
+    const currentAddressObject = Account._addressMap[address]?.deref();
+    if (currentAddressObject === void 0) {
+      Account._addressMap[address] = new WeakRef(this);
+    } else {
+      return currentAddressObject;
+    }
+    return this;
+  }
+};
+__publicField(Account, "previousHashStore");
+__publicField(Account, "uniqueName", globallyUnique("Account", Account, "xyo"));
+__publicField(Account, "_addressMap", {});
+__publicField(Account, "_protectedConstructorKey", /* @__PURE__ */ Symbol());
+Account = __decorateClass([
+  staticImplements4()
+], Account);
+
+// src/lib/walletPath/formatWalletPath.ts
+var formatWalletPath = (path) => {
+  return path.trimStart().trimEnd().split("/").filter((p) => !!p).join("/");
+};
+
+// src/lib/walletPath/combineWalletPaths.ts
+var combineWalletPaths = (path1, path2) => {
+  const parts1 = formatWalletPath(path1).split("/");
+  const parts2 = formatWalletPath(path2).split("/");
+  return [...parts1, ...parts2].join("/");
+};
+
+// src/lib/walletPath/isValidWalletPath.ts
+import { isString as isString2 } from "@xylabs/sdk";
+var pathSegmentRegex = /^\d+'?$/;
+var isValidAbsoluteWalletPath = (path) => {
+  if (!isString2(path)) return false;
+  if (!path.startsWith("m")) return false;
+  return path === "m" ? true : isValidRelativeWalletPath(path.slice(2));
+};
+var isValidRelativeWalletPath = (path) => {
+  if (!isString2(path)) return false;
+  if (path.length === 0 || path.startsWith("m")) return false;
+  const parts = path.split("/");
+  if (parts.some((p) => !p)) return false;
+  return parts.slice(1).every((p) => pathSegmentRegex.test(p));
+};
+export {
+  Account,
+  AddressValue,
+  EllipticKey,
+  PrivateKey,
+  PublicKey,
+  base64urlDecode,
+  base64urlDecodeJson,
+  base64urlEncode,
+  base64urlEncodeJson,
+  combineWalletPaths,
+  createJwt,
+  decodeJwt,
+  formatWalletPath,
+  isValidAbsoluteWalletPath,
+  isValidRelativeWalletPath,
+  normalizeAddress,
+  sha256Bytes,
+  stripHexPrefix,
+  verifyJwt
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/account/neutral/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './walletPath/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/account/neutral/lib/walletPath/combineWalletPaths.d.ts

@@ -0,0 +1,2 @@
+export declare const combineWalletPaths: (path1: string, path2: string) => string;
+//# sourceMappingURL=combineWalletPaths.d.ts.map

package/dist/_pkg/account/neutral/lib/walletPath/formatWalletPath.d.ts

@@ -0,0 +1,2 @@
+export declare const formatWalletPath: (path: string) => string;
+//# sourceMappingURL=formatWalletPath.d.ts.map

package/dist/_pkg/account/neutral/lib/walletPath/index.d.ts

@@ -0,0 +1,4 @@
+export * from './combineWalletPaths.ts';
+export * from './formatWalletPath.ts';
+export * from './isValidWalletPath.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/account/neutral/lib/walletPath/isValidWalletPath.d.ts

@@ -0,0 +1,3 @@
+export declare const isValidAbsoluteWalletPath: (path?: string) => boolean;
+export declare const isValidRelativeWalletPath: (path?: string) => boolean;
+//# sourceMappingURL=isValidWalletPath.d.ts.map

package/dist/_pkg/account/neutral/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/_pkg/account-model/neutral/Account.d.ts

@@ -0,0 +1,46 @@
+import type { Hash } from '@xylabs/sdk';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PrivateKeyInstance, PublicKeyInstance } from '../../key-model/neutral/index.ts';
+import type { PreviousHashStore } from '../../previous-hash-store-model/neutral/index.ts';
+import type { AccountAlgorithm } from './Algorithm.ts';
+import type { SignJwtOptions, SignJwtResult } from './Jwt/types.ts';
+export declare const ethMessagePrefix = "\u0019Ethereum Signed Message:\n";
+export interface PhraseInitializationConfig {
+    phrase: string;
+}
+export interface PrivateKeyInitializationConfig {
+    privateKey: ArrayBufferLike;
+}
+export interface MnemonicInitializationConfig {
+    mnemonic: string;
+    path?: string;
+}
+export interface AccountOptions {
+    previousHash?: ArrayBufferLike;
+}
+export type InitializationConfig = PhraseInitializationConfig | PrivateKeyInitializationConfig | MnemonicInitializationConfig;
+export type AccountConfig = InitializationConfig & AccountOptions;
+export declare const isPhraseInitializationConfig: (value: unknown) => value is PhraseInitializationConfig;
+export declare const isPrivateKeyInitializationConfig: (value: unknown) => value is PrivateKeyInitializationConfig;
+export declare const isMnemonicInitializationConfig: (value: unknown) => value is MnemonicInitializationConfig;
+export declare const isInitializationConfig: (value: unknown) => value is InitializationConfig;
+export interface AccountInstance {
+    readonly address: XyoAddress;
+    readonly addressBytes: ArrayBufferLike;
+    readonly algorithm: AccountAlgorithm;
+    previousHash: Hash | undefined;
+    previousHashBytes: ArrayBufferLike | undefined;
+    readonly private?: PrivateKeyInstance;
+    readonly public?: PublicKeyInstance;
+    sign: (hash: ArrayBufferLike, previousHash?: ArrayBufferLike) => Promise<[ArrayBufferLike, Hash?]>;
+    signJwt: (options: SignJwtOptions) => Promise<SignJwtResult>;
+    verify: (msg: ArrayBufferLike, signature: ArrayBufferLike) => Promise<boolean>;
+}
+export declare const isAccountInstance: (account: unknown) => account is AccountInstance;
+export interface AccountStatic<T extends AccountInstance = AccountInstance, C extends AccountConfig = AccountConfig> {
+    previousHashStore?: PreviousHashStore;
+    create(options?: C): Promise<T>;
+    fromPrivateKey(key: ArrayBufferLike | bigint | string): Promise<AccountInstance>;
+    random(): Promise<AccountInstance>;
+}
+//# sourceMappingURL=Account.d.ts.map

package/dist/_pkg/account-model/neutral/Algorithm.d.ts

@@ -0,0 +1,5 @@
+export type AccountAlgorithm = 'secp256k1' | 'ml-dsa-65';
+export declare const AccountAlgorithmHrp: Partial<Record<AccountAlgorithm, string>>;
+export declare function hrpForAlgorithm(algorithm: AccountAlgorithm): string | undefined;
+export declare function algorithmFromAddress(address: string): AccountAlgorithm;
+//# sourceMappingURL=Algorithm.d.ts.map

package/dist/_pkg/account-model/neutral/Jwt/constants.d.ts

@@ -0,0 +1,14 @@
+import { Enum } from '@xylabs/sdk';
+export declare const JwtAlg: Enum<{
+    ES256K: "ES256K";
+}>;
+export type JwtAlg = Enum<typeof JwtAlg>;
+export declare const JwtTyp: Enum<{
+    JWT: "JWT";
+}>;
+export type JwtTyp = Enum<typeof JwtTyp>;
+export declare const JwtSchema: Enum<{
+    Signin: "network.xyo.auth.signin";
+}>;
+export type JwtSchema = Enum<typeof JwtSchema>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/_pkg/account-model/neutral/Jwt/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants.ts';
+export * from './types.ts';
+//# sourceMappingURL=index.d.ts.map