dxs-stas-sdk 1.0.0

package/src/bitcoin/wallet.ts

@@ -0,0 +1,59 @@
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { toBuffer } from "../buffer/buffer-utils";
+import { HDKey, Versions } from "@scure/bip32";
+import { PrivateKey } from "./private-key";
+
+interface WalletOpt {
+  versions: Versions;
+  depth?: number;
+  index?: number;
+  parentFingerprint?: number;
+  chainCode: Uint8Array;
+  privateKey?: Uint8Array | bigint;
+}
+
+export class Wallet extends HDKey {
+  static fromMnemonic = (mnemonic: string) => {
+    const seed = mnemonicToSeedSync(mnemonic);
+    return Wallet.fromHdKey(Wallet.fromMasterSeed(seed));
+  };
+
+  static fromHdKey = ({
+    versions,
+    depth,
+    index,
+    parentFingerprint,
+    chainCode,
+    privateKey,
+  }: HDKey) =>
+    new Wallet({
+      versions,
+      depth,
+      index,
+      parentFingerprint,
+      chainCode: chainCode!,
+      privateKey: privateKey!,
+    });
+
+  private _pk: PrivateKey;
+
+  constructor(opt: WalletOpt) {
+    super(opt);
+
+    this._pk = new PrivateKey(toBuffer(this.privateKey!));
+  }
+
+  get Address() {
+    return this._pk.Address;
+  }
+
+  get PublicKey() {
+    return this._pk.PublicKey;
+  }
+
+  derive(path: string): Wallet {
+    return Wallet.fromHdKey(super.derive(path));
+  }
+
+  sign = (message: Uint8Array) => this._pk.sign(message);
+}

package/src/buffer/buffer-reader.ts

@@ -0,0 +1,88 @@
+import { ensureUInt, slice } from "./buffer-utils";
+
+export class BufferReader {
+  buffer: Buffer;
+  offset: number;
+
+  constructor(buffer: Buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+  }
+
+  readUInt8() {
+    const result = this.buffer.readUInt8(this.offset);
+    this.offset++;
+
+    return result;
+  }
+
+  readUInt16() {
+    const result = this.buffer.readUInt16LE(this.offset);
+    this.offset += 2;
+
+    return result;
+  }
+
+  readInt32() {
+    const result = this.buffer.readInt32LE(this.offset);
+    this.offset += 4;
+
+    return result;
+  }
+
+  readUInt32() {
+    const result = this.buffer.readUInt32LE(this.offset);
+    this.offset += 4;
+
+    return result;
+  }
+
+  readUInt64() {
+    const a = this.buffer.readUInt32LE(this.offset);
+    let b = this.buffer.readUInt32LE(this.offset + 4);
+    b *= 0x100000000;
+
+    const result = b + a;
+    ensureUInt(result, 0x001fffffffffffff);
+
+    this.offset += 8;
+
+    return result;
+  }
+
+  readVarInt() {
+    var first = this.readUInt8();
+
+    // 8 bit
+    if (first < 0xfd) {
+      return first;
+    }
+
+    // 16 bit
+    if (first === 0xfd) {
+      return this.readUInt16();
+    }
+
+    // 32 bit
+    if (first === 0xfe) {
+      return this.readUInt32();
+    }
+
+    // 64 bit
+    return this.readUInt64();
+  }
+
+  readChunk(n: number) {
+    if (this.buffer.length < this.offset + n) {
+      throw new Error("Cannot read chunk out of bounds");
+    }
+    const result = slice(this.buffer, this.offset, this.offset + n);
+    this.offset += n;
+
+    return result;
+  }
+
+  readVarChunk() {
+    return this.readChunk(this.readVarInt());
+  }
+}

package/src/buffer/buffer-utils.ts

@@ -0,0 +1,116 @@
+import toBufferExternal from "typedarray-to-buffer";
+import { OpCode } from "../bitcoin/op-codes";
+
+export const OP_INT_BASE = OpCode.OP_RESERVED;
+
+export const asMinimalOP = (buffer: Buffer) => {
+  if (buffer.length === 0) return OpCode.OP_0;
+  if (buffer.length !== 1) return;
+  if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
+  if (buffer[0] === 0x81) return OpCode.OP_1NEGATE;
+};
+
+export const ensureUInt = (value: number, max: number) => {
+  if (value < 0)
+    throw new Error("specified a negative value for writing an unsigned value");
+
+  if (value > max) throw new Error("RangeError: value out of range");
+
+  if (Math.floor(value) !== value)
+    throw new Error(`value has a fractional component: ${value}`);
+};
+
+export const toBuffer = toBufferExternal;
+
+export const toUtf8Buffer = (value: string) => Buffer.from(value, "utf8");
+export const toHexBuffer = (value: string) => Buffer.from(value, "hex");
+
+export const slice = (buffer: Buffer, offset: number, length: number) =>
+  toBuffer(Uint8Array.prototype.slice.call(buffer, offset, length));
+
+export const reverseBuffer = (buffer: Buffer) => {
+  let j = buffer.length - 1;
+  let tmp = 0;
+
+  for (let i = 0; i < buffer.length / 2; i++) {
+    tmp = buffer[i];
+    buffer[i] = buffer[j];
+    buffer[j] = tmp;
+    j--;
+  }
+
+  return buffer;
+};
+
+export const cloneBuffer = (
+  source: Buffer,
+  targetStart: number = 0,
+  sourceStart?: number | undefined,
+  sourceEnd?: number | undefined
+) => {
+  sourceStart = sourceStart ?? 0;
+  sourceEnd = sourceEnd ?? source.length;
+
+  const clone = Buffer.allocUnsafe(sourceEnd - sourceStart);
+  source.copy(clone, targetStart, sourceStart, sourceEnd);
+
+  return clone;
+};
+
+export const splitBuffer = (source: Buffer, splitBy: Buffer): Buffer[] => {
+  let search = -1;
+  let move = 0;
+  const segments: Buffer[] = [];
+
+  while ((search = source.indexOf(splitBy)) > -1) {
+    const segment = slice(source, 0, search + move);
+    if (segment.length > 0) segments.push(segment);
+
+    source = slice(source, search + splitBy.length, source.length);
+  }
+
+  if (source.length > 0) segments.push(source);
+
+  return segments;
+};
+
+export const getVarIntLength = (value: number): number =>
+  value < 0xfd ? 1 : value <= 0xffff ? 3 : value <= 0xffffffff ? 5 : 9;
+
+export const getNumberSize = (data: number): number =>
+  data > 0 && data <= 16
+    ? 1
+    : getVarIntLength(getMinimumRequiredByte(data)) +
+      getMinimumRequiredByte(data);
+
+export const getMinimumRequiredByte = (value: number): number =>
+  value >= -128 && value <= 127
+    ? 1
+    : value >= -32768 && value <= 32767
+    ? 2
+    : value >= -8388608 && value <= 8388607
+    ? 3
+    : value >= -2147483648 && value <= 2147483647
+    ? 4
+    : value >= -549755813888 && value <= 549755813887
+    ? 5
+    : value >= -140737488355328 && value <= 140737488355327
+    ? 6
+    : value >= -36028797018963968 && value <= 36028797018963967 // TODO it's a bug  MAX_SAFE_INTEGER = 9007199254740991
+    ? 7
+    : 8;
+
+export const getNumberBuffer = (value: number): Buffer => {
+  const size = getMinimumRequiredByte(value);
+  const buffer = Buffer.alloc(size);
+
+  buffer.writeIntLE(value, 0, size);
+
+  return buffer;
+};
+
+export const estimateChunkSize = (bufferSize: number) =>
+  getVarIntLength(bufferSize) + bufferSize;
+
+export const getChunkSize = (buffer: Buffer) =>
+  estimateChunkSize(buffer.length);

package/src/buffer/buffer-writer.ts

@@ -0,0 +1,74 @@
+import { ensureUInt } from "./buffer-utils";
+
+export class BufferWriter {
+  buffer: Buffer;
+  offset: number;
+
+  constructor(buffer: Buffer, offset = 0) {
+    this.buffer = buffer;
+    this.offset = offset;
+  }
+
+  static fromSize = (size: number) =>
+    new BufferWriter(Buffer.allocUnsafe(size));
+
+  writeUInt8(value: number) {
+    this.offset = this.buffer.writeUInt8(value, this.offset);
+  }
+
+  writeUInt16(value: number) {
+    this.offset = this.buffer.writeUInt16LE(value, this.offset);
+  }
+
+  writeUInt32(value: number) {
+    this.offset = this.buffer.writeUInt32LE(value, this.offset);
+  }
+
+  writeUInt64(value: number) {
+    ensureUInt(value, 0x001fffffffffffff);
+
+    this.buffer.writeInt32LE(value & -1, this.offset);
+    this.buffer.writeUInt32LE(Math.floor(value / 0x100000000), this.offset + 4);
+    this.offset += 8;
+  }
+
+  writeVarInt(value: number) {
+    // 8 bit
+    if (value <= 0xfc) {
+      this.writeUInt8(value);
+
+      // 16 bit
+    } else if (value <= 0xffff) {
+      this.writeUInt8(0xfd);
+      this.writeUInt16(value);
+
+      // 32 bit
+    } else if (value <= 0xffffffff) {
+      this.writeUInt8(0xfe);
+      this.writeUInt32(value);
+
+      // 64 bit
+    } else {
+      this.writeUInt8(0xff);
+      this.writeUInt64(value);
+    }
+  }
+
+  writeChunk(chunk: Buffer) {
+    if (this.buffer.length < this.offset + chunk.length)
+      throw new Error(
+        `Cannot writte chunk out of bounds; total size: ${
+          this.buffer.length
+        }; position: ${this.offset}; excess: ${
+          this.offset + chunk.length - this.buffer.length
+        }`
+      );
+
+    this.offset += chunk.copy(this.buffer, this.offset);
+  }
+
+  writeVarChunk(chunk: Buffer) {
+    this.writeVarInt(chunk.length);
+    this.writeChunk(chunk);
+  }
+}

package/src/buffer/index.ts

@@ -0,0 +1,3 @@
+export * from "./buffer-reader";
+export * from "./buffer-utils";
+export * from "./buffer-writer";

package/src/hashes.ts

@@ -0,0 +1,13 @@
+import { sha256 as nobleHash256 } from "@noble/hashes/sha256";
+import { ripemd160 as nobleRipemd160 } from "@noble/hashes/ripemd160";
+import { toBuffer } from "./buffer/buffer-utils";
+
+export const sha256 = (message: Buffer): Buffer =>
+  toBuffer(nobleHash256(message));
+
+export const ripemd160 = (message: Buffer): Buffer =>
+  toBuffer(nobleRipemd160(message));
+
+export const hash160 = (buffer: Buffer) => ripemd160(sha256(buffer));
+
+export const hash256 = (buffer: Buffer) => sha256(sha256(buffer));

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from "./bitcoin";
+export * from "./buffer";
+export * from "./script";
+export * from "./stas-bundle-factory";
+export * from "./transaction";
+export * from "./transaction-factory";
+export * from "./base";
+export * from "./hashes";

package/src/script/build/null-data-builder.ts

@@ -0,0 +1,21 @@
+import { OpCode } from "../../bitcoin/op-codes";
+import { ScriptType } from "../../bitcoin/script-type";
+import { nullDataTokens } from "../script-samples";
+import { ScriptToken } from "../script-token";
+import { ScriptBuilder } from "./script-builder";
+
+export class NullDataBuilder extends ScriptBuilder {
+  constructor(data: Buffer[]) {
+    super(ScriptType.nullData);
+
+    for (var token of nullDataTokens) {
+      this._tokens.push(ScriptToken.fromScriptToken(token));
+    }
+
+    this.addOpCode(OpCode.OP_RETURN);
+
+    for (var segment of data) {
+      this.addData(segment);
+    }
+  }
+}

package/src/script/build/p2pkh-builder.ts

@@ -0,0 +1,34 @@
+import { Address } from "../../bitcoin/address";
+import { OpCode } from "../../bitcoin/op-codes";
+import { ScriptType } from "../../bitcoin/script-type";
+import { p2phkTokens } from "../script-samples";
+import { ScriptToken } from "../script-token";
+import { ScriptBuilder } from "./script-builder";
+
+export class P2pkhBuilder extends ScriptBuilder {
+  private _isOpReturnAdded: boolean = false;
+
+  constructor(address: Address) {
+    super(ScriptType.p2pkh, address);
+
+    for (var token of p2phkTokens) {
+      if (token.IsReceiverId) {
+        const receiver = ScriptToken.fromBuffer(address.Hash160);
+        receiver.IsReceiverId = true;
+
+        this._tokens.push(receiver);
+      } else {
+        this._tokens.push(ScriptToken.fromScriptToken(token));
+      }
+    }
+  }
+
+  addReturnData(data: Buffer) {
+    if (!this._isOpReturnAdded) {
+      this.addOpCode(OpCode.OP_RETURN);
+      this._isOpReturnAdded = true;
+    }
+
+    this.addData(data);
+  }
+}

package/src/script/build/p2stas-builder.ts

@@ -0,0 +1,38 @@
+import { Address } from "../../bitcoin/address";
+import { OpCode } from "../../bitcoin/op-codes";
+import { ScriptType } from "../../bitcoin/script-type";
+import { getP2stasTokens } from "../script-samples";
+import { ScriptToken } from "../script-token";
+import { ScriptBuilder } from "./script-builder";
+
+export class P2stasBuilder extends ScriptBuilder {
+  constructor(
+    address: Address,
+    tokenId: string,
+    symbol: string,
+    data: Buffer[] = []
+  ) {
+    super(ScriptType.p2stas, address);
+
+    const stasTokens = getP2stasTokens();
+
+    for (var token of stasTokens) {
+      if (token.IsReceiverId) {
+        const receiver = ScriptToken.fromBuffer(address.Hash160);
+        receiver.IsReceiverId = true;
+
+        this._tokens.push(receiver);
+      } else {
+        this._tokens.push(ScriptToken.fromScriptToken(token));
+      }
+    }
+
+    this.addOpCode(OpCode.OP_RETURN);
+    this.addData(Buffer.from(tokenId, "hex"));
+    this.addData(Buffer.from(symbol, "utf8"));
+
+    for (const d of data) {
+      this.addData(d);
+    }
+  }
+}

package/src/script/build/script-builder.ts

@@ -0,0 +1,128 @@
+import { getNumberBuffer } from "../../buffer/buffer-utils";
+import { BufferWriter } from "../../buffer/buffer-writer";
+import { Address } from "../../bitcoin/address";
+import { OpCode } from "../../bitcoin/op-codes";
+import { ScriptType } from "../../bitcoin/script-type";
+import { ScriptToken } from "../script-token";
+
+export class ScriptBuilder {
+  _tokens: ScriptToken[] = [];
+
+  ScriptType: ScriptType;
+  ToAddress?: Address;
+
+  constructor(scriptType: ScriptType, toAddress?: Address) {
+    this.ScriptType = scriptType;
+    this.ToAddress = toAddress;
+  }
+
+  static fromTokens = (tokens: ScriptToken[], scriptType: ScriptType) => {
+    const builder = new ScriptBuilder(scriptType);
+    builder._tokens = tokens;
+
+    return builder;
+  };
+
+  size = () => {
+    let size = 0;
+
+    for (const token of this._tokens) {
+      size += this.tokenSize(token);
+    }
+
+    return size;
+  };
+
+  tokenSize = (token: ScriptToken) => {
+    let size = 1;
+
+    const opcodeNum = token.OpCodeNum;
+    const dataLength = token.DataLength;
+    const add =
+      opcodeNum > 0 && opcodeNum < OpCode.OP_PUSHDATA1
+        ? dataLength
+        : opcodeNum === OpCode.OP_PUSHDATA1
+        ? dataLength + 1
+        : opcodeNum === OpCode.OP_PUSHDATA2
+        ? dataLength + 2
+        : opcodeNum === OpCode.OP_PUSHDATA4
+        ? dataLength + 4
+        : 0;
+
+    return size + add;
+  };
+
+  toBuffer = () => {
+    const buffer = Buffer.alloc(this.size());
+    const bufferWriter = new BufferWriter(buffer);
+
+    for (var token of this._tokens) {
+      bufferWriter.writeUInt8(token.OpCodeNum);
+
+      if (token.OpCodeNum > 0 && token.OpCodeNum < OpCode.OP_PUSHDATA1) {
+        bufferWriter.writeChunk(token.Data!);
+      } else if (token.OpCodeNum === OpCode.OP_PUSHDATA1) {
+        bufferWriter.writeUInt8(token.DataLength);
+        bufferWriter.writeChunk(token.Data!);
+      } else if (token.OpCodeNum === OpCode.OP_PUSHDATA2) {
+        bufferWriter.writeUInt16(token.DataLength);
+        bufferWriter.writeChunk(token.Data!);
+      } else if (token.OpCodeNum === OpCode.OP_PUSHDATA4) {
+        bufferWriter.writeUInt32(token.DataLength);
+        bufferWriter.writeChunk(token.Data!);
+      }
+    }
+
+    return buffer;
+  };
+
+  toHex = () => this.toBuffer().toString("hex");
+
+  addToken = (token: ScriptToken) => {
+    this._tokens.push(token);
+
+    return this;
+  };
+
+  addOpCode = (opCode: OpCode) => {
+    this._tokens.push(new ScriptToken(opCode, opCode));
+
+    return this;
+  };
+
+  addData = (data: Buffer) => {
+    this._tokens.push(ScriptToken.fromBuffer(data));
+
+    return this;
+  };
+
+  addDatas = (data: Buffer[]) => {
+    for (const chunk of data) this._tokens.push(ScriptToken.fromBuffer(chunk));
+
+    return this;
+  };
+
+  addNumber = (data: number) => {
+    if (data === 0) this.addOpCode(OpCode.OP_0);
+    else if (data <= 16) this.addOpCode(0x50 + data);
+    else this.addData(getNumberBuffer(data));
+
+    return this;
+  };
+
+  toAsm = () => {
+    const opCodeKeys = Object.keys(OpCode);
+    const opCodeValues = Object.values(OpCode);
+
+    let result = "";
+
+    for (const token of this._tokens) {
+      if (result.length > 0) result += " ";
+
+      if (token.Data) result += token.Data!.toString("hex");
+      else result += opCodeKeys[opCodeValues.indexOf(token.OpCodeNum)];
+    }
+
+    return result;
+  };
+}

package/src/script/index.ts

@@ -0,0 +1,10 @@
+export * from "./build/null-data-builder";
+export * from "./build/p2pkh-builder";
+export * from "./build/p2stas-builder";
+export * from "./build/script-builder";
+
+export * from "./read/script-reader";
+
+export * from "./script-samples";
+export * from "./script-token";
+export * from "./script-utils";

package/src/script/read/script-reader.ts

@@ -0,0 +1,79 @@
+import { asMinimalOP, slice } from "../../buffer/buffer-utils";
+import { OpCode } from "../../bitcoin/op-codes";
+import { ScriptToken } from "../script-token";
+
+export class ScriptReader {
+  static read = (source: Buffer) => {
+    const result = [];
+
+    let i = 0;
+
+    while (i < source.length) {
+      const byte = source[i];
+
+      // data chunk
+      if (byte > OpCode.OP_0 && byte <= OpCode.OP_PUSHDATA4) {
+        const d = ScriptReader.decode(source, i);
+
+        // did reading a pushDataInt fail?
+        if (d === null) return [];
+
+        i += d.size;
+        // attempt to read too much data?
+
+        if (i + d.number > source.length) return [];
+
+        const data = slice(source, i, i + d.number);
+        i += d.number;
+
+        // decompile minimally
+        const op = asMinimalOP(data);
+
+        if (op !== undefined) {
+          result.push(new ScriptToken(byte, op));
+        } else {
+          result.push(ScriptToken.fromBuffer(data));
+        }
+        // opcode
+      } else {
+        result.push(new ScriptToken(byte, byte));
+
+        i += 1;
+      }
+    }
+
+    return result;
+  };
+
+  static decode = (buffer: Buffer, offset: number) => {
+    const opcode = buffer.readUInt8(offset);
+    let num;
+    let size;
+    // ~6 bit
+    if (opcode < OpCode.OP_PUSHDATA1) {
+      num = opcode;
+      size = 1;
+      // 8 bit
+    } else if (opcode === OpCode.OP_PUSHDATA1) {
+      if (offset + 2 > buffer.length) return null;
+      num = buffer.readUInt8(offset + 1);
+      size = 2;
+      // 16 bit
+    } else if (opcode === OpCode.OP_PUSHDATA2) {
+      if (offset + 3 > buffer.length) return null;
+      num = buffer.readUInt16LE(offset + 1);
+      size = 3;
+      // 32 bit
+    } else {
+      if (offset + 5 > buffer.length) return null;
+      if (opcode !== OpCode.OP_PUSHDATA4) throw new Error("Unexpected opcode");
+      num = buffer.readUInt32LE(offset + 1);
+      size = 5;
+    }
+    return {
+      opcode,
+      number: num,
+      size,
+    };
+  };
+}