dxs-stas-sdk 1.0.0

package/src/transaction/build/input-builder.ts

@@ -0,0 +1,270 @@
+import {
+  cloneBuffer,
+  estimateChunkSize,
+  getChunkSize,
+  getNumberSize,
+  reverseBuffer,
+  splitBuffer,
+} from "../../buffer/buffer-utils";
+import { BufferWriter } from "../../buffer/buffer-writer";
+import { OpCode } from "../../bitcoin/op-codes";
+import { OutPoint } from "../../bitcoin/out-point";
+import { PrivateKey } from "../../bitcoin/private-key";
+import { ScriptType } from "../../bitcoin/script-type";
+import { SignatureHashType } from "../../bitcoin/sig-hash-type";
+import { hash256 } from "../../hashes";
+import { ScriptBuilder } from "../../script/build/script-builder";
+import { TransactionBuilder } from "./transaction-builder";
+import { Wallet } from "../../bitcoin";
+
+export class InputBilder {
+  protected TxBuilder: TransactionBuilder;
+  protected Owner: PrivateKey | Wallet;
+  protected Idx: number;
+
+  OutPoint: OutPoint;
+  Merge: Boolean;
+  UnlockingScript?: Buffer;
+  Sequence = TransactionBuilder.DefaultSequence;
+
+  private _mergeVout: number = 0;
+  private _mergeSegments: Buffer[] = [];
+
+  constructor(
+    txBuilder: TransactionBuilder,
+    outPoint: OutPoint,
+    signer: PrivateKey | Wallet,
+    merge: boolean
+  ) {
+    this.TxBuilder = txBuilder;
+    this.Idx = txBuilder.Inputs.length;
+    this.OutPoint = outPoint;
+    this.Owner = signer;
+    this.Merge = merge;
+  }
+
+  sign = () => {
+    const preimage = this.preimage(TransactionBuilder.DefaultSighashType);
+    const hashedPreimage = hash256(preimage);
+    const der = this.Owner.sign(hashedPreimage);
+    const derWithSigHashType = Buffer.alloc(der.length + 1);
+
+    der.copy(derWithSigHashType);
+    derWithSigHashType.writeInt8(
+      TransactionBuilder.DefaultSighashType,
+      der.length
+    );
+
+    if (this.OutPoint.ScriptType === ScriptType.p2pkh) {
+      const size =
+        getChunkSize(derWithSigHashType) + getChunkSize(this.Owner.PublicKey);
+      const buffer = Buffer.alloc(size);
+      const bufferWriter = new BufferWriter(buffer);
+
+      bufferWriter.writeVarChunk(derWithSigHashType);
+      bufferWriter.writeVarChunk(this.Owner.PublicKey);
+
+      this.UnlockingScript = buffer;
+    } else if (this.OutPoint.ScriptType === ScriptType.p2stas) {
+      this.prepareMergeInfo();
+
+      const script = new ScriptBuilder(ScriptType.p2stas);
+      let hasNote = false;
+
+      for (const output of this.TxBuilder.Outputs) {
+        if (output.LockingScript.ScriptType === ScriptType.nullData) {
+          const nulldata = output.LockingScript.toBuffer();
+          const payload = Buffer.alloc(nulldata.length - 2);
+
+          nulldata.copy(payload, 0, 2);
+          script.addData(payload);
+
+          hasNote = true;
+        } else {
+          script
+            .addNumber(output.Satoshis)
+            .addData(output.LockingScript.ToAddress!.Hash160);
+        }
+      }
+
+      if (!hasNote) script.addOpCode(OpCode.OP_0);
+
+      var fundingInput =
+        this.TxBuilder.Inputs[this.TxBuilder.Inputs.length - 1];
+
+      script
+        .addNumber(fundingInput.OutPoint.Vout)
+        .addData(reverseBuffer(Buffer.from(fundingInput.OutPoint.TxId, "hex")));
+
+      if (this.Merge) {
+        script
+          .addNumber(this._mergeVout)
+          .addDatas(this._mergeSegments)
+          .addNumber(this._mergeSegments.length);
+      } else {
+        script.addOpCode(OpCode.OP_0);
+      }
+
+      script
+        .addData(preimage)
+        .addData(derWithSigHashType)
+        .addData(this.Owner.PublicKey);
+
+      this.UnlockingScript = script.toBuffer();
+    }
+  };
+
+  writeTo(bufferWriter: BufferWriter) {
+    bufferWriter.writeChunk(
+      reverseBuffer(Buffer.from(this.OutPoint.TxId, "hex"))
+    );
+    bufferWriter.writeUInt32(this.OutPoint.Vout);
+    bufferWriter.writeVarChunk(this.UnlockingScript!);
+    bufferWriter.writeUInt32(this.Sequence);
+  }
+
+  size = () =>
+    32 + // TX.Id
+    4 + // Vout
+    this.unlockingScriptSize() +
+    4; // Sequence
+
+  preimageLength = (): number =>
+    4 + // Tx version
+    32 + // Prevout hash
+    32 + // Sequence hash
+    32 + // Output Tx id
+    4 + // VOUT ;
+    getChunkSize(this.OutPoint.LockignScript) +
+    8 + // Satoshis
+    4 + // Sequence
+    32 + //Outputs hash
+    4 + // Lock time
+    4; // Signature type
+
+  stasNullDataLength = () => {
+    const nullDataOutput = this.TxBuilder.Outputs.find(
+      (x) => x.LockingScript.ScriptType === ScriptType.nullData
+    );
+
+    if (!nullDataOutput) return 1;
+
+    return estimateChunkSize(nullDataOutput.LockingScript.size() - 2);
+  };
+
+  prevoutHashLength = () => (32 + 4) * this.TxBuilder.Inputs.length;
+
+  unlockingScriptSize = (): number => {
+    if (this.UnlockingScript !== undefined) {
+      return estimateChunkSize(this.UnlockingScript.length);
+    }
+
+    let size =
+      1 + // OP_PUSH
+      73 + // DER-encoded signature (70-73 bytes)
+      1 + // OP_PUSH
+      33; // Public Key
+
+    if (this.OutPoint.ScriptType === ScriptType.p2stas) {
+      this.prepareMergeInfo();
+
+      const fundingIdx = this.TxBuilder.Inputs.length - 1;
+      const fundingOutpoint = this.TxBuilder.Inputs[fundingIdx].OutPoint;
+
+      size += this.stasNullDataLength();
+      size += this.TxBuilder.Outputs.reduce((a, x) => {
+        if (x.LockingScript.ScriptType === ScriptType.nullData) return a;
+
+        return a + getNumberSize(x.Satoshis) + 21;
+      }, 0);
+
+      size += getNumberSize(fundingOutpoint.Vout);
+      size += estimateChunkSize(32); // Funding Tx vout
+      size += estimateChunkSize(this.preimageLength());
+
+      if (!this.Merge) {
+        size += 1; // OP_0
+      } else {
+        size += getNumberSize(this._mergeVout);
+        size += getNumberSize(this._mergeSegments.length);
+        size += this._mergeSegments.reduce((a, x) => getChunkSize(x) + a, 0);
+      }
+    }
+
+    return estimateChunkSize(size);
+  };
+
+  /// <summary>
+  /// Only SIGHASH_ALL|FORK_ID implemented
+  /// </summary>
+  preimage = (signatureHashType: SignatureHashType) => {
+    const size = this.preimageLength();
+    const buffer = Buffer.alloc(size);
+    var writer = new BufferWriter(buffer);
+
+    writer.writeUInt32(this.TxBuilder.Version); // 4
+    this.writePrevoutHash(writer); // 32
+    this.writeSequenceHash(writer); // 32
+    writer.writeChunk(reverseBuffer(Buffer.from(this.OutPoint.TxId, "hex"))); // 32
+    writer.writeUInt32(this.OutPoint.Vout); // 4
+    writer.writeVarChunk(this.OutPoint.LockignScript);
+    writer.writeUInt64(this.OutPoint.Satoshis); // 8
+    writer.writeUInt32(this.Sequence); // 4
+    this.writeOutputsHash(writer); // 32
+    writer.writeUInt32(this.TxBuilder.LockTime); // 4
+    writer.writeUInt32(signatureHashType); // 4
+
+    return buffer;
+  };
+
+  private writePrevoutHash = (bufferWriter: BufferWriter) => {
+    const size = this.prevoutHashLength();
+    const buffer = Buffer.alloc(size);
+    const writer = new BufferWriter(buffer);
+
+    for (const input of this.TxBuilder.Inputs) {
+      writer.writeChunk(reverseBuffer(Buffer.from(input.OutPoint.TxId, "hex")));
+      writer.writeUInt32(input.OutPoint.Vout);
+    }
+
+    bufferWriter.writeChunk(hash256(buffer));
+  };
+
+  private writeSequenceHash = (bufferWriter: BufferWriter) => {
+    const buffer = Buffer.alloc(4 * this.TxBuilder.Inputs.length);
+    const writer = new BufferWriter(buffer);
+
+    for (const input of this.TxBuilder.Inputs)
+      writer.writeUInt32(input.Sequence);
+
+    bufferWriter.writeChunk(hash256(buffer));
+  };
+
+  private writeOutputsHash = (bufferWriter: BufferWriter) => {
+    var size = this.TxBuilder.Outputs.reduce((a, x) => a + x.size(), 0);
+
+    const buffer = Buffer.alloc(size);
+    const writer = new BufferWriter(buffer);
+
+    for (const output of this.TxBuilder.Outputs) {
+      writer.writeUInt64(output.Satoshis);
+      writer.writeVarChunk(output.LockingScript.toBuffer());
+    }
+
+    bufferWriter.writeChunk(hash256(buffer));
+  };
+
+  private prepareMergeInfo = () => {
+    if (!this.Merge || this._mergeSegments.length > 0) return;
+
+    const lockingScript = this.TxBuilder.Inputs[0].OutPoint.LockignScript;
+    const scriptToCut = cloneBuffer(lockingScript, 0, 23);
+    const mergeUtxo = this.TxBuilder.Inputs[this.Idx === 0 ? 1 : 0];
+
+    this._mergeVout = mergeUtxo.OutPoint.Vout;
+    this._mergeSegments = splitBuffer(
+      mergeUtxo.OutPoint.Transaction!.Raw,
+      scriptToCut
+    ).reverse();
+  };
+}

package/src/transaction/build/output-builder.ts

@@ -0,0 +1,25 @@
+import { estimateChunkSize } from "../../buffer/buffer-utils";
+import { BufferWriter } from "../../buffer/buffer-writer";
+import { ScriptBuilder } from "../../script/build/script-builder";
+
+export class OutputBuilder {
+  Satoshis: number;
+  LockingScript: ScriptBuilder;
+
+  constructor(lockingScript: ScriptBuilder, satoshis: number) {
+    this.LockingScript = lockingScript;
+    this.Satoshis = satoshis;
+  }
+
+  size() {
+    return (
+      8 + // satoshis Size, always 8 bytes
+      estimateChunkSize(this.LockingScript.size())
+    );
+  }
+
+  writeTo(bufferWriter: BufferWriter) {
+    bufferWriter.writeUInt64(this.Satoshis);
+    bufferWriter.writeVarChunk(this.LockingScript.toBuffer());
+  }
+}

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

@@ -0,0 +1,163 @@
+import { getVarIntLength } from "../../buffer/buffer-utils";
+import { BufferWriter } from "../../buffer/buffer-writer";
+import { Address } from "../../bitcoin/address";
+import { OpCode } from "../../bitcoin/op-codes";
+import { OutPoint } from "../../bitcoin/out-point";
+import { PrivateKey } from "../../bitcoin/private-key";
+import { SignatureHashType } from "../../bitcoin/sig-hash-type";
+import { TokenScheme } from "../../bitcoin/token-scheme";
+import { NullDataBuilder } from "../../script/build/null-data-builder";
+import { P2pkhBuilder } from "../../script/build/p2pkh-builder";
+import { P2stasBuilder } from "../../script/build/p2stas-builder";
+import { ScriptReader } from "../../script/read/script-reader";
+import { InputBilder } from "./input-builder";
+import { OutputBuilder } from "./output-builder";
+import { Wallet } from "../../bitcoin";
+
+export class TransactionBuilder {
+  static DefaultSequence = 0xffffffff;
+  static DefaultSighashType =
+    SignatureHashType.SIGHASH_ALL | SignatureHashType.SIGHASH_FORKID;
+
+  Inputs: InputBilder[] = [];
+  Outputs: OutputBuilder[] = [];
+
+  Version = 1;
+  LockTime = 0;
+
+  static init = () => new TransactionBuilder();
+
+  size = () =>
+    4 + // version
+    4 + // locktime
+    getVarIntLength(this.Inputs.length) +
+    this.Inputs.reduce((a, x) => a + x.size(), 0) +
+    getVarIntLength(this.Outputs.length) +
+    this.Outputs.reduce((a, x) => a + x.size(), 0);
+
+  getFee = (satoshisPerByte: number) =>
+    Math.ceil(this.size() * satoshisPerByte);
+
+  addInput = (outPoint: OutPoint, signer: PrivateKey | Wallet) => {
+    this.Inputs.push(new InputBilder(this, outPoint, signer, false));
+
+    return this;
+  };
+
+  addStasMergeInput = (outPoint: OutPoint, signer: PrivateKey | Wallet) => {
+    this.Inputs.push(new InputBilder(this, outPoint, signer, true));
+
+    return this;
+  };
+
+  addP2PkhOutput = (value: number, to: Address, data: Buffer[] = []) => {
+    const script = new P2pkhBuilder(to);
+
+    for (const d of data) {
+      script.addReturnData(d);
+    }
+
+    this.Outputs.push(new OutputBuilder(script, value));
+
+    return this;
+  };
+
+  addNullDataOutput(data: Buffer[]) {
+    const script = new NullDataBuilder(data);
+
+    this.Outputs.push(new OutputBuilder(script, 0));
+
+    return this;
+  }
+
+  addChangeOutputWithFee(
+    to: Address,
+    change: number,
+    satoshisPerByte: number,
+    idx: number | null = null
+  ) {
+    const script = new P2pkhBuilder(to);
+    const output = new OutputBuilder(script, change);
+
+    if (idx !== null) this.Outputs.splice(idx, 0, output);
+    else this.Outputs.push(output);
+
+    let fee = this.getFee(satoshisPerByte);
+
+    if (fee >= change) throw new Error("Insufficient satoshis to pay fee");
+
+    output.Satoshis = change - fee;
+
+    return this;
+  }
+
+  addStasOutputByScheme = (
+    schema: TokenScheme,
+    satoshis: number,
+    to: Address,
+    data: Buffer[] = []
+  ) => {
+    const script = new P2stasBuilder(to, schema.TokenId, schema.Symbol);
+
+    for (const d of data) {
+      script.addData(d);
+    }
+
+    this.Outputs.push(new OutputBuilder(script, satoshis));
+
+    return this;
+  };
+
+  addStasOutputByPrevLockingScript = (
+    satoshis: number,
+    to: Address,
+    prevStasLockingScript: Buffer
+  ) => {
+    const prevScriptTokens = ScriptReader.read(prevStasLockingScript);
+    const opReturnIdx = prevScriptTokens.findIndex(
+      (x) => x.OpCodeNum === OpCode.OP_RETURN
+    );
+
+    const toknenId = prevScriptTokens[opReturnIdx + 1].Data!.toString("hex");
+    const symbol = prevScriptTokens[opReturnIdx + 2].Data!.toString("utf8");
+    const data: Buffer[] = [];
+
+    for (let i = opReturnIdx + 3; i < prevScriptTokens.length; i++) {
+      data.push(prevScriptTokens[i].Data!);
+    }
+
+    const script = new P2stasBuilder(to, toknenId, symbol, data);
+
+    this.Outputs.push(new OutputBuilder(script, satoshis));
+
+    return this;
+  };
+
+  sign = () => {
+    for (const input of this.Inputs) {
+      input.sign();
+    }
+
+    return this;
+  };
+
+  toBuffer = () => {
+    const size = this.size();
+    const buffer = Buffer.alloc(size);
+    const bufferWriter = new BufferWriter(buffer);
+
+    bufferWriter.writeUInt32(this.Version);
+
+    bufferWriter.writeVarInt(this.Inputs.length);
+    for (const input of this.Inputs) input.writeTo(bufferWriter);
+
+    bufferWriter.writeVarInt(this.Outputs.length);
+    for (const output of this.Outputs) output.writeTo(bufferWriter);
+
+    bufferWriter.writeUInt32(this.LockTime);
+
+    return buffer;
+  };
+
+  toHex = () => this.toBuffer().toString("hex");
+}

package/src/transaction/index.ts

@@ -0,0 +1,4 @@
+export * from "./build/input-builder";
+export * from "./build/output-builder";
+export * from "./build/transaction-builder";
+export * from "./read/transaction-reader";

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

@@ -0,0 +1,54 @@
+import { BufferReader } from "../../buffer/buffer-reader";
+import { reverseBuffer } from "../../buffer/buffer-utils";
+import { Transaction } from "../../bitcoin/transaction";
+import { TransactionInput } from "../../bitcoin/transaction-input";
+import { TransactionOutput } from "../../bitcoin/transaction-output";
+
+export class TransactionReader {
+  static readHex = (raw: string) =>
+    TransactionReader.readBuffer(Buffer.from(raw, "hex"));
+
+  static readBuffer = (buffer: Buffer) => {
+    const reader = new BufferReader(buffer);
+
+    const version = reader.readUInt32();
+    const inputCount = reader.readVarInt();
+    const inputs = [];
+
+    for (let i = 0; i < inputCount; i++) {
+      inputs.push(TransactionReader.readInput(reader));
+    }
+
+    const outputCount = reader.readVarInt();
+    const outputs = [];
+
+    for (let i = 0; i < outputCount; i++) {
+      outputs.push(TransactionReader.readOutput(reader));
+    }
+
+    const lockTime = reader.readUInt32();
+
+    return new Transaction(buffer, inputs, outputs, version, lockTime);
+  };
+
+  static readInput = (reader: BufferReader): TransactionInput => {
+    const txId = reverseBuffer(reader.readChunk(32));
+    const vout = reader.readUInt32();
+    const unlockingScript = reader.readVarChunk();
+    const sequence = reader.readUInt32();
+
+    return new TransactionInput(
+      txId.toString("hex"),
+      vout,
+      unlockingScript,
+      sequence
+    );
+  };
+
+  static readOutput = (reader: BufferReader): TransactionOutput => {
+    const satoshis = reader.readUInt64();
+    const lockignScript = reader.readVarChunk();
+
+    return new TransactionOutput(satoshis, lockignScript);
+  };
+}