@totemsdk/core 1.2.3 → 1.2.5

package/README.md

@@ -2,7 +2,7 @@
 
 **The cryptographic engine — every other package depends on this.**
 
-Zero production dependencies (only `@noble/hashes` as a peer). Provides quantum-resistant WOTS signatures, hierarchical TreeKey address derivation, BIP39 seed phrases, Merkle Mountain Range proofs, and byte-exact Minima Java-compatible transaction serialization.
+Zero production dependencies (only `@noble/hashes` as a peer). Provides WOTS (Winternitz) signatures, hierarchical TreeKey address derivation, BIP39 seed phrases, Merkle Mountain Range proofs, and byte-exact Minima Java-compatible transaction serialization.
 
 ## Install
 

package/dist/MiniNumber.d.ts

@@ -0,0 +1,47 @@
+export declare class MiniNumber {
+    readonly unscaled: bigint;
+    readonly scale: number;
+    static readonly ZERO: MiniNumber;
+    static readonly ONE: MiniNumber;
+    static readonly TWO: MiniNumber;
+    static readonly THREE: MiniNumber;
+    static readonly FOUR: MiniNumber;
+    static readonly EIGHT: MiniNumber;
+    static readonly TWELVE: MiniNumber;
+    static readonly SIXTEEN: MiniNumber;
+    static readonly TWENTY: MiniNumber;
+    static readonly THIRTYTWO: MiniNumber;
+    static readonly FIFTY: MiniNumber;
+    static readonly SIXTYFOUR: MiniNumber;
+    static readonly TWOFIVESIX: MiniNumber;
+    static readonly FIVEONE12: MiniNumber;
+    static readonly THOUSAND24: MiniNumber;
+    static readonly MINUSONE: MiniNumber;
+    constructor(value: string | number | bigint | MiniNumber);
+    getAsBigDecimal(): string;
+    getAsBigInteger(): string;
+    toNumber(): number;
+    toString(): string;
+    private assertSameScale;
+    add(other: MiniNumber): MiniNumber;
+    sub(other: MiniNumber): MiniNumber;
+    mult(other: MiniNumber): MiniNumber;
+    div(other: MiniNumber): MiniNumber;
+    modulo(other: MiniNumber): MiniNumber;
+    pow(n: number): MiniNumber;
+    sqrt(): MiniNumber;
+    floor(): MiniNumber;
+    ceil(): MiniNumber;
+    abs(): MiniNumber;
+    negate(): MiniNumber;
+    increment(): MiniNumber;
+    decrement(): MiniNumber;
+    compareTo(other: MiniNumber): number;
+    isEqual(other: MiniNumber): boolean;
+    isLess(other: MiniNumber): boolean;
+    isLessEqual(other: MiniNumber): boolean;
+    isMore(other: MiniNumber): boolean;
+    isMoreEqual(other: MiniNumber): boolean;
+    setSignificantDigits(d: number): MiniNumber;
+    decimalPlaces(): number;
+}

package/dist/MiniNumber.js

@@ -0,0 +1,300 @@
+"use strict";
+// Matching Java's `org.minima.objects.base.MiniNumber` backed by `BigDecimal`
+// with MathContext(64, RoundingMode.DOWN).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiniNumber = void 0;
+const MAX_DIGITS = 64;
+const MAX_DECIMAL_PLACES = MAX_DIGITS - 20;
+const MAX_VALUE_BIG = (1n << 64n) - 1n; // 2^64 - 1
+function checkLimits(unscaled, scale) {
+    if (scale > MAX_DECIMAL_PLACES) {
+        const diff = scale - MAX_DECIMAL_PLACES;
+        const divisor = 10n ** BigInt(diff);
+        unscaled = unscaled / divisor;
+        scale = MAX_DECIMAL_PLACES;
+    }
+    const abs = unscaled < 0n ? -unscaled : unscaled;
+    const factor = 10n ** BigInt(scale);
+    const intPart = abs / factor;
+    const rem = abs % factor;
+    if (intPart > MAX_VALUE_BIG || (intPart === MAX_VALUE_BIG && rem > 0n)) {
+        throw new RangeError(`MiniNumber too large: ${unscaled}E${-scale}`);
+    }
+}
+function digits(v) {
+    if (v === 0n)
+        return 0;
+    return v.toString().replace('-', '').length;
+}
+function roundToDigits(unscaled, scale, digits_target) {
+    let u = unscaled;
+    let s = scale;
+    const currentDigits = digits(u);
+    if (currentDigits > digits_target) {
+        const drop = currentDigits - digits_target;
+        const divisor = 10n ** BigInt(drop);
+        u = u / divisor;
+        s = s - drop;
+    }
+    if (s > MAX_DECIMAL_PLACES) {
+        const diff = s - MAX_DECIMAL_PLACES;
+        const divisor = 10n ** BigInt(diff);
+        u = u / divisor;
+        s = s - diff;
+    }
+    while (s > 0 && u % 10n === 0n) {
+        u = u / 10n;
+        s--;
+    }
+    return { unscaled: u, scale: s };
+}
+class MiniNumber {
+    constructor(value) {
+        if (value instanceof MiniNumber) {
+            this.unscaled = value.unscaled;
+            this.scale = value.scale;
+            return;
+        }
+        if (typeof value === 'bigint') {
+            this.unscaled = value;
+            this.scale = 0;
+            if (value !== 0n) {
+                const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+                this.unscaled = r.unscaled;
+                this.scale = r.scale;
+                checkLimits(this.unscaled, this.scale);
+            }
+            return;
+        }
+        if (typeof value === 'number') {
+            const s = Number.isInteger(value) ? value.toFixed(0) : value.toExponential(20);
+            const parsed = parseDecimal(s);
+            this.unscaled = parsed.unscaled;
+            this.scale = parsed.scale;
+            if (this.unscaled !== 0n) {
+                const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+                this.unscaled = r.unscaled;
+                this.scale = r.scale;
+                checkLimits(this.unscaled, this.scale);
+            }
+            return;
+        }
+        const parsed = parseDecimal(value);
+        this.unscaled = parsed.unscaled;
+        this.scale = parsed.scale;
+        if (this.unscaled !== 0n) {
+            const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+            this.unscaled = r.unscaled;
+            this.scale = r.scale;
+            checkLimits(this.unscaled, this.scale);
+        }
+    }
+    getAsBigDecimal() {
+        return this.toString();
+    }
+    getAsBigInteger() {
+        const s = this.toString();
+        const dot = s.indexOf('.');
+        return dot === -1 ? s : s.slice(0, dot);
+    }
+    toNumber() {
+        return Number(this.toString());
+    }
+    toString() {
+        if (this.unscaled === 0n)
+            return '0';
+        const neg = this.unscaled < 0n;
+        const abs = neg ? -this.unscaled : this.unscaled;
+        let s = abs.toString();
+        if (s.length <= this.scale) {
+            s = s.padStart(this.scale + 1, '0');
+            s = s.slice(0, s.length - this.scale) + '.' + s.slice(s.length - this.scale);
+        }
+        else {
+            s = s.slice(0, s.length - this.scale) + '.' + s.slice(s.length - this.scale);
+        }
+        s = s.replace(/(\.[0-9]*?)0+$/, '$1').replace(/\.$/, '');
+        return neg ? '-' + s : s;
+    }
+    assertSameScale(other) {
+        if (this.scale === other.scale)
+            return { a: this.unscaled, b: other.unscaled, outScale: this.scale };
+        if (this.scale > other.scale) {
+            const diff = this.scale - other.scale;
+            return { a: this.unscaled, b: other.unscaled * 10n ** BigInt(diff), outScale: this.scale };
+        }
+        const diff = other.scale - this.scale;
+        return { a: this.unscaled * 10n ** BigInt(diff), b: other.unscaled, outScale: other.scale };
+    }
+    add(other) {
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a + b;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    sub(other) {
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a - b;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    mult(other) {
+        const result = this.unscaled * other.unscaled;
+        const outScale = this.scale + other.scale;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    div(other) {
+        if (other.unscaled === 0n)
+            throw new Error('Division by zero');
+        const extraScale = MAX_DIGITS;
+        const scaledThis = this.unscaled * 10n ** BigInt(extraScale);
+        const result = scaledThis / other.unscaled;
+        const outScale = this.scale + extraScale - other.scale;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    modulo(other) {
+        if (other.unscaled === 0n)
+            throw new Error('Modulo by zero');
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a % b;
+        return new MiniNumber(result.toString() + 'e' + (-outScale));
+    }
+    pow(n) {
+        if (n < 0)
+            throw new Error('Negative power not supported');
+        let result = MiniNumber.ONE;
+        for (let i = 0; i < n; i++)
+            result = result.mult(this);
+        return result;
+    }
+    sqrt() {
+        if (this.unscaled < 0n)
+            throw new Error('Square root of negative number');
+        if (this.unscaled === 0n)
+            return MiniNumber.ZERO;
+        const extra = MAX_DIGITS * 2;
+        const scaled = this.unscaled * 10n ** BigInt(extra);
+        const s = scaled / 10n ** BigInt(extra / 2);
+        let x = s;
+        const two = 2n;
+        for (let i = 0; i < 100; i++) {
+            const next = (x + scaled / x) / two;
+            if (next === x)
+                break;
+            x = next;
+        }
+        const outScale = (this.scale + extra) / 2;
+        const r = roundToDigits(x, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    floor() {
+        if (this.scale === 0)
+            return new MiniNumber(this);
+        const divisor = 10n ** BigInt(this.scale);
+        const q = this.unscaled / divisor;
+        const rem = this.unscaled % divisor;
+        if (this.unscaled < 0n && rem !== 0n) {
+            return new MiniNumber((q - 1n).toString());
+        }
+        return new MiniNumber(q.toString());
+    }
+    ceil() {
+        if (this.scale === 0)
+            return new MiniNumber(this);
+        const divisor = 10n ** BigInt(this.scale);
+        const q = this.unscaled / divisor;
+        const rem = this.unscaled % divisor;
+        if (this.unscaled > 0n && rem !== 0n) {
+            return new MiniNumber((q + 1n).toString());
+        }
+        return new MiniNumber(q.toString());
+    }
+    abs() {
+        if (this.unscaled >= 0n)
+            return new MiniNumber(this);
+        return new MiniNumber((-this.unscaled).toString() + 'e' + (-this.scale));
+    }
+    negate() {
+        return new MiniNumber((-this.unscaled).toString() + 'e' + (-this.scale));
+    }
+    increment() {
+        return this.add(MiniNumber.ONE);
+    }
+    decrement() {
+        return this.sub(MiniNumber.ONE);
+    }
+    compareTo(other) {
+        const { a, b } = this.assertSameScale(other);
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+    isEqual(other) { return this.compareTo(other) === 0; }
+    isLess(other) { return this.compareTo(other) < 0; }
+    isLessEqual(other) { return this.compareTo(other) <= 0; }
+    isMore(other) { return this.compareTo(other) > 0; }
+    isMoreEqual(other) { return this.compareTo(other) >= 0; }
+    setSignificantDigits(d) {
+        if (d > MAX_DIGITS)
+            throw new Error(`Cannot specify this many significant digits ${d}`);
+        if (d < 0)
+            throw new Error(`Cannot specify negative significant digits ${d}`);
+        const currentDigits = digits(this.unscaled);
+        if (currentDigits <= d)
+            return new MiniNumber(this);
+        const drop = currentDigits - d;
+        const divisor = 10n ** BigInt(drop);
+        const newUnscaled = this.unscaled / divisor;
+        return new MiniNumber(newUnscaled.toString() + 'e' + (-(this.scale - drop)));
+    }
+    decimalPlaces() {
+        return this.scale;
+    }
+}
+exports.MiniNumber = MiniNumber;
+MiniNumber.ZERO = new MiniNumber(0);
+MiniNumber.ONE = new MiniNumber(1);
+MiniNumber.TWO = new MiniNumber(2);
+MiniNumber.THREE = new MiniNumber(3);
+MiniNumber.FOUR = new MiniNumber(4);
+MiniNumber.EIGHT = new MiniNumber(8);
+MiniNumber.TWELVE = new MiniNumber(12);
+MiniNumber.SIXTEEN = new MiniNumber(16);
+MiniNumber.TWENTY = new MiniNumber(20);
+MiniNumber.THIRTYTWO = new MiniNumber(32);
+MiniNumber.FIFTY = new MiniNumber(50);
+MiniNumber.SIXTYFOUR = new MiniNumber(64);
+MiniNumber.TWOFIVESIX = new MiniNumber(256);
+MiniNumber.FIVEONE12 = new MiniNumber(512);
+MiniNumber.THOUSAND24 = new MiniNumber(1024);
+MiniNumber.MINUSONE = new MiniNumber(-1);
+function parseDecimal(s) {
+    s = s.trim();
+    const ePos = s.toLowerCase().indexOf('e');
+    if (ePos !== -1) {
+        const mantissa = s.slice(0, ePos);
+        const exponent = parseInt(s.slice(ePos + 1), 10);
+        const { unscaled, scale } = parseDecimal(mantissa);
+        const newScale = scale - exponent;
+        if (newScale < 0) {
+            const factor = 10n ** BigInt(-newScale);
+            return { unscaled: unscaled * factor, scale: 0 };
+        }
+        return { unscaled, scale: newScale };
+    }
+    const neg = s.startsWith('-');
+    const abs = neg ? s.slice(1) : s;
+    const dot = abs.indexOf('.');
+    if (dot === -1) {
+        return { unscaled: BigInt(neg ? '-' + abs : abs), scale: 0 };
+    }
+    const intPart = abs.slice(0, dot) || '0';
+    const fracPart = abs.slice(dot + 1);
+    const full = intPart + fracPart;
+    const scale = fracPart.length;
+    return { unscaled: BigInt(neg ? '-' + full : full), scale };
+}

package/dist/bip39.js

@@ -402,14 +402,23 @@ function phraseToSeed(rawPhrase) {
  * @returns Array of 24 random BIP39 words (lowercase)
  */
 function generateWordList() {
-    if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+    const randomValues = new Uint32Array(24);
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        crypto.getRandomValues(randomValues);
+    }
+    else if (typeof process !== 'undefined' && process.versions?.node) {
+        const nodeCrypto = Function('return require')()('crypto');
+        const bytes = nodeCrypto.randomBytes(96);
+        for (let i = 0; i < 24; i++) {
+            randomValues[i] = bytes.readUInt32BE(i * 4);
+        }
+    }
+    else {
         throw new Error('generateWordList: no cryptographically secure random source available. ' +
             'Seed generation requires crypto.getRandomValues (browser/Node 19+) or node:crypto.randomBytes (Node). ' +
             'Math.random() is not acceptable for key material.');
     }
     const words = [];
-    const randomValues = new Uint32Array(24);
-    crypto.getRandomValues(randomValues);
     for (let i = 0; i < 24; i++) {
         const index = randomValues[i] % exports.WORD_LIST.length;
         words.push(exports.WORD_LIST[index]);

package/dist/index.d.ts

@@ -26,6 +26,7 @@ export * from './mmr.js';
 export * from './scripts/index.js';
 export { scriptToAddress, addressToRoot } from './derive.js';
 export { WORD_LIST, convertStringToSeed, convertWordListToSeed, generateSeedPhrase, } from './bip39.js';
+export { MiniNumber } from './MiniNumber.js';
 export { type MinimaTransaction, type MinimaCoin, type ParsedMiniNumber, type MinimaToken, type StateVariable, type RawStateVariable, type CoinProofData, type SpendableCoinInput, type TransactionBuildResult, parseDecimalToMiniNumber, serializeCoin, createDefaultTransaction, buildMinimaCoin, } from './transaction.js';
 export { verifySignature, verifySignatureDetailed, verifyTreeSignatureDetailed, deriveAddressFromPublicKey, normalizeHex, type VerificationResult, } from './verify.js';
 export { writeMiniByte, writeMMREntryNumber, concat, bigIntToByteArray, type Bytes, } from './Streamable.js';

package/dist/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateChallenge = exports.createChallenge = exports.timingSafeEqual = exports.computeTransactionDigest = exports.serializeTransaction = exports.wotsAddressFromKeypair = exports.parseMxAddress = exports.makeMxAddress = exports.cleanSeedPhrase = exports.validatePhrase = exports.generateWordList = exports.phraseToSeed = exports.verifyMMRProof = exports.mmrRootFromPublicKeys = exports.verifyTreeSignature = exports.deriveUnifiedAddressPublicKey = exports.createUnifiedRootTreeKey = exports.createUnifiedChildTreeKey = exports.precomputeTransactionCoinID = exports.writeMiniString = exports.writeMiniData = exports.writeMiniNumber = exports.deriveRootPrivSeed = exports.derivePerAddressSeed = exports.deriveChainSeedJava = exports.wotsKeypairFromSeed = exports.wotsPublicKeyFromSeed = exports.wotsPkFromSig = exports.wotsVerifyDigest = exports.wotsVerify = exports.wotsSign = exports.deriveFullPublicKey = exports.derivePKdigest = exports.hashChain = exports.expandPrivateKey = exports.sha3_256 = exports.concatBytes = exports.hexToBytes = exports.bytesToHex = exports.TransactionReceiptStore = exports.WatermarkExhaustedError = exports.TransactionLifecycleError = exports.TransactionLifecycle = exports.TransactionService = exports.flatIndexFromLanes = exports.finalizeLease = exports.prepareLease = exports.LeaseMonitor = exports.WatermarkStore = exports.LeaseStore = void 0;
-exports.MINIMA_CONSTANTS = exports.createPerAddressTreeKeyAsync = exports.createPerAddressTreeKey = exports.createUnifiedChildTreeKeyAsync = exports.DEFAULT_LEVELS = exports.DEFAULT_KEYS_PER_LEVEL = exports.getRootPublicKey = exports.deserializeTreeSignature = exports.serializeTreeSignature = exports.TreeKeyNode = exports.TreeKey = exports.serializeMMREntry = exports.serializeMMRData = exports.serializeMMREntryNumber = exports.createMMREntryNumber = exports.deriveUnifiedChildSeed = exports.indexToMiniDataBytes = exports.javaHashAllObjects = exports.writeHashToStream = exports.serializeMiniNumberONE = exports.serializeMiniNumberZERO = exports.hashObject = exports.deriveChildTreeSeedJava = exports.hashAllObjects = exports.serializeMiniData = exports.serializeMiniNumber = exports.bigIntToByteArray = exports.concat = exports.writeMMREntryNumber = exports.writeMiniByte = exports.normalizeHex = exports.deriveAddressFromPublicKey = exports.verifyTreeSignatureDetailed = exports.verifySignatureDetailed = exports.verifySignature = exports.buildMinimaCoin = exports.createDefaultTransaction = exports.serializeCoin = exports.parseDecimalToMiniNumber = exports.generateSeedPhrase = exports.convertWordListToSeed = exports.convertStringToSeed = exports.WORD_LIST = exports.addressToRoot = exports.scriptToAddress = exports.decodeMx = exports.encodeMx = exports.scriptFromWotsPk = void 0;
+exports.MINIMA_CONSTANTS = exports.createPerAddressTreeKeyAsync = exports.createPerAddressTreeKey = exports.createUnifiedChildTreeKeyAsync = exports.DEFAULT_LEVELS = exports.DEFAULT_KEYS_PER_LEVEL = exports.getRootPublicKey = exports.deserializeTreeSignature = exports.serializeTreeSignature = exports.TreeKeyNode = exports.TreeKey = exports.serializeMMREntry = exports.serializeMMRData = exports.serializeMMREntryNumber = exports.createMMREntryNumber = exports.deriveUnifiedChildSeed = exports.indexToMiniDataBytes = exports.javaHashAllObjects = exports.writeHashToStream = exports.serializeMiniNumberONE = exports.serializeMiniNumberZERO = exports.hashObject = exports.deriveChildTreeSeedJava = exports.hashAllObjects = exports.serializeMiniData = exports.serializeMiniNumber = exports.bigIntToByteArray = exports.concat = exports.writeMMREntryNumber = exports.writeMiniByte = exports.normalizeHex = exports.deriveAddressFromPublicKey = exports.verifyTreeSignatureDetailed = exports.verifySignatureDetailed = exports.verifySignature = exports.buildMinimaCoin = exports.createDefaultTransaction = exports.serializeCoin = exports.parseDecimalToMiniNumber = exports.MiniNumber = exports.generateSeedPhrase = exports.convertWordListToSeed = exports.convertStringToSeed = exports.WORD_LIST = exports.addressToRoot = exports.scriptToAddress = exports.decodeMx = exports.encodeMx = exports.scriptFromWotsPk = void 0;
 // Version information for bundle duplication detection
 __exportStar(require("./version.js"), exports);
 // Platform-agnostic Adapters (SDK Upgrade)
@@ -128,6 +128,9 @@ Object.defineProperty(exports, "WORD_LIST", { enumerable: true, get: function ()
 Object.defineProperty(exports, "convertStringToSeed", { enumerable: true, get: function () { return bip39_js_1.convertStringToSeed; } });
 Object.defineProperty(exports, "convertWordListToSeed", { enumerable: true, get: function () { return bip39_js_1.convertWordListToSeed; } });
 Object.defineProperty(exports, "generateSeedPhrase", { enumerable: true, get: function () { return bip39_js_1.generateSeedPhrase; } });
+// MiniNumber class (matches Java MiniNumber/BigDecimal semantics)
+var MiniNumber_js_1 = require("./MiniNumber.js");
+Object.defineProperty(exports, "MiniNumber", { enumerable: true, get: function () { return MiniNumber_js_1.MiniNumber; } });
 // Transaction types (from JS)
 var transaction_js_1 = require("./transaction.js");
 Object.defineProperty(exports, "parseDecimalToMiniNumber", { enumerable: true, get: function () { return transaction_js_1.parseDecimalToMiniNumber; } });

package/dist/wots.d.ts

@@ -4,7 +4,7 @@
  * This implementation matches BouncyCastle's WinternitzOTSignature exactly,
  * which is used by Minima's Winternitz.java class.
  *
- * Key differences from standard WOTS/WOTS+:
+ * Key differences from standard WOTS (Winternitz):
  * - w=8 means 8 BITS per digit (not base-8), so each byte is one digit (0-255)
  * - Stateful PRNG (GMSSRandom) for chain seed derivation, not stateless H(i||seed)
  * - 34 total chains (32 message + 2 checksum), not 89

package/dist/wots.js

@@ -5,7 +5,7 @@
  * This implementation matches BouncyCastle's WinternitzOTSignature exactly,
  * which is used by Minima's Winternitz.java class.
  *
- * Key differences from standard WOTS/WOTS+:
+ * Key differences from standard WOTS (Winternitz):
  * - w=8 means 8 BITS per digit (not base-8), so each byte is one digit (0-255)
  * - Stateful PRNG (GMSSRandom) for chain seed derivation, not stateless H(i||seed)
  * - 34 total chains (32 message + 2 checksum), not 89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Core cryptographic primitives for Totem SDK — backed by Rust/WASM",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",