@midnight-ntwrk/wallet-sdk-address-format 3.0.0-beta.7 → 3.0.0-beta.9

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { DustPublicKey, EncryptionSecretKey, UserAddress } from '@midnight-ntwrk/ledger-v6';
+export declare const mainnet: unique symbol;
+export type NetworkId = string | typeof mainnet;
 export type FormatContext = {
-    networkId: string | null;
+    networkId: NetworkId;
 };
 export type Field = {
     bytes: number;
@@ -11,32 +13,43 @@ export declare const ScaleBigInt: {
     encode: (data: bigint) => Buffer;
     decode: (repr: Uint8Array) => bigint;
 };
+export declare const Bech32mSymbol: unique symbol;
+export type HasCodec<T> = {
+    [Bech32mSymbol]: Bech32mCodec<T>;
+};
+export type CodecTarget<T> = T extends HasCodec<infer U> ? U : never;
 export declare class MidnightBech32m {
     static readonly prefix = "mn";
+    static encode<T extends HasCodec<T>>(networkId: NetworkId, item: T): MidnightBech32m;
     static validateSegment(segmentName: string, segment: string): void;
     static parse(bech32string: string): MidnightBech32m;
     readonly type: string;
-    readonly network: string | null;
+    readonly network: NetworkId;
     readonly data: Buffer;
-    constructor(type: string, network: string | null, data: Buffer);
+    constructor(type: string, network: NetworkId, data: Buffer);
+    decode<TClass extends HasCodec<any>>(tclass: TClass, networkId: NetworkId): CodecTarget<TClass>;
     asString(): string;
+    toString(): string;
 }
 export declare class Bech32mCodec<T> {
     readonly type: string;
     readonly dataToBytes: (data: T) => Buffer;
     readonly dataFromBytes: (bytes: Buffer) => T;
     constructor(type: string, dataToBytes: (data: T) => Buffer, dataFromBytes: (bytes: Buffer) => T);
-    encode(networkId: string | null, data: T): MidnightBech32m;
-    decode(networkId: string | null, repr: MidnightBech32m): T;
-    static createContext(networkId: string | null): FormatContext;
+    encode(networkId: NetworkId, data: T): MidnightBech32m;
+    decode(networkId: NetworkId, repr: MidnightBech32m): T;
+    static createContext(networkId: NetworkId): FormatContext;
 }
 export declare class ShieldedAddress {
     static readonly codec: Bech32mCodec<ShieldedAddress>;
+    static readonly [Bech32mSymbol]: Bech32mCodec<ShieldedAddress>;
+    readonly [Bech32mSymbol]: Bech32mCodec<ShieldedAddress>;
     readonly coinPublicKey: ShieldedCoinPublicKey;
     readonly encryptionPublicKey: ShieldedEncryptionPublicKey;
     constructor(coinPublicKey: ShieldedCoinPublicKey, encryptionPublicKey: ShieldedEncryptionPublicKey);
     coinPublicKeyString(): string;
     encryptionPublicKeyString(): string;
+    equals(other: ShieldedAddress): boolean;
 }
 export declare class ShieldedEncryptionSecretKey {
     static readonly codec: Bech32mCodec<ShieldedEncryptionSecretKey>;
@@ -67,13 +80,21 @@ export declare class UnshieldedAddress {
     readonly data: Buffer;
     static readonly keyLength = 32;
     static readonly codec: Bech32mCodec<UnshieldedAddress>;
+    static readonly [Bech32mSymbol]: Bech32mCodec<UnshieldedAddress>;
+    readonly [Bech32mSymbol]: Bech32mCodec<UnshieldedAddress>;
     constructor(data: Buffer);
     get hexString(): UserAddress;
+    equals(other: string): boolean;
+    equals(other: UnshieldedAddress): boolean;
 }
 export declare class DustAddress {
     readonly data: bigint;
     static readonly codec: Bech32mCodec<DustAddress>;
+    static readonly [Bech32mSymbol]: Bech32mCodec<DustAddress>;
+    readonly [Bech32mSymbol]: Bech32mCodec<DustAddress>;
     static readonly encodePublicKey: (networkId: string, publicKey: DustPublicKey) => string;
     constructor(data: bigint);
     serialize(): Buffer;
+    equals(other: bigint): boolean;
+    equals(other: DustAddress): boolean;
 }

package/dist/index.js

@@ -1,6 +1,24 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { EncryptionSecretKey } from '@midnight-ntwrk/ledger-v6';
 import { bech32m } from '@scure/base';
 import * as subsquidScale from '@subsquid/scale-codec';
+export const mainnet = Symbol('Mainnet');
+const NetworkId = {
+    toString: (networkId) => {
+        return networkId === mainnet ? 'mainnet' : networkId;
+    },
+};
 export const BLSScalar = {
     bytes: 32,
     modulus: BigInt('0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001'),
@@ -18,8 +36,12 @@ export const ScaleBigInt = {
         return BigInt(res);
     },
 };
+export const Bech32mSymbol = Symbol('MidnightBech32m');
 export class MidnightBech32m {
     static prefix = 'mn';
+    static encode(networkId, item) {
+        return item[Bech32mSymbol].encode(networkId, item);
+    }
     static validateSegment(segmentName, segment) {
         const result = /^[A-Za-z1-9-]+$/.test(segment);
         if (!result) {
@@ -28,12 +50,12 @@ export class MidnightBech32m {
     }
     static parse(bech32string) {
         const bech32parsed = bech32m.decodeToBytes(bech32string);
-        const [prefix, type, network = null] = bech32parsed.prefix.split('_');
+        const [prefix, type, network = mainnet] = bech32parsed.prefix.split('_');
         if (prefix != MidnightBech32m.prefix) {
             throw new Error(`Expected prefix ${MidnightBech32m.prefix}`);
         }
         MidnightBech32m.validateSegment('type', type);
-        if (network != null) {
+        if (network != mainnet) {
             MidnightBech32m.validateSegment('network', network);
         }
         return new MidnightBech32m(type, network, Buffer.from(bech32parsed.bytes));
@@ -46,14 +68,22 @@ export class MidnightBech32m {
         this.network = network;
         this.type = type;
         MidnightBech32m.validateSegment('type', type);
-        if (network != null) {
+        if (network != mainnet) {
             MidnightBech32m.validateSegment('network', network);
         }
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    decode(tclass, networkId) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return tclass[Bech32mSymbol].decode(networkId, this);
+    }
     asString() {
-        const networkSegment = this.network == null ? '' : `_${this.network}`;
+        const networkSegment = this.network == mainnet ? '' : `_${this.network}`;
         return bech32m.encode(`${MidnightBech32m.prefix}_${this.type}${networkSegment}`, bech32m.toWords(this.data), false);
     }
+    toString() {
+        return this.asString();
+    }
 }
 export class Bech32mCodec {
     type;
@@ -74,15 +104,17 @@ export class Bech32mCodec {
             throw new Error(`Expected type ${this.type}, got ${repr.type}`);
         }
         if (context.networkId != repr.network) {
-            throw new Error(`Expected ${context.networkId ?? 'mainnet'} address, got ${repr.network ?? 'mainnet'} one`);
+            throw new Error(`Expected ${NetworkId.toString(context.networkId)} address, got ${NetworkId.toString(repr.network)} one`);
         }
         return this.dataFromBytes(repr.data);
     }
     static createContext(networkId) {
-        if (networkId === null) {
-            return { networkId: null };
+        if (networkId === 'mainnet') {
+            return { networkId: mainnet };
+        }
+        else {
+            return { networkId };
         }
-        return { networkId };
     }
 }
 export class ShieldedAddress {
@@ -91,6 +123,8 @@ export class ShieldedAddress {
         const encryptionPublicKey = new ShieldedEncryptionPublicKey(bytes.subarray(ShieldedCoinPublicKey.keyLength));
         return new ShieldedAddress(coinPublicKey, encryptionPublicKey);
     });
+    static [Bech32mSymbol] = ShieldedAddress.codec;
+    [Bech32mSymbol] = ShieldedAddress.codec;
     coinPublicKey;
     encryptionPublicKey;
     constructor(coinPublicKey, encryptionPublicKey) {
@@ -103,6 +137,9 @@ export class ShieldedAddress {
     encryptionPublicKeyString() {
         return this.encryptionPublicKey.data.toString('hex');
     }
+    equals(other) {
+        return this.coinPublicKey.equals(other.coinPublicKey) && this.encryptionPublicKey.equals(other.encryptionPublicKey);
+    }
 }
 export class ShieldedEncryptionSecretKey {
     static codec = new Bech32mCodec('shield-esk', (esk) => Buffer.from(esk.zswap.yesIKnowTheSecurityImplicationsOfThis_serialize()), (repr) => new ShieldedEncryptionSecretKey(EncryptionSecretKey.deserialize(repr)));
@@ -156,6 +193,8 @@ export class UnshieldedAddress {
     data;
     static keyLength = 32;
     static codec = new Bech32mCodec('addr', (addr) => addr.data, (repr) => new UnshieldedAddress(repr));
+    static [Bech32mSymbol] = UnshieldedAddress.codec;
+    [Bech32mSymbol] = UnshieldedAddress.codec;
     constructor(data) {
         if (data.length != UnshieldedAddress.keyLength) {
             throw new Error('Unshielded address needs to be 32 bytes long');
@@ -165,10 +204,16 @@ export class UnshieldedAddress {
     get hexString() {
         return this.data.toString('hex');
     }
+    equals(other) {
+        const otherAddress = typeof other === 'string' ? new UnshieldedAddress(Buffer.from(other, 'hex')) : other;
+        return otherAddress.data.equals(this.data);
+    }
 }
 export class DustAddress {
     data;
     static codec = new Bech32mCodec('dust', (daddr) => daddr.serialize(), (repr) => new DustAddress(ScaleBigInt.decode(repr)));
+    static [Bech32mSymbol] = DustAddress.codec;
+    [Bech32mSymbol] = DustAddress.codec;
     static encodePublicKey = (networkId, publicKey) => {
         return DustAddress.codec.encode(networkId, new DustAddress(publicKey)).asString();
     };
@@ -181,4 +226,8 @@ export class DustAddress {
     serialize() {
         return ScaleBigInt.encode(this.data);
     }
+    equals(other) {
+        const otherAddress = typeof other === 'bigint' ? other : other.data;
+        return otherAddress === this.data;
+    }
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-address-format",
-  "version": "3.0.0-beta.7",
+  "version": "3.0.0-beta.9",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "author": "IOHK",
+  "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
@@ -24,7 +24,7 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.5",
+    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.6",
     "@scure/base": "^1.2.6",
     "@subsquid/scale-codec": "^4.0.1"
   },
@@ -41,6 +41,7 @@
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
     "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml}\"",
     "dist": "tsc -b ./tsconfig.build.json",
     "dist:publish": "tsc -b ./tsconfig.publish.json",
     "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",