@com-chain/jsc3l 2.0.1-rc.19 → 2.0.1-rc.20

package/src/bcTransaction.ts

@@ -2,7 +2,7 @@
 import { getNakedAddress, padLeft, encodeNumber } from './ethereum/ethFuncs'
 import { generateTx } from './ethereum/uiFuncs'
 import AjaxReq from './rest/ajaxReq'
-
+import * as utils from './utils'
 
 function roundCent (strAmount:string) {
   return Math.round(100 * parseFloat(strAmount))
@@ -14,7 +14,7 @@ function typeConv (label: string): (x:any) => (string | number) {
     return (a) => padLeft(getNakedAddress(a), 64)
   }
   if (label === 'int') {
-    return (nb) => encodeNumber(parseInt(nb, 19))
+    return (nb) => encodeNumber(parseInt(nb, 10))
   }
   if (label.startsWith('limit') || label === 'amount') {
     return (nb) => encodeNumber(roundCent(nb))
@@ -40,48 +40,96 @@ export abstract class BcTransactionAbstract {
   // //////////////////////////////////////////////////////////////////////////
   //  CM VS Nant Handling
 
-  getSplitting (nantVal, cmVal, cmMinusLim, amount) {
-    cmVal = parseFloat(cmVal)
-    nantVal = parseFloat(nantVal)
-    let nant = 0
-    let cm = 0
-
-    let res = parseFloat(amount)
-    if (cmVal > 0) {
-      if (cmVal >= res) {
-        cm = res
-        res = 0
-      } else {
-        cm = cmVal
-        res = res - cmVal
-        cmVal = 0
-      }
-    }
-
-    if (nantVal > 0) {
-      if (nantVal >= res) {
-        nant = res
-        res = 0
-      } else {
-        nant = nantVal
-        res = res - nantVal
-        // nantVal=0;
-      }
+  static getSplitting (nantBal, cmBal, cmSrcMin, amount) {
+    console.warn("Obsolete usage of `BcTransactionAbstract.getSplitting()'," +
+                 " prefer `jsc3l.utils.getSplitting()'")
+    cmBal = parseFloat(cmBal)
+    nantBal = parseFloat(nantBal)
+    amount = parseFloat(amount)
+    cmSrcMin = parseFloat(cmSrcMin)
+
+    try {
+      let {nant, cm} = utils.getSplitting(amount, { cm: cmBal, nant: nantBal}, cmSrcMin)
+      return { possible: true, nant, cm}
+    } catch(e: any) {
+      return { possible: false}
     }
-
-    if (res > 0 && cmVal - parseFloat(cmMinusLim) >= res) {
-      cm = cm + res
-      res = 0
-    }
-
-    const possible = res === 0
-    return { possible: possible, nant: nant, cm: cm }
   }
-
-  // //////////////////////////////////////////////////////////////////////////
+  getSplitting = BcTransactionAbstract.getSplitting
 
 }
 
+/* @skip-prod-transpilation */
+if (import.meta.vitest) {
+  const { it, expect, describe } = import.meta.vitest
+  describe('split', () => {
+    it('should split 0 to cm: 0, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 0, 0, 0))
+        .toStrictEqual({ possible: true, nant: 0, cm: 0})
+    });
+    it('should NOT split 1 with no funds', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 0, 0, 1).possible)
+        .toBe(false)
+    });
+    // Only Cm
+    it('should split 1 to cm: 1, nant: 0 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 1))
+        .toStrictEqual({ possible: true, nant: 0, cm: 1})
+    });
+    it('should split 2 to cm: 2, nant: 0 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 2))
+        .toStrictEqual({ possible: true, nant: 0, cm: 2})
+    });
+    it('should NOT split 3 with bal cm: 2, nant: 0', () => {
+      expect(BcTransactionAbstract.getSplitting(0, 2, 0, 3).possible)
+        .toBe(false)
+    });
+    // Only Nant
+    it('should split 1 to cm: 0, nant: 1 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 1))
+        .toStrictEqual({ possible: true, nant: 1, cm: 0})
+    });
+    it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 2))
+        .toStrictEqual({ possible: true, nant: 2, cm: 0})
+    });
+    it('should NOT split 3 with bal cm: 0, nant: 2', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, 0, 3).possible)
+        .toBe(false)
+    });
+    // Both Nant and Cm
+    it('should split 2 to cm: 1, nant: 1 with bal cm: 1, nant: 1', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 1, 0, 2))
+        .toStrictEqual({ possible: true, nant: 1, cm: 1})
+    });
+    it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(2, 0, -2, 2))
+        .toStrictEqual({ possible: true, nant: 2, cm: 0})
+    });
+    it('should split 2 to cm: 1, nant: 1 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 0, -1, 2))
+        .toStrictEqual({ possible: true, nant: 1, cm: 1})
+    });
+    it('should NOT split 3 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 0, -1, 3).possible)
+        .toBe(false)
+    });
+    it('should split 3 to cm: 2, nant: 1 with bal cm: 1, nant: 1 (limSrcCm: -1)', () => {
+      expect(BcTransactionAbstract.getSplitting(1, 1, -1, 3))
+        .toStrictEqual({ possible: true, nant: 1, cm: 2})
+    });
+    // Negative cm bal and limSrcCm
+    it('should split 1 to cm: -1, nant: 0 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(0, -1, -2, 1))
+        .toStrictEqual({ possible: true, nant: 0, cm: 1})
+    });
+    it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+      expect(BcTransactionAbstract.getSplitting(0, -1, -2, 2).possible)
+        .toBe(false)
+    });
+
+  });
+}
 
 export function transactionFactory(transactionDefs: any[], bcTransactionClass: any) {
 

package/src/ethereum/ethFuncs.ts

@@ -86,7 +86,7 @@ if (import.meta.vitest) {
     it('should encode 16 to "00...0010"', () => {
       expect(encodeNumber(16)).toBe('0000000000000000000000000000000000000000000000000000000000000010')
     })
-    it('should encode 0x1f_ffff_ffff_ffff to "00...ffff_ffff_ffff"', () => {
+    it('should encode 0x1f_ffff_ffff_ffff to "00...001f_ffff_ffff_ffff"', () => {
       expect(encodeNumber(0x1f_ffff_ffff_ffff)).toBe('000000000000000000000000000000000000000000000000001fffffffffffff')
     })
 
@@ -99,11 +99,11 @@ if (import.meta.vitest) {
     it('should encode -0x10 to "ff...fff0"', () => {
       expect(encodeNumber(-0x10)).toBe('fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0')
     })
-    it('should encode -0x1f_ffff_ffff_fffff to "ff...e0000000000001"', () => {
+    it('should encode -0x1f_ffff_ffff_fffff to "ff...ffe0_0000_0000_0001"', () => {
       expect(encodeNumber(-0x1f_ffff_ffff_ffff)).toBe('ffffffffffffffffffffffffffffffffffffffffffffffffffe0000000000001')
     })
 
-    it('should refuse to encode 0x1ff_ffff_ffff_ffff', () => {
+    it('should refuse to encode 0x20_0000_0000_0000', () => {
       expect(() => encodeNumber(0x20_0000_0000_0000)).toThrowError('number type')
     })
     it('should refuse to encode -0x20_0000_0000_0000', () => {

package/src/index.ts

@@ -5,6 +5,7 @@ import * as qr from './qr'
 // Only required for blockie helper
 import blockies from './blockies'
 import Wallet from './ethereum/myetherwallet'
+import * as utils from './utils'
 
 import * as t from './type'
 
@@ -47,7 +48,7 @@ abstract class AbstractJsc3l {
   _Endpoint: new (baseUrl: any) => EndpointAbstract
   _connection: null | ConnectionMgrAbstract
   _http: null | HttpAbstract
-
+  utils = utils
 
   constructor (localDefaultConf?, defaultTransactionDefs?) {
     this.localDefaultConf = localDefaultConf || {}

package/src/utils.ts

@@ -0,0 +1,300 @@
+export class SplitError extends Error {
+  constructor (message) {
+    super(message)
+    this.name = 'SplitError'
+  }
+}
+
+
+export class InsufficientBalanceError extends SplitError {
+  missingAmount: number
+  constructor (message, missingAmount) {
+    super(message)
+    this.name = 'InsufficientBalanceError'
+    this.missingAmount = missingAmount
+  }
+}
+
+export class CmSpendLimitError extends SplitError {
+  missingAmount: number
+  constructor (message, missingAmount) {
+    super(message)
+    this.name = 'CmSpendLimitError'
+    this.missingAmount = missingAmount
+  }
+}
+
+
+function min(a, b) {
+  return a < b ? a : b
+}
+
+
+export let getSplitting = function (amount, bals, cmSrcMin, cmSpendMax = null) {
+
+  const zero = amount - amount  // Required for agnosticity
+
+  const split = { nant: zero, cm: zero }
+  const cmPosSpendMax = cmSpendMax !== null ? min(bals.cm, cmSpendMax) : bals.cm
+
+  if (cmPosSpendMax >= 0) {
+    if (cmPosSpendMax >= amount) {
+      split.cm += amount
+      return split
+    }
+    split.cm += cmPosSpendMax
+    amount -= cmPosSpendMax
+    bals.cm -= cmPosSpendMax
+    if (cmSpendMax !== null) {
+      cmSpendMax -= cmPosSpendMax
+    }
+  }
+
+  if (bals.nant >= amount) {
+    split.nant += amount
+    return split
+  }
+
+  split.nant = bals.nant
+  amount -= bals.nant
+
+  let cmNegAvailable = bals.cm - cmSrcMin
+  const cmNegSpendMax = cmSpendMax !== null ? min(cmNegAvailable, cmSpendMax) : cmNegAvailable
+  if (cmNegSpendMax >= amount) {
+    split.cm += amount
+    return split
+  }
+
+  amount -= cmNegSpendMax
+  bals.cm -= cmNegSpendMax
+  if (cmSpendMax !== null) {
+    cmSpendMax -= cmNegSpendMax
+  }
+
+  cmNegAvailable = (bals.cm - cmSrcMin)
+  if (cmNegAvailable >= amount && cmSpendMax == 0) {
+    throw new CmSpendLimitError(
+      `Cm spend limit preventing to complete amount (remaining: ${amount}).`,
+      amount
+    )
+  }
+
+  throw new InsufficientBalanceError(
+    `Missing ${amount - cmNegAvailable} to complete amount`,
+    amount - cmNegAvailable
+  )
+}
+
+
+/* @skip-prod-transpilation */
+if (import.meta.vitest) {
+  const { it, expect, describe, beforeAll, afterAll } = import.meta.vitest
+
+  function testSuite (numberFactory: any = null, label: any = null) {
+    let msg
+    if (numberFactory) {
+      msg = `check with ${label}`
+    } else {
+      msg = "check with standard number"
+    }
+    describe(msg, () => {
+
+      let getSplittingOrig = getSplitting
+      let toStrictEqual
+
+      beforeAll(() => {
+
+        if (numberFactory) {
+          getSplitting = function (amount, bals, cmSrcMin, cmSpendMax = null) {
+            amount = numberFactory(amount)
+            bals.cm = numberFactory(bals.cm)
+            bals.nant = numberFactory(bals.nant)
+            cmSrcMin = numberFactory(cmSrcMin)
+            if (cmSpendMax !== null) {
+              cmSpendMax = numberFactory(cmSpendMax)
+            }
+            return getSplittingOrig(amount, bals, cmSrcMin, cmSpendMax)
+          }
+          toStrictEqual = function (actual, expected) {
+            let { cm, nant } = expected
+            expect(actual).toStrictEqual({ cm: numberFactory(cm), nant: numberFactory(nant) })
+          }
+        } else {
+          toStrictEqual = function (actual, expected) {
+            expect(actual).toStrictEqual(expected)
+          }
+        }
+      })
+
+      afterAll(() => {
+        getSplitting = getSplittingOrig
+      })
+
+
+      describe('split without cmSpendMax', () => {
+        it('should split 0 to cm: 0, nant: 0', () => {
+          toStrictEqual(getSplitting(0, { cm: 0, nant: 0 }, 0), { nant: 0, cm: 0 })
+        });
+        it('should NOT split 1 with no funds', () => {
+          expect(() => getSplitting(1, { cm: 0, nant: 0 }, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Only Cm
+        it('should split 1 to cm: 1, nant: 0 with bal cm: 2, nant: 0', () => {
+          toStrictEqual(getSplitting(1, {cm: 2, nant: 0}, 0), { nant: 0, cm: 1 })
+        });
+        it('should split 2 to cm: 2, nant: 0 with bal cm: 2, nant: 0', () => {
+          toStrictEqual(getSplitting(2, { cm: 2, nant: 0 }, 0), { nant: 0, cm: 2 })
+        });
+        it('should NOT split 3 with bal cm: 2, nant: 0', () => {
+          expect(() => getSplitting(3, { cm: 2, nant: 0 }, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Only Nant
+        it('should split 1 to cm: 0, nant: 1 with bal cm: 0, nant: 2', () => {
+          toStrictEqual(getSplitting(1, { cm: 0, nant: 2 }, 0), { nant: 1, cm: 0 })
+        });
+        it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2', () => {
+          toStrictEqual(getSplitting(2, { cm: 0, nant: 2 }, 0), { nant: 2, cm: 0 })
+        });
+        it('should NOT split 3 with bal cm: 0, nant: 2', () => {
+          expect(() => getSplitting(3, { cm: 0, nant: 2 }, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Both Nant and Cm
+        it('should split 2 to cm: 1, nant: 1 with bal cm: 1, nant: 1', () => {
+          toStrictEqual(getSplitting(2, { cm: 1, nant: 1 }, 0), { nant: 1, cm: 1 })
+        });
+        it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2 (limSrcCm: -2)', () => {
+          toStrictEqual(getSplitting(2, { cm: 0, nant: 2 }, -2), { nant: 2, cm: 0 })
+        });
+        it('should split 2 to cm: 1, nant: 1 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+          toStrictEqual(getSplitting(2, { cm: 0, nant: 1 }, -1), { nant: 1, cm: 1 })
+        });
+        it('should NOT split 3 with bal cm: 0, nant: 1 (limSrcCm: -1)', () => {
+          expect(() => getSplitting(3, { cm: 0, nant: 1 }, -1))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should split 3 to cm: 2, nant: 1 with bal cm: 1, nant: 1 (limSrcCm: -1)', () => {
+          toStrictEqual(getSplitting(3, { cm: 1, nant: 1 }, -1), { nant: 1, cm: 2 })
+        });
+        // Negative cm bal and limSrcCm
+        it('should split 1 to cm: -1, nant: 0 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+          toStrictEqual(getSplitting(1, { cm: -1, nant: 0 }, -2), { nant: 0, cm: 1 })
+        });
+        it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -2)', () => {
+          expect(() => getSplitting(2, { cm: -1, nant: 0 }, -2))
+            .toThrow("Missing 1 to complete amount")
+        });
+      });
+      describe('split with cmSpendMax', () => {
+        it('should split 0 to cm: 0, nant: 0 (cmSpendMax: 0)', () => {
+          toStrictEqual(getSplitting(0, { cm: 0, nant: 0 }, 0, 0), { nant: 0, cm: 0})
+        });
+        it('should split 0 to cm: 0, nant: 0 (cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(0, { cm: 0, nant: 0 }, 0, 0), { nant: 0, cm: 0})
+        });
+        it('should NOT split 1 with no funds (cmSpendMax: 1)', () => {
+          expect(() => getSplitting(1, { cm: 0, nant: 0 }, 0, 1))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 1 with no funds (cmSpendMax: 0)', () => {
+          expect(() => getSplitting(1, { cm: 0, nant: 0 }, 0, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Only Cm
+        it('should split 1 to cm: 1, nant: 0 with bal cm: 2, nant: 0 (cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(1, {cm: 2, nant: 0}, 0, 1), { nant: 0, cm: 1 })
+        });
+        it('should split 2 to cm: 2, nant: 0 with bal cm: 2, nant: 0 (cmSpendMax: 2)', () => {
+          toStrictEqual(getSplitting(2, { cm: 2, nant: 0 }, 0, 2), { nant: 0, cm: 2 })
+        });
+        it('should NOT split 2 to cm: 2, nant: 0 with bal cm: 2, nant: 0 (cmSpendMax: 1)', () => {
+          expect(() => getSplitting(2, { cm: 2, nant: 0 }, 0, 1))
+            .toThrow("Cm spend limit preventing to complete amount (remaining: 1)")
+        });
+        it('should NOT split 3 with bal cm: 2, nant: 0 (cmSpendMax: 5)', () => {
+          expect(() => getSplitting(3, { cm: 2, nant: 0 }, 0, 5))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 3 with bal cm: 2, nant: 0 (cmSpendMax: 2)', () => {
+          expect(() => getSplitting(3, { cm: 2, nant: 0 }, 0, 2))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 3 with bal cm: 2, nant: 0 (cmSpendMax: 1)', () => {
+          expect(() => getSplitting(3, { cm: 2, nant: 0 }, 0, 1))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Only Nant
+        it('should split 1 to cm: 0, nant: 1 with bal cm: 0, nant: 2 (cmSpendMax: 0)', () => {
+          toStrictEqual(getSplitting(1, { cm: 0, nant: 2 }, 0, 0), { nant: 1, cm: 0 })
+        });
+        it('should split 2 to cm: 0, nant: 2 with bal cm: 0, nant: 2 (cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(2, { cm: 0, nant: 2 }, 0, 1), { nant: 2, cm: 0 })
+        });
+        it('should NOT split 3 with bal cm: 0, nant: 2 (cmSpendMax: 0)', () => {
+          expect(() => getSplitting(3, { cm: 0, nant: 2 }, 0, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        // Both Nant and Cm
+        it('should split 2 to cm: 1, nant: 1 with bal cm: 1, nant: 1 (cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(2, { cm: 1, nant: 1 }, 0, 1), { nant: 1, cm: 1})
+        });
+        it('should NOT split 2 to cm: 1, nant: 1 with bal cm: 1, nant: 1 (cmSpendMax: 0)', () => {
+          expect(() => getSplitting(2, { cm: 1, nant: 1 }, 0, 0))
+            .toThrow("Cm spend limit preventing to complete amount (remaining: 1)")
+        });
+        it('should split 2 to cm: 1, nant: 1 with bal cm: 0, nant: 1 (limSrcCm: -1, cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(2, { cm: 0, nant: 1 }, -1, 1), { nant: 1, cm: 1})
+        });
+        it('should NOT split 2 to cm: 1, nant: 1 with bal cm: 0, nant: 1 (limSrcCm: -1, cmSpendMax: 0)', () => {
+          expect(() => getSplitting(2, { cm: 0, nant: 1 }, -1, 0))
+            .toThrow("Cm spend limit preventing to complete amount (remaining: 1)")
+        });
+        it('should NOT split 3 with bal cm: 0, nant: 1 (limSrcCm: -1, cmSpendMax: 5)', () => {
+          expect(() => getSplitting(3, { cm: 0, nant: 1 }, -1, 5))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 3 with bal cm: 0, nant: 1 (limSrcCm: -1, cmSpendMax: 0)', () => {
+          expect(() => getSplitting(3, { cm: 0, nant: 1 }, -1, 0))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should split 3 to cm: 2, nant: 1 with bal cm: 1, nant: 1 (limSrcCm: -1, cmSpendMax: 2)', () => {
+          toStrictEqual(getSplitting(3, { cm: 1, nant: 1 }, -1, 2), { nant: 1, cm: 2 })
+        });
+        it('should NOT split 3 to cm: 2, nant: 1 with bal cm: 1, nant: 1 (limSrcCm: -1, cmSpendMax: 1)', () => {
+          expect(() => getSplitting(3, { cm: 1, nant: 1 }, -1, 1))
+            .toThrow("Cm spend limit preventing to complete amount (remaining: 1)")
+        });
+        // If the recipient can't receive cm, then pay with nant if possible.
+        it('should split 2 to cm: 0, nant: 2 with bal cm: 2, nant: 2 (limSrcCm: 0, cmSpendMax: 0)', () => {
+          toStrictEqual(getSplitting(2, { cm: 2, nant: 2 }, 0, 0), { nant: 2, cm: 0 })
+        });
+        it('should split 3 to cm: 1, nant: 2 with bal cm: 2, nant: 2 (limSrcCm: 0, cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(3, { cm: 2, nant: 2 }, 0, 1), { nant: 2, cm: 1 })
+        });
+        it('should split 3 to cm: 2, nant: 2 with bal cm: 2, nant: 2 (limSrcCm: 0, cmSpendMax: 2)', () => {
+          toStrictEqual(getSplitting(3, { cm: 2, nant: 2 }, 0, 2), { nant: 1, cm: 2 })
+        });
+        // Negative cm bal and limSrcCm
+        it('should split 1 to cm: -1, nant: 0 with bal cm: -1, nant: 0 (limSrcCm: -2, cmSpendMax: 1)', () => {
+          toStrictEqual(getSplitting(1, { cm: -1, nant: 0 }, -2, 1), { nant: 0, cm: 1 })
+        });
+        it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -2, cmSpendMax: 2)', () => {
+          expect(() => getSplitting(2, { cm: -1, nant: 0 }, -2, 2))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -2, cmSpendMax: 0)', () => {
+          expect(() => getSplitting(2, { cm: -1, nant: 0 }, -2, 2))
+            .toThrow("Missing 1 to complete amount")
+        });
+        it('should NOT split 2 with bal cm: -1, nant: 0 (limSrcCm: -3, cmSpendMax: 1)', () => {
+          expect(() => getSplitting(2, { cm: -1, nant: 0 }, -3, 1))
+            .toThrow("Cm spend limit preventing to complete amount (remaining: 1)")
+        });
+      })
+    })
+  }
+  testSuite()
+  testSuite(BigInt, "BigInt")
+}

package/tests/environment.ts

@@ -0,0 +1,27 @@
+import type { Environment } from 'vitest'
+
+export default <Environment>{
+  name: 'custom',
+  transformMode: 'ssr',
+  // optional - only if you support "experimental-vm" pool
+  async setupVM() {
+    const vm = await import('node:vm')
+    const context = vm.createContext()
+    return {
+      getVmContext() {
+        return context
+      },
+      teardown() {
+        // called after all tests with this env have been run
+      }
+    }
+  },
+  setup() {
+    // custom setup
+    return {
+      teardown() {
+        // called after all tests with this env have been run
+      }
+    }
+  }
+}

package/tests/setup.ts

@@ -0,0 +1,12 @@
+import { Buffer } from 'buffer'
+import { afterAll, beforeAll } from 'vitest';
+
+beforeAll(() => {
+  global.Buffer = Buffer
+});
+
+afterAll(() => {
+  delete global.Buffer
+});
+
+

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
     "compilerOptions": {
-        "target": "es2017",
+        "target": "es2020",
         "module": "esnext",
         "moduleResolution": "node",
         "declaration": true,

package/vitest.config.ts

@@ -6,6 +6,8 @@ const cfg =  defineConfig({
     include: ['src/**/*.{js,ts}'],
     setupFiles: ['./tests/setup.ts'],
     environment: 'jsdom',
+    passWithNoTests: true,
+    bail: 1,
   },
 })