@opcat-labs/scrypt-ts-opcat 1.0.0

package/src/smart-contract/builtin-libs/contextUtils.ts

@@ -0,0 +1,270 @@
+import { prop, method } from '../decorators.js';
+import { assert } from '../fns/assert.js';
+import { byteStringToInt, intToByteString, len, reverseByteString, slice, toByteString } from '../fns/byteString.js';
+import { hash256 } from '../fns/hashes.js';
+import { SmartContractLib } from '../smartContractLib.js';
+import { PubKey, ByteString, Sig, Int32, UInt32, PrivKey, SigHashPreimage } from '../types/primitives.js';
+import { SHPreimage, SpentScriptHashes, SpentAmounts, Prevouts, Outpoint, SpentDataHashes, TxHashPreimage } from '../types/structs.js';
+import { StdUtils } from './stdUtils.js';
+import { TxUtils } from './txUtils.js';
+
+/**
+ * Library for verifying preimage.
+ * @category Library
+ * @onchain
+ */
+export class ContextUtils extends SmartContractLib {
+
+  // The following arguments can be generated using sample code at
+  // https://gist.github.com/scrypt-sv/f6882be580780a88984cee75dd1564c4.js
+  @prop()
+  static readonly privKey: PrivKey = PrivKey(0x26f00fe2340a84335ebdf30f57e9bb58487117b29355718f5e46bf5168d7df97n);
+  @prop()
+  static readonly pubKey: PubKey = PubKey(toByteString('02ba79df5f8ae7604a9830f03c7933028186aede0675a16f025dc4f8be8eec0382'));
+  // invK is the modular inverse of k, the ephemeral key
+  @prop()
+  static readonly invK: bigint = 0xc8ffdbaa05d93aa4ede79ec58f06a72562048b775a3507c2bf44bde4f007c40an;
+  // r is x coordinate of R, which is kG
+  @prop()
+  static readonly r: bigint = 0x1008ce7480da41702918d1ec8e6849ba32b4d65b1e40dc669c31a1e6306b266cn;
+  // rBigEndian is the signed magnitude representation of r, in big endian
+  @prop()
+  static readonly rBigEndian: ByteString = toByteString('1008ce7480da41702918d1ec8e6849ba32b4d65b1e40dc669c31a1e6306b266c');
+
+
+  @method()
+  static normalize(k: bigint, modulus: bigint): bigint {
+    const res: bigint = k % modulus;
+    // ensure it's positive
+    return (res < 0) ? res + modulus : res;
+  }
+  @method()
+  static sign(h: bigint, privKey: PrivKey, inverseK: bigint, r: bigint, rBigEndian: ByteString, sigHashType: ByteString): Sig {
+    // TODO: r * privKey can also be precomputed
+    let s: bigint = inverseK * (h + r * (privKey as bigint));
+    const N: bigint = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
+    s = ContextUtils.normalize(s, N);
+    // lower S
+    if (s > N / 2n) {
+      s = N - s;
+    }
+    // require(s != 0);		// check offchain
+    /*
+    * DER: h + l + rh + rl + r + sh + sl + s + hashtype
+    * note: r & s are at most 33 bytes, thus no need to convert endian of rl & sl
+    */
+    const rlen: bigint = BigInt(len(rBigEndian));
+    const slen = len(intToByteString(s));
+    // we convert s to 32 bytes, otherwise reverseByteString(, 32) fails when s is strictly less than 31 bytes (note: 31 bytes works)
+    // slice it after reversing to remove extra leading zeros, otherwise strict DER rule fails it due to not minimally encoded
+    const sBigEndian: ByteString = slice(reverseByteString(intToByteString(s, 32n), BigInt(32)), 32n - slen);
+
+    const l: bigint = 4n + rlen + BigInt(slen);
+    // rBigEndian must be mininally encoded, to conform to strict DER rule
+    const rb: ByteString = toByteString('30') 
+    + intToByteString(l) 
+    + toByteString('02')
+    + intToByteString(rlen) 
+    + rBigEndian 
+    + toByteString('02') 
+    + intToByteString(slen) 
+    + sBigEndian
+    + toByteString(sigHashType);
+    return Sig(rb);
+  }
+
+  @method()
+  static fromBEUnsigned(b: ByteString): Int32 {
+    // change endian first
+    // append positive sign byte. This does not hurt even when sign bit is already positive
+    return byteStringToInt(reverseByteString(b, 32n) + toByteString('00'));
+  }
+
+  /**
+   * sign the transaction preimage
+   * @param shPreimage - the transaction preimage
+   * @returns a signature
+   */
+  @method()
+  static checkSHPreimage(shPreimage: SHPreimage, sigHashType: ByteString): Sig {
+    assert(len(shPreimage.nVersion) == 4n, 'invalid length of nVersion');
+    assert(len(shPreimage.hashPrevouts) == 32n, 'invalid length of hashPrevouts');
+    assert(len(shPreimage.spentScriptHash) == 32n, 'invalid length of spentScriptHash');
+    assert(len(shPreimage.spentDataHash) == 32n, 'invalid length of spentDataHash');
+    assert(shPreimage.value >= 0n, 'invalid value of value');
+    assert(len(shPreimage.nSequence) == 4n, 'invalid length of nSequence');
+    assert(len(shPreimage.hashSpentAmounts) == 32n, 'invalid length of hashSpentAmounts');
+    assert(len(shPreimage.hashSpentScriptHashes) == 32n, 'invalid length of hashSpentScriptHashes');
+    assert(len(shPreimage.hashSpentDataHashes) == 32n, 'invalid length of hashSpentDataHashes');
+    assert(len(shPreimage.hashSequences) == 32n, 'invalid length of hashSequences');
+    assert(len(shPreimage.hashOutputs) == 32n, 'invalid length of hashOutputs');
+    assert(shPreimage.inputIndex >= 0n, 'invalid value of inputIndex');
+    assert(shPreimage.nLockTime >= 0n, 'invalid value of nLockTime');
+    assert(shPreimage.sigHashType == 1n
+      || shPreimage.sigHashType == 2n
+      || shPreimage.sigHashType == 3n
+      || shPreimage.sigHashType == 0x81n
+      || shPreimage.sigHashType == 0x82n
+      || shPreimage.sigHashType == 0x83n
+      , 'invalid value of sigHashType');
+
+    const preimage = shPreimage.nVersion
+      + shPreimage.hashPrevouts
+      + shPreimage.spentScriptHash
+      + shPreimage.spentDataHash
+      + TxUtils.satoshisToByteString(shPreimage.value)
+      + shPreimage.nSequence
+      + shPreimage.hashSpentAmounts
+      + shPreimage.hashSpentScriptHashes
+      + shPreimage.hashSpentDataHashes
+      + shPreimage.hashSequences
+      + shPreimage.hashOutputs
+      + StdUtils.toLEUnsigned(shPreimage.inputIndex, 4n)
+      + StdUtils.toLEUnsigned(shPreimage.nLockTime, 4n)
+      + intToByteString(shPreimage.sigHashType, 4n);
+
+    const h: ByteString = hash256(preimage);
+    const sig: Sig = ContextUtils.sign(
+      ContextUtils.fromBEUnsigned(h), 
+      ContextUtils.privKey, 
+      ContextUtils.invK,
+       ContextUtils.r, 
+       ContextUtils.rBigEndian,
+        sigHashType);
+    return sig;
+  }
+
+  @method()
+  static serializeSHPreimage(shPreimage: SHPreimage): SigHashPreimage {
+    assert(len(shPreimage.nVersion) == 4n, 'invalid length of nVersion');
+    assert(len(shPreimage.hashPrevouts) == 32n, 'invalid length of hashPrevouts');
+    assert(len(shPreimage.spentScriptHash) == 32n, 'invalid length of spentScriptHash');
+    assert(len(shPreimage.spentDataHash) == 32n, 'invalid length of spentDataHash');
+    assert(shPreimage.value >= 0n, 'invalid value of value');
+    assert(len(shPreimage.nSequence) == 4n, 'invalid length of nSequence');
+    assert(len(shPreimage.hashSpentAmounts) == 32n, 'invalid length of hashSpentAmounts');
+    assert(len(shPreimage.hashSpentScriptHashes) == 32n, 'invalid length of hashSpentScriptHashes');
+    assert(len(shPreimage.hashSpentDataHashes) == 32n, 'invalid length of hashSpentDataHashes');
+    assert(len(shPreimage.hashSequences) == 32n, 'invalid length of hashSequences');
+    assert(len(shPreimage.hashOutputs) == 32n, 'invalid length of hashOutputs');
+    assert(shPreimage.inputIndex >= 0n, 'invalid value of inputIndex');
+    assert(shPreimage.nLockTime >= 0n, 'invalid value of nLockTime');
+    assert(shPreimage.sigHashType == 1n
+      || shPreimage.sigHashType == 2n
+      || shPreimage.sigHashType == 3n
+      || shPreimage.sigHashType == 0x81n
+      || shPreimage.sigHashType == 0x82n
+      || shPreimage.sigHashType == 0x83n
+      , 'invalid value of sigHashType');
+
+    const preimage = shPreimage.nVersion
+      + shPreimage.hashPrevouts
+      + shPreimage.spentScriptHash
+      + shPreimage.spentDataHash
+      + TxUtils.satoshisToByteString(shPreimage.value)
+      + shPreimage.nSequence
+      + shPreimage.hashSpentAmounts
+      + shPreimage.hashSpentScriptHashes
+      + shPreimage.hashSpentDataHashes
+      + shPreimage.hashSequences
+      + shPreimage.hashOutputs
+      + StdUtils.toLEUnsigned(shPreimage.inputIndex, 4n)
+      + StdUtils.toLEUnsigned(shPreimage.nLockTime, 4n)
+      + intToByteString(shPreimage.sigHashType, 4n);
+    return SigHashPreimage(preimage);
+  }
+
+  /**
+   * Verify that the prevouts context passed in by the user is authentic
+   * @param prevouts prevouts context passed in by the user that need to be verified
+   * @param prevout prevout context passed in by the user that need to be verified
+   * @param t_hashPrevouts hashPrevouts in preimage which is trustable
+   * @param t_inputIndex the index of the input, which is trustable
+   * @returns the number of inputs, which is trustable
+   */
+  @method()
+  static checkPrevouts(
+    prevouts: Prevouts,
+    t_hashPrevouts: ByteString,
+    t_inputIndex: UInt32,
+    t_inputCount: Int32,
+  ): Outpoint {
+    // check prevouts
+    assert(hash256(prevouts) == t_hashPrevouts, 'hashPrevouts mismatch');
+    assert(t_inputIndex < t_inputCount, 'invalid prevouts');
+    assert(t_inputCount == StdUtils.checkLenDivisibleBy(prevouts, 36n), 'invalid prevouts');
+
+    const b = slice(prevouts, t_inputIndex * 36n, (t_inputIndex + 1n) * 36n);
+    return {
+      txHash: slice(b, 0n, 32n),
+      outputIndex: StdUtils.byteStringToUInt32(slice(b, 32n, 36n)),
+    }
+  }
+
+  /**
+   * Check if the spent scripts array passed in matches the shaSpentScripts
+   * @param spentScriptHashes array of spent scripts passed in that need to be verified
+   * @param t_hashSpentScripts the hash of the merged spent scripts, which comes from preimage and is trustable
+   * @param t_inputCount must be trustable, the number of inputs
+   */
+  @method()
+  static checkSpentScripts(
+    spentScriptHashes: SpentScriptHashes,
+    t_hashSpentScripts: ByteString,
+    t_inputCount: bigint,
+  ): void {
+    assert(hash256(spentScriptHashes) == t_hashSpentScripts, 'hashSpentScripts mismatch');
+    assert(t_inputCount == StdUtils.checkLenDivisibleBy(spentScriptHashes, 32n), 'invalid spentScriptHashes');
+  }
+
+  /**
+   * Check if the spent amounts array passed in matches the shaSpentAmounts
+   * @param spentAmounts array of spent amounts passed in that need to be verified
+   * @param t_hashSpentAmounts the hash of the merged spent amounts, which comes from preimage and is trustable
+   * @param t_inputCount must be trustable, the number of inputs
+   */
+  @method()
+  static checkSpentAmounts(
+    spentAmounts: SpentAmounts,
+    t_hashSpentAmounts: ByteString,
+  ): Int32 {
+    assert(hash256(spentAmounts) == t_hashSpentAmounts, 'hashSpentAmounts mismatch');
+    return StdUtils.checkLenDivisibleBy(spentAmounts, 8n);
+  }
+
+  @method()
+  static checkSpentDataHashes(
+    spentDataHashes: SpentDataHashes,
+    t_hashSpentDataHashes: ByteString,
+    t_inputCount: bigint,
+  ): void {
+    assert(hash256(spentDataHashes) == t_hashSpentDataHashes, 'hashSpentDataHashes mismatch');
+    assert(t_inputCount == StdUtils.checkLenDivisibleBy(spentDataHashes, 32n), 'invalid spentDataHashes');
+  }
+
+
+  @method()
+  static getSpentScriptHash(
+    spentScriptHashes: SpentScriptHashes,
+    inputIndex: Int32,
+  ): ByteString {
+    return slice(spentScriptHashes, inputIndex * 32n, (inputIndex + 1n) * 32n);
+  }
+
+  @method()
+  static getSpentAmount(
+    spentAmounts: SpentAmounts,
+    inputIndex: Int32,
+  ): Int32 {
+    return StdUtils.fromLEUnsigned(slice(spentAmounts, inputIndex * 8n, (inputIndex + 1n) * 8n));
+  }
+
+  @method()
+  static getSpentDataHash(
+    spentDataHashes: SpentDataHashes,
+    inputIndex: Int32,
+  ): ByteString {
+    return slice(spentDataHashes, inputIndex * 32n, (inputIndex + 1n) * 32n);
+  }
+  
+}

package/src/smart-contract/builtin-libs/index.ts

@@ -0,0 +1,7 @@
+export { ContextUtils } from './contextUtils.js';
+export { TxUtils } from './txUtils.js';
+export { StateUtils } from './stateUtils.js';
+export { StdUtils } from './stdUtils.js';
+export { Backtrace, type ChainTxVerifyResponse } from './backtrace.js';
+export { StateLib } from './stateLib.js';
+export { TxHashPreimageUtils } from './txHashPreimageUtils.js';

package/src/smart-contract/builtin-libs/p2pk.ts

@@ -0,0 +1,58 @@
+import { method, prop } from "../decorators.js"
+import { assert } from "../fns/assert.js"
+import { PubKey, Sig } from "../types/primitives.js"
+import { SmartContract } from "../smartContract.js"
+
+export class P2PK extends SmartContract {
+    @prop()
+    readonly pubKey: PubKey
+
+    constructor(pubKey: PubKey) {
+        super(...arguments)
+        this.pubKey = pubKey
+    }
+
+    @method()
+    public unlock(sig: Sig) {
+        assert(this.checkSig(sig, this.pubKey), 'signature check failed')
+    }
+}
+
+const desc = {
+    version: 9,
+    compilerVersion: '1.19.0+commit.72eaeba',
+    contract: 'P2PK',
+    md5: '0c046dfb1f1a91cf72b9a852537bdfe1',
+    structs: [],
+    library: [],
+    alias: [],
+    abi: [
+        {
+            type: 'function',
+            name: 'unlock',
+            index: 0,
+            params: [
+                {
+                    name: 'sig',
+                    type: 'Sig',
+                },
+            ],
+        },
+        {
+            type: 'constructor',
+            params: [
+                {
+                    name: 'pubKey',
+                    type: 'PubKey',
+                },
+            ],
+        },
+    ],
+    stateProps: [],
+    buildType: 'release',
+    file: '',
+    hex: '<pubKey>ac',
+    sourceMapFile: '',
+}
+
+P2PK.loadArtifact(desc)

package/src/smart-contract/builtin-libs/p2pkh.ts

@@ -0,0 +1,67 @@
+import { method, prop } from "../decorators.js"
+import { assert } from "../fns/assert.js"
+import { Addr, PubKey, Sig } from "../types/primitives.js"
+import { SmartContract } from "../smartContract.js"
+import { pubKey2Addr } from "../fns/pubKey2Addr.js"
+
+export class P2PKH extends SmartContract {
+    @prop()
+    readonly addr: Addr
+
+    constructor(addr: Addr) {
+        super(...arguments)
+        this.addr = addr
+    }
+
+    @method()
+    public unlock(sig: Sig, pubkey: PubKey) {
+        assert(
+            pubKey2Addr(pubkey) == this.addr,
+            'public key hashes are not equal'
+        )
+        assert(this.checkSig(sig, pubkey), 'signature check failed')
+    }
+}
+
+const desc = {
+    version: 9,
+    compilerVersion: '1.19.0+commit.72eaeba',
+    contract: 'P2PKH',
+    md5: '0c046dfb1f1a91cf72b9a852537bdfe1',
+    structs: [],
+    library: [],
+    alias: [],
+    abi: [
+        {
+            type: 'function',
+            name: 'unlock',
+            index: 0,
+            params: [
+                {
+                    name: 'sig',
+                    type: 'Sig',
+                },
+                {
+                    name: 'pubkey',
+                    type: 'PubKey',
+                },
+            ],
+        },
+        {
+            type: 'constructor',
+            params: [
+                {
+                    name: 'addr',
+                    type: 'Ripemd160',
+                },
+            ],
+        },
+    ],
+    stateProps: [],
+    buildType: 'release',
+    file: '',
+    hex: '76a9<addr>88ac',
+    sourceMapFile: '',
+}
+
+P2PKH.loadArtifact(desc)

package/src/smart-contract/builtin-libs/stateLib.ts

@@ -0,0 +1,82 @@
+import { SmartContractLib } from '../smartContractLib.js';
+import { ByteString, OpcatState, StructObject } from '../types/primitives.js';
+import { ABICoder } from '../abi.js';
+import { deserializeState, serializeState } from '../stateSerializer.js';
+import { getUnRenamedSymbol } from '../abiutils.js';
+import { sha256 } from '../fns/index.js';
+
+/**
+ * Library for computing the hash of a state.
+ * @category Library
+ * @onchain
+ */
+export class StateLib<ST extends OpcatState> extends SmartContractLib {
+  /**
+   * Calculate the hash of the state object
+   * @param state the state object
+   * @returns the hash byte string of the state object
+   * @onchain
+   * @category State
+   */
+  static serializeState<T extends OpcatState>(
+    this: { new (...args: any[]): StateLib<T> },
+    state: T,
+  ): ByteString  {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const libraryClazz = this as any as typeof SmartContractLib;
+    const artifact = libraryClazz.artifact;
+    if (!artifact) {
+      throw new Error(`Artifact is not loaded for the library: ${this.name}`);
+    }
+
+    const abiCoder = new ABICoder(artifact);
+    const library = abiCoder.artifact.library.find(
+      (lib) => getUnRenamedSymbol(lib.name) === getUnRenamedSymbol(this.name),
+    );
+    if (!library) {
+      throw new Error(`Library ${this.name} is not found in the artifact`);
+    }
+    if (!library.stateType) {
+      throw new Error(`State type is not defined for the library: ${this.name}`);
+    }
+
+    return serializeState(artifact, libraryClazz.stateType, state);
+  }
+
+  static deserializeState<T extends OpcatState>(
+    this: { new (...args: any[]): StateLib<T> },
+    serializedState: ByteString,
+  ): T {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const libraryClazz = this as any as typeof SmartContractLib;
+    const artifact = libraryClazz.artifact;
+    if (!artifact) {
+      throw new Error(`Artifact is not loaded for the library: ${this.name}`);
+    }
+
+    const abiCoder = new ABICoder(artifact);
+    const library = abiCoder.artifact.library.find(
+      (lib) => getUnRenamedSymbol(lib.name) === getUnRenamedSymbol(this.name),
+    );
+    if (!library) {
+      throw new Error(`Library ${this.name} is not found in the artifact`);
+    }
+    if (!library.stateType) {
+      throw new Error(`State type is not defined for the library: ${this.name}`);
+    }
+
+    return deserializeState(artifact, libraryClazz.stateType, serializedState);
+  }
+
+  static stateHash<T extends OpcatState>(
+    this: { new (...args: any[]): StateLib<T> },
+    state: T,
+  ): ByteString {
+    return sha256((this as any).serializeState(state));
+  }
+
+  // keep this method to enable the typecheck for stateHash method in ts
+  private _id(_state: ST): ST {
+    return _state;
+  }
+}

package/src/smart-contract/builtin-libs/stateUtils.ts

@@ -0,0 +1,37 @@
+import { assert } from '../fns/assert.js';
+import { method } from '../decorators.js';
+import { slice } from '../fns/byteString.js';
+import { SmartContractLib } from '../smartContractLib.js';
+import { ByteString, Int32, UInt32 } from '../types/primitives.js';
+import { SpentDataHashes } from '../types/structs.js';
+import { TX_OUTPUT_DATA_HASH_LEN } from '../consts.js';
+import { sha256 } from '../fns/hashes.js';
+
+/**
+ * spentDatas library
+ * @category Library
+ * @onchain
+ */
+export class StateUtils extends SmartContractLib {
+  /**
+   * Check if the dataHash of the passed-in raw state matches the spent data hash
+   * @param rawState passed-in raw state after serialization
+   * @param t_spentDataHashes trustable spent data hashes
+   * @param t_inputIndex trustable input index
+   */
+  @method()
+  static checkInputState(
+    t_inputIndex: UInt32,
+    rawState: ByteString,
+    t_spentDataHashes: SpentDataHashes,
+  ): void {
+    assert(
+      slice(
+        t_spentDataHashes, 
+        t_inputIndex * TX_OUTPUT_DATA_HASH_LEN, 
+        (t_inputIndex + 1n) * TX_OUTPUT_DATA_HASH_LEN
+      ) == sha256(rawState), 
+      'dataHash of state mismatch'
+    );
+  }
+}

package/src/smart-contract/builtin-libs/stdUtils.ts

@@ -0,0 +1,156 @@
+import { method } from "../decorators.js";
+import { assert } from "../fns/assert.js";
+import { byteStringToInt, intToByteString, len, slice, toByteString } from "../fns/byteString.js";
+import { SmartContractLib } from "../smartContractLib.js";
+import { ByteString, PrivKey, UInt32, UInt64 } from "../types/primitives.js";
+
+
+export const UINT64_MAX = 0xffffffffffffffffn;
+export const UINT64_MIN = 0n;
+export const UINT32_MAX = 0xffffffffn;
+export const UINT32_MIN = 0n;
+
+type ReadVarintResult = {
+  data: ByteString;
+  nextPos: bigint;
+}
+
+export class StdUtils extends SmartContractLib {
+  @method()
+  static checkLenDivisibleBy(b: ByteString, n: bigint): bigint {
+    const l = len(b);
+    assert(l % n == 0n, 'length of b is not divisible by n');
+    return l / n;
+  }
+
+
+  @method()
+  static uint64ToByteString(n: UInt64): ByteString {
+    assert(n >= UINT64_MIN && n <= UINT64_MAX, 'uint64 out of range');
+    return StdUtils.toLEUnsigned(n, 8n);
+  }
+
+  @method()
+  static uint32ToByteString(n: UInt32): ByteString {
+    assert(n >= UINT32_MIN && n <= UINT32_MAX, 'uint32 out of range');
+    return StdUtils.toLEUnsigned(n, 4n)
+  }
+
+  @method()
+  static byteStringToUInt32(b: ByteString): UInt32 {
+    assert(len(b) == 4n, 'byteStringToUInt32: byteString length is not 4');
+    return StdUtils.fromLEUnsigned(b);
+  }
+
+  /**
+     * convert signed integer `n` to unsigned integer of `l` string, in little endian
+     * @param {bigint} n the number to be converted
+     * @param {bigint} l expected length
+     * @returns {ByteString} returns a `ByteString`
+     */
+  @method()
+  static toLEUnsigned(n: bigint, l: bigint): ByteString {
+    const m = intToByteString(n, l + 1n);
+    // remove sign byte
+    return slice(m, 0n, l);
+  }
+
+  /**
+     * convert `ByteString` to unsigned integer, in sign-magnitude little endian
+     * @param {ByteString} bytes the `ByteString` to be converted
+     * @returns {bigint} returns a number
+     */
+  @method()
+  static fromLEUnsigned(b: ByteString): bigint {
+    return byteStringToInt(b + toByteString('00'));
+  }
+
+  @method()
+  static writeVarInt(n: bigint): ByteString {
+    let b: ByteString = toByteString('');
+    let size = 0n;
+    if (n < 0xfdn) {
+      size = 1n;
+    }
+    else if (n < 0x10000n) {
+      b = toByteString('fd')
+      size = 2n;
+    }
+    else if (n < 0x100000000n) {
+      b = toByteString('fe')
+      size = 4n;
+    }
+    else {
+      b = toByteString('ff')
+      size = 8n;
+    }
+    return b + StdUtils.toLEUnsigned(n, size);
+  }
+
+
+  /**
+     * serializes `ByteString` with `VarInt` encoding
+     * @param buf a `ByteString`
+     * @returns serialized `ByteString`
+     */
+  @method()
+  static pushData(buf: ByteString): ByteString {
+    let n = len(buf);
+
+    let header: ByteString = toByteString('');
+
+    if (n < 0x4c) {
+      header = StdUtils.toLEUnsigned(n, 1n);
+    }
+    else if (n < 0x100) {
+      header = toByteString('4c') + StdUtils.toLEUnsigned(n, 1n);
+    }
+    else if (n < 0x10000) {
+      header = toByteString('4d') + StdUtils.toLEUnsigned(n, 2n);
+    }
+    else if (n < 0x100000000) {
+      header = toByteString('4e') + StdUtils.toLEUnsigned(n, 4n);
+    }
+    else {
+      // shall not reach here
+      assert(false);
+    }
+
+    return header + buf;
+  }
+
+  /**
+     * read [VarInt (variable integer)]{@link https://learnmeabitcoin.com/technical/general/compact-size/}-encoded data from the beginning of 'buf'
+     * @param {ByteString} buf a buffer `ByteString` of format: [prefix FD/FE/FF +] length + data
+     * @returns return data
+     */
+  @method()
+  static readVarint(buf: ByteString, pos: bigint): ReadVarintResult {
+    let l: bigint = 0n;
+    let ret: ByteString = toByteString('');
+    let nextPos: bigint = pos;
+    const header: ByteString = slice(buf, pos, pos + 1n);
+
+    if (header == toByteString('fd')) {
+      l = StdUtils.fromLEUnsigned(slice(buf, pos + 1n, pos + 3n));
+      ret = slice(buf, 3n, 3n + l);
+      nextPos = pos + 3n + l;
+    }
+    else if (header == toByteString('fe')) {
+      l = StdUtils.fromLEUnsigned(slice(buf, pos + 1n, pos + 5n));
+      ret = slice(buf, pos + 5n, pos + 5n + l);
+      nextPos = pos + 5n + l;
+    }
+    else if (header == toByteString('ff')) {
+      l = StdUtils.fromLEUnsigned(slice(buf, pos + 1n, pos + 9n));
+      ret = slice(buf, pos + 9n, pos + 9n + l);
+      nextPos = pos + 9n + l;
+    } else {
+      l = StdUtils.fromLEUnsigned(slice(buf, pos, pos + 1n));
+      ret = slice(buf, pos + 1n, pos + 1n + l);
+      nextPos = pos + 1n + l;
+    }
+
+    return { data: ret, nextPos: nextPos };
+  }
+}