dxs-stas-sdk 1.0.0

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  transform: { "^.+\\.ts?$": "ts-jest" },
+  testEnvironment: "node",
+  testRegex: "/tests/.*\\.(test|spec)?\\.(ts|tsx)$",
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "dxs-stas-sdk",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dxs.stas.sdk.ts",
+  "scripts": {
+    "test": "jest",
+    "start": "tsnd ./src/index.ts",
+    "publish": "rollup -c rollup.config.ts -w --configPlugin typescript"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "author": "oleg@dxs.app",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/jest": "^29.2.5",
+    "@types/typedarray-to-buffer": "^4.0.0",
+    "jest": "^29.3.1",
+    "rollup": "^3.10.0",
+    "ts-jest": "^29.0.5",
+    "ts-node-dev": "^2.0.0",
+    "tslib": "^2.4.1",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.2.0",
+    "@noble/secp256k1": "^1.7.1",
+    "@scure/base": "^1.1.1",
+    "@scure/bip32": "^1.1.5",
+    "@scure/bip39": "^1.1.1",
+    "buffer": "^6.0.3",
+    "typedarray-to-buffer": "^4.0.0"
+  }
+}

package/rollup.config.ts

@@ -0,0 +1,26 @@
+import resolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import typescript from "@rollup/plugin-typescript";
+
+export default {
+  input: `src/index.ts`,
+  output: [
+    {
+      file: "./dist/dxs.stas.sdk.js",
+      format: "cjs",
+      treeshake: true,
+      sourcemap: true,
+    },
+  ],
+  watch: {
+    include: "src/**",
+  },
+  plugins: [
+    commonjs(),
+    typescript(),
+    resolve({
+      preferBuiltins: true,
+      extensions: [".mjs", ".js", ".json", ".node", ".ts"],
+    }),
+  ],
+};

package/src/base.ts

@@ -0,0 +1,4 @@
+import { sha256 } from "@noble/hashes/sha256";
+import { base58check } from "@scure/base";
+
+export const bs58check = base58check(sha256);

package/src/bitcoin/address.ts

@@ -0,0 +1,42 @@
+import { bs58check } from "../base";
+import { toBuffer } from "../buffer/buffer-utils";
+import { hash160 } from "../hashes";
+import { Network, Networks } from "./network";
+
+export class Address {
+  Value: string;
+  Hash160: Buffer;
+  Network: Network = Networks.Mainnet;
+
+  /*
+  Only p2pkh and mainnet supports now
+  */
+  constructor(hash160: Buffer) {
+    if (hash160.length !== 20) throw new Error("Invalid hash160");
+
+    const buffer = Buffer.allocUnsafe(21);
+
+    buffer.writeUInt8(this.Network.pubKeyHash, 0);
+    hash160.copy(buffer, 1);
+
+    this.Value = bs58check.encode(buffer);
+    this.Hash160 = hash160;
+  }
+
+  static fromBase58 = (address: string) => {
+    const buffer = toBuffer(bs58check.decode(address));
+
+    if (buffer[0] !== Networks.Mainnet.pubKeyHash)
+      throw new Error("Only mainnet supported");
+
+    const hash160 = Buffer.allocUnsafe(20);
+    buffer.copy(hash160, 0, 1);
+
+    return new Address(hash160);
+  };
+
+  static fromPublicKey = (publicKey: Buffer) => new Address(hash160(publicKey));
+
+  static fromHash160Hex = (hash160: string) =>
+    new Address(Buffer.from(hash160, "hex"));
+}

package/src/bitcoin/destination.ts

@@ -0,0 +1,7 @@
+import { Address } from "./address";
+
+export type TDestination = {
+  Address: Address;
+  Satoshis: number;
+  Data?: Buffer[];
+};

package/src/bitcoin/index.ts

@@ -0,0 +1,15 @@
+export * from "./address";
+export * from "./destination";
+export * from "./mnemonic";
+export * from "./network";
+export * from "./op-codes";
+export * from "./out-point";
+export * from "./payment";
+export * from "./private-key";
+export * from "./script-type";
+export * from "./sig-hash-type";
+export * from "./token-scheme";
+export * from "./transaction-input";
+export * from "./transaction-output";
+export * from "./transaction";
+export * from "./wallet";

package/src/bitcoin/mnemonic.ts

@@ -0,0 +1,40 @@
+import { generateMnemonic, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english";
+
+export { wordlist } from "@scure/bip39/wordlists/english";
+
+export type TWords = { [idxs: string]: string };
+
+export class Mnemonic {
+  constructor(public phrase: string, public words: TWords) {}
+
+  public static generate = (): Mnemonic =>
+    Mnemonic.fromPhrase(generateMnemonic(wordlist, 128));
+
+  public static fromWords = (words: TWords): Mnemonic => {
+    var phrase = Object.values(words).join(" ");
+
+    return new Mnemonic(phrase, words);
+  };
+
+  public static fromPhrase = (phrase: string): Mnemonic => {
+    var words = phrase.split(" ").reduce<TWords>((a, v, i) => {
+      a[`${i}`] = v;
+
+      return a;
+    }, {});
+
+    return new Mnemonic(phrase, words);
+  };
+
+  public static fromRandomText = (text: string): Mnemonic | undefined => {
+    const sanitized = text
+      .replace(/\r?\n|\r/g, " ")
+      .replace(/\s{2,}/g, " ")
+      .replace(/^\s+/, "")
+      .replace(/\s+$/, "");
+
+    if (validateMnemonic(sanitized, wordlist))
+      return Mnemonic.fromPhrase(sanitized);
+  };
+}

package/src/bitcoin/network.ts

@@ -0,0 +1,11 @@
+export type Network = {
+  pubKeyHash: number;
+  wif: number;
+};
+
+export const Networks: { [name: string]: Network } = {
+  Mainnet: {
+    pubKeyHash: 0x00,
+    wif: 0x80,
+  },
+};

package/src/bitcoin/op-codes.ts

@@ -0,0 +1,143 @@
+export enum OpCode {
+  // push value
+  OP_0 = 0x00,
+  OP_PUSHDATA1 = 0x4c,
+  OP_PUSHDATA2 = 0x4d,
+  OP_PUSHDATA4 = 0x4e,
+  OP_1NEGATE = 0x4f,
+  OP_RESERVED = 0x50,
+  OP_TRUE = 0x51,
+  OP_1 = 0x51,
+  OP_2 = 0x52,
+  OP_3 = 0x53,
+  OP_4 = 0x54,
+  OP_5 = 0x55,
+  OP_6 = 0x56,
+  OP_7 = 0x57,
+  OP_8 = 0x58,
+  OP_9 = 0x59,
+  OP_10 = 0x5a,
+  OP_11 = 0x5b,
+  OP_12 = 0x5c,
+  OP_13 = 0x5d,
+  OP_14 = 0x5e,
+  OP_15 = 0x5f,
+  OP_16 = 0x60,
+
+  // control
+  OP_NOP = 0x61,
+  OP_VER = 0x62,
+  OP_IF = 0x63,
+  OP_NOTIF = 0x64,
+  OP_VERIF = 0x65,
+  OP_VERNOTIF = 0x66,
+  OP_ELSE = 0x67,
+  OP_ENDIF = 0x68,
+  OP_VERIFY = 0x69,
+  OP_RETURN = 0x6a,
+
+  // stack ops
+  OP_TOALTSTACK = 0x6b,
+  OP_FROMALTSTACK = 0x6c,
+  OP_2DROP = 0x6d,
+  OP_2DUP = 0x6e,
+  OP_3DUP = 0x6f,
+  OP_2OVER = 0x70,
+  OP_2ROT = 0x71,
+  OP_2SWAP = 0x72,
+  OP_IFDUP = 0x73,
+  OP_DEPTH = 0x74,
+  OP_DROP = 0x75,
+  OP_DUP = 0x76,
+  OP_NIP = 0x77,
+  OP_OVER = 0x78,
+  OP_PICK = 0x79,
+  OP_ROLL = 0x7a,
+  OP_ROT = 0x7b,
+  OP_SWAP = 0x7c,
+  OP_TUCK = 0x7d,
+
+  // data manipulation ops
+  OP_CAT = 0x7e,
+  OP_SPLIT = 0x7f,
+  OP_NUM2BIN = 0x80,
+  OP_BIN2NUM = 0x81,
+  OP_SIZE = 0x82,
+
+  // bit logic
+  OP_INVERT = 0x83,
+  OP_AND = 0x84,
+  OP_OR = 0x85,
+  OP_XOR = 0x86,
+  OP_EQUAL = 0x87,
+  OP_EQUALVERIFY = 0x88,
+  OP_RESERVED1 = 0x89,
+  OP_RESERVED2 = 0x8a,
+
+  // numeric
+  OP_1ADD = 0x8b,
+  OP_1SUB = 0x8c,
+  OP_2MUL = 0x8d,
+  OP_2DIV = 0x8e,
+  OP_NEGATE = 0x8f,
+  OP_ABS = 0x90,
+  OP_NOT = 0x91,
+  OP_0NOTEQUAL = 0x92,
+
+  OP_ADD = 0x93,
+  OP_SUB = 0x94,
+  OP_MUL = 0x95,
+  OP_DIV = 0x96,
+  OP_MOD = 0x97,
+  OP_LSHIFT = 0x98,
+  OP_RSHIFT = 0x99,
+
+  OP_BOOLAND = 0x9a,
+  OP_BOOLOR = 0x9b,
+  OP_NUMEQUAL = 0x9c,
+  OP_NUMEQUALVERIFY = 0x9d,
+  OP_NUMNOTEQUAL = 0x9e,
+  OP_LESSTHAN = 0x9f,
+  OP_GREATERTHAN = 0xa0,
+  OP_LESSTHANOREQUAL = 0xa1,
+  OP_GREATERTHANOREQUAL = 0xa2,
+  OP_MIN = 0xa3,
+  OP_MAX = 0xa4,
+
+  OP_WITHIN = 0xa5,
+
+  // crypto
+  OP_RIPEMD160 = 0xa6,
+  OP_SHA1 = 0xa7,
+  OP_SHA256 = 0xa8,
+  OP_HASH160 = 0xa9,
+  OP_HASH256 = 0xaa,
+  OP_CODESEPARATOR = 0xab,
+  OP_CHECKSIG = 0xac,
+  OP_CHECKSIGVERIFY = 0xad,
+  OP_CHECKMULTISIG = 0xae,
+  OP_CHECKMULTISIGVERIFY = 0xaf,
+
+  // expansion
+  OP_NOP1 = 0xb0,
+  OP_NOP2 = 0xb1,
+  OP_CHECKLOCKTIMEVERIFY = 0xb1,
+  OP_NOP3 = 0xb2,
+  OP_CHECKSEQUENCEVERIFY = 0xb2,
+  OP_NOP4 = 0xb3,
+  OP_NOP5 = 0xb4,
+  OP_NOP6 = 0xb5,
+  OP_NOP7 = 0xb6,
+  OP_NOP8 = 0xb7,
+  OP_NOP9 = 0xb8,
+  OP_NOP10 = 0xb9,
+
+  // template matching params
+  OP_SMALLDATA = 0xf9,
+  OP_SMALLINTEGER = 0xfa,
+  OP_PUBKEYS = 0xfb,
+  OP_PUBKEYHASH = 0xfd,
+  OP_PUBKEY = 0xfe,
+
+  OP_INVALIDOPCODE = 0xff,
+}

package/src/bitcoin/out-point.ts

@@ -0,0 +1,61 @@
+import { TransactionReader } from "../transaction";
+import { Address } from "./address";
+import { ScriptType } from "./script-type";
+import { Transaction } from "./transaction";
+
+export class OutPoint {
+  TxId: string;
+  Vout: number;
+  LockignScript: Buffer;
+  Satoshis: number;
+  Address: Address;
+  ScriptType: ScriptType;
+  Transaction?: Transaction;
+
+  constructor(
+    txId: string,
+    vout: number,
+    lockignScript: Buffer,
+    satoshis: number,
+    address: Address,
+    scriptType: ScriptType
+  ) {
+    this.TxId = txId;
+    this.Vout = vout;
+    this.LockignScript = lockignScript;
+    this.Satoshis = satoshis;
+    this.Address = address;
+    this.ScriptType = scriptType;
+  }
+
+  static fromTransaction = (transaction: Transaction, vout: number) =>
+    new OutPointFull(transaction, vout);
+
+  static fromHex = (hex: string, vout: number) =>
+    new OutPointFull(TransactionReader.readHex(hex), vout);
+
+  toString = () => `${this.TxId}:${this.Vout}`;
+}
+
+export class OutPointFull extends OutPoint {
+  constructor(transaction: Transaction, vout: number) {
+    const output = transaction.Outputs[vout];
+
+    if (
+      output.ScriptType !== ScriptType.p2pkh &&
+      output.ScriptType !== ScriptType.p2stas
+    )
+      throw new Error("p2pkh or p2stat output must be provided");
+
+    super(
+      transaction.Id,
+      vout,
+      output.LockignScript,
+      output.Satoshis,
+      output.Address!,
+      output.ScriptType
+    );
+
+    this.Transaction = transaction;
+  }
+}

package/src/bitcoin/payment.ts

@@ -0,0 +1,8 @@
+import { OutPoint } from "./out-point";
+import { PrivateKey } from "./private-key";
+import { Wallet } from "./wallet";
+
+export type TPayment = {
+  OutPoint: OutPoint;
+  Owner: PrivateKey | Wallet;
+};

package/src/bitcoin/private-key.ts

@@ -0,0 +1,57 @@
+import {
+  getPublicKey,
+  Signature,
+  signSync,
+  utils,
+  verify,
+} from "@noble/secp256k1";
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha256";
+import { getChunkSize, toBuffer } from "../buffer/buffer-utils";
+import { Address } from "./address";
+import { BufferWriter } from "../buffer";
+import { hash256 } from "../hashes";
+
+export { verify } from "@noble/secp256k1";
+
+utils.hmacSha256Sync = (key, ...msgs) =>
+  hmac(sha256, key, utils.concatBytes(...msgs));
+
+utils.sha256Sync = (...msgs) => sha256(utils.concatBytes(...msgs));
+
+export class PrivateKey {
+  private _pk: Buffer;
+
+  Address: Address;
+  PublicKey: Buffer;
+
+  constructor(pk: Buffer) {
+    this._pk = pk;
+    this.PublicKey = toBuffer(getPublicKey(this._pk, true));
+    this.Address = Address.fromPublicKey(toBuffer(this.PublicKey));
+  }
+
+  sign = (message: Uint8Array) =>
+    toBuffer(signSync(message, this._pk, { der: true }));
+
+  verify = (signature: Buffer, message: Buffer) =>
+    verify(signature, message, this.PublicKey);
+}
+
+export const verifyBitcoinSignedMessage = (
+  message: Buffer,
+  publicKey: Buffer,
+  signature: Buffer
+) => {
+  const prefix = Buffer.from("Bitcoin Signed Message:\n");
+  const writer = BufferWriter.fromSize(
+    getChunkSize(prefix) + getChunkSize(message)
+  );
+
+  writer.writeVarChunk(prefix);
+  writer.writeVarChunk(message);
+
+  const sig = Signature.fromCompact(signature);
+
+  return verify(sig, hash256(writer.buffer), publicKey);
+};

package/src/bitcoin/script-type.ts

@@ -0,0 +1,9 @@
+export enum ScriptType {
+  unknown = 0,
+  p2pk = 1,
+  p2pkh = 2,
+  p2sh = 3,
+  p2ms = 4,
+  nullData = 5,
+  p2stas = 6,
+}

package/src/bitcoin/sig-hash-type.ts

@@ -0,0 +1,7 @@
+export enum SignatureHashType {
+  SIGHASH_ALL = 0x01,
+  SIGHASH_NONE = 0x02,
+  SIGHASH_SINGLE = 0x03,
+  SIGHASH_FORKID = 0x40,
+  SIGHASH_ANYONECANPAY = 0x80,
+}

package/src/bitcoin/token-scheme.ts

@@ -0,0 +1,28 @@
+export class TokenScheme {
+  Name: string;
+  TokenId: string;
+  Symbol: string;
+  SatoshisPerToken: number;
+
+  constructor(
+    name: string,
+    tokenId: string,
+    symbol: string,
+    satoshisPerToken: number
+  ) {
+    this.Name = name;
+    this.TokenId = tokenId;
+    this.Symbol = symbol;
+    this.SatoshisPerToken = satoshisPerToken;
+  }
+
+  toJson = () =>
+    JSON.stringify({
+      name: this.Name,
+      tokenId: this.TokenId,
+      symbol: this.Symbol,
+      satoshisPerToken: this.SatoshisPerToken,
+    });
+
+  toBuffer = () => Buffer.from(this.toJson(), "utf8");
+}

package/src/bitcoin/transaction-input.ts

@@ -0,0 +1,33 @@
+import { ScriptReader } from "../script/read/script-reader";
+import { Address } from "./address";
+
+export class TransactionInput {
+  TxId: string;
+  Vout: number;
+  UnlockingScript: Buffer;
+  Sequence: number;
+
+  constructor(
+    txId: string,
+    vout: number,
+    unlockingScript: Buffer,
+    sequence: number
+  ) {
+    this.TxId = txId;
+    this.Vout = vout;
+    this.UnlockingScript = unlockingScript;
+    this.Sequence = sequence;
+  }
+
+  tryGetAddress = () => {
+    const scriptTokens = ScriptReader.read(this.UnlockingScript);
+    const lastToken = scriptTokens[scriptTokens.length - 1];
+
+    if (
+      lastToken.DataLength === 33 &&
+      (lastToken.Data![0] === 2 || lastToken.Data![0] === 3)
+    ) {
+      return Address.fromPublicKey(lastToken.Data!);
+    }
+  };
+}

package/src/bitcoin/transaction-output.ts

@@ -0,0 +1,105 @@
+import { ScriptReader } from "../script/read/script-reader";
+import { p2phkTokens, getP2stasTokens } from "../script/script-samples";
+import { ScriptToken } from "../script/script-token";
+import { Address } from "./address";
+import { OpCode } from "./op-codes";
+import { ScriptType } from "./script-type";
+
+export class TransactionOutput {
+  Satoshis: number;
+  LockignScript: Buffer;
+  ScriptType: ScriptType = ScriptType.unknown;
+  Address?: Address;
+  TokenId?: string;
+  Symbol?: string;
+  data: Buffer[] = [];
+
+  constructor(satoshis: number, lockignScript: Buffer) {
+    this.Satoshis = satoshis;
+    this.LockignScript = lockignScript;
+
+    const scriptTokens = ScriptReader.read(this.LockignScript);
+
+    if (!this._isNulData(scriptTokens)) {
+      if (!this._isP2pkh(scriptTokens)) {
+        this._isP2stas(scriptTokens);
+      }
+    }
+  }
+
+  private _isNulData = (scriptTokens: ScriptToken[]): boolean => {
+    if (
+      scriptTokens.length > 2 &&
+      scriptTokens[0].OpCodeNum === OpCode.OP_0 &&
+      scriptTokens[1].OpCodeNum === OpCode.OP_RETURN
+    ) {
+      for (let i = 2; i < scriptTokens.length; i++)
+        this.data.push(scriptTokens[i].Data!);
+
+      this.ScriptType = ScriptType.nullData;
+
+      return true;
+    }
+
+    return false;
+  };
+
+  private _isP2pkh = (scriptTokens: ScriptToken[]): boolean => {
+    if (scriptTokens.length > p2phkTokens.length) return false;
+
+    let opReturnReached = false;
+
+    for (let i = 0; i < scriptTokens.length; i++) {
+      const token = scriptTokens[i];
+
+      if (!opReturnReached) {
+        if (token.OpCodeNum === OpCode.OP_RETURN) {
+          opReturnReached = true;
+        } else {
+          if (token.OpCodeNum !== p2phkTokens[i].OpCodeNum) return false;
+
+          if (p2phkTokens[i].IsReceiverId)
+            this.Address = new Address(token.Data!);
+        }
+      } else {
+        this.data.push(token.Data!);
+      }
+    }
+
+    this.ScriptType = ScriptType.p2pkh;
+
+    return true;
+  };
+
+  private _isP2stas = (scriptTokens: ScriptToken[]): boolean => {
+    const p2stasTokens = getP2stasTokens();
+
+    if (scriptTokens.length < p2stasTokens.length) return false;
+
+    let opReturnIdx = -1;
+
+    for (let i = 0; i < scriptTokens.length; i++) {
+      const token = scriptTokens[i];
+
+      if (opReturnIdx === -1) {
+        if (token.OpCodeNum === OpCode.OP_RETURN) {
+          opReturnIdx = i;
+        } else {
+          if (token.OpCodeNum !== p2stasTokens[i].OpCodeNum) return false;
+
+          if (p2stasTokens[i].IsReceiverId)
+            this.Address = new Address(token.Data!);
+        }
+      } else {
+        if (i === opReturnIdx + 1) this.TokenId = token.Data!.toString("hex");
+        else if (i === opReturnIdx + 2)
+          this.Symbol = token.Data!.toString("utf8");
+        else this.data.push(token.Data!);
+      }
+    }
+
+    this.ScriptType = ScriptType.p2stas;
+
+    return true;
+  };
+}

package/src/bitcoin/transaction.ts

@@ -0,0 +1,31 @@
+import { reverseBuffer } from "../buffer/buffer-utils";
+import { hash256 } from "../hashes";
+import { TransactionInput } from "./transaction-input";
+import { TransactionOutput } from "./transaction-output";
+
+export class Transaction {
+  Inputs: TransactionInput[];
+  Outputs: TransactionOutput[];
+  Version: number;
+  LockTime: number;
+  Raw: Buffer;
+  Hex: string;
+  Id: string;
+
+  constructor(
+    raw: Buffer,
+    inputs: TransactionInput[],
+    outputs: TransactionOutput[],
+    version: number,
+    lockTime: number
+  ) {
+    this.Inputs = inputs;
+    this.Outputs = outputs;
+    this.Version = version;
+    this.LockTime = lockTime;
+
+    this.Raw = raw;
+    this.Hex = raw.toString("hex");
+    this.Id = reverseBuffer(hash256(raw)).toString("hex");
+  }
+}