dxs-stas-sdk 1.0.0

package/src/script/script-samples.ts

@@ -0,0 +1,27 @@
+import { OpCode } from "../bitcoin/op-codes";
+import { ScriptReader } from "./read/script-reader";
+import { ScriptToken } from "./script-token";
+
+export const nullDataTokens = [ScriptToken.forSample(OpCode.OP_0)];
+
+export const p2phkTokens = [
+  new ScriptToken(OpCode.OP_DUP),
+  new ScriptToken(OpCode.OP_HASH160),
+  ScriptToken.forSample(20, 20, true),
+  new ScriptToken(OpCode.OP_EQUALVERIFY),
+  new ScriptToken(OpCode.OP_CHECKSIG),
+];
+
+export const p2stasSampleHex =
+  "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";
+
+let stasTokens: ScriptToken[] | null = null;
+
+export const getP2stasTokens = () => {
+  if (stasTokens === null) {
+    stasTokens = ScriptReader.read(Buffer.from(p2stasSampleHex, "hex"));
+    stasTokens[2].IsReceiverId = true;
+  }
+
+  return stasTokens;
+};

package/src/script/script-token.ts

@@ -0,0 +1,66 @@
+import { OpCode } from "../bitcoin/op-codes";
+import { isOpCode } from "./script-utils";
+
+export class ScriptToken {
+  OpCodeNum: number;
+  OpCode?: OpCode;
+  Data?: Buffer;
+  DataLength: number = 0;
+  IsReceiverId: boolean = false;
+
+  constructor(opCodeNum: number, opCode?: OpCode) {
+    this.OpCode = opCode;
+    this.OpCodeNum = opCodeNum;
+  }
+
+  static fromBuffer(buffer: Buffer) {
+    const opCodeNum =
+      buffer.length === 0
+        ? -1
+        : buffer.length < 76
+        ? buffer.length
+        : buffer.length <= 255
+        ? OpCode.OP_PUSHDATA1
+        : buffer.length <= 65535
+        ? OpCode.OP_PUSHDATA2
+        : buffer.length <= 4294967295
+        ? OpCode.OP_PUSHDATA4
+        : -1;
+
+    if (opCodeNum === -1) throw new Error(`No data provided: ${buffer.length}`);
+
+    const token = new ScriptToken(opCodeNum);
+
+    token.Data = buffer;
+    token.DataLength = buffer.length;
+
+    return token;
+  }
+
+  static fromScriptToken(from: ScriptToken) {
+    const token = from.Data
+      ? ScriptToken.fromBuffer(from.Data)
+      : new ScriptToken(from.OpCodeNum, from.OpCode);
+
+    token.IsReceiverId = from.IsReceiverId;
+
+    return token;
+  }
+
+  static forSample(
+    opCodeNum: number,
+    dataLength: number = 0,
+    isReceiverId: boolean = false
+  ) {
+    const token = new ScriptToken(opCodeNum);
+
+    const { valid, opCode } = isOpCode(opCodeNum);
+
+    if (valid === false) token.OpCode = opCode;
+
+    token.DataLength = dataLength;
+    token.IsReceiverId = isReceiverId;
+
+    return token;
+  }
+}

package/src/script/script-utils.ts

@@ -0,0 +1,12 @@
+import { OpCode } from "../bitcoin/op-codes";
+
+export const isOpCode = (opCodeNum: number) => {
+  if (
+    opCodeNum === OpCode.OP_0 ||
+    (opCodeNum >= OpCode.OP_PUSHDATA1 && opCodeNum <= OpCode.OP_INVALIDOPCODE)
+  ) {
+    return { valid: true, opCode: opCodeNum };
+  }
+
+  return { valid: false, opCode: OpCode.OP_INVALIDOPCODE };
+};

package/src/stas-bundle-factory.ts

@@ -0,0 +1,367 @@
+import {
+  Address,
+  OutPoint,
+  ScriptType,
+  TDestination,
+  TokenScheme,
+  TPayment,
+  Transaction,
+  Wallet,
+} from "./bitcoin";
+import { TransactionBuilder, TransactionReader } from "./transaction";
+import {
+  BuildMergeTx,
+  BuildSplitTx,
+  BuildTransferTx,
+  FeeRate,
+} from "./transaction-factory";
+
+export const AvgFeeForMerge = 500;
+
+export type TGetUtxoFunction = (satoshis?: number) => Promise<OutPoint[]>;
+export type TGetTransactionsFunction = (
+  ids: string[]
+) => Promise<Record<string, Transaction>>;
+export type TStasPayoutBundle = {
+  transactions?: string[];
+  feeSatoshis: number;
+  message?: string;
+};
+
+export class StasBundleFactory {
+  constructor(
+    private readonly tokenScheme: TokenScheme,
+    private readonly stasWallet: Wallet,
+    private readonly feeWallet: Wallet,
+    private readonly getFeeUtxoSet: TGetUtxoFunction,
+    private readonly getStasUtxoSet: TGetUtxoFunction,
+    private readonly getTransactions: TGetTransactionsFunction
+  ) {}
+
+  public createBundle = async (
+    amount: number,
+    to: Address,
+    note?: Buffer[]
+  ): Promise<TStasPayoutBundle> => {
+    const satoshisToSend = Math.round(
+      amount * this.tokenScheme.SatoshisPerToken
+    );
+    const stasUtxoSet = (await this.getStasUtxoSet(satoshisToSend)).sort(
+      (a, b) => a.Satoshis - b.Satoshis
+    );
+    const availableSatoshis = stasUtxoSet.reduce((a, x) => a + x.Satoshis, 0);
+
+    if (availableSatoshis < satoshisToSend)
+      return {
+        message: "Insufficient STAS tokens balance",
+        feeSatoshis: 0,
+      };
+
+    const stasUtxos = this.getStasUtxo(stasUtxoSet, satoshisToSend);
+
+    let { feeSatoshis: estimatedFee } = await this._createBundle(
+      [],
+      stasUtxos,
+      satoshisToSend,
+      new OutPoint(
+        "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+        0,
+        Buffer.from(
+          "76a91462e907b15cbf27d5425399ebf6f0fb50ebb88f1888ac",
+          "hex"
+        ),
+        5000000000,
+        this.feeWallet.Address,
+        ScriptType.p2pkh
+      ),
+      to,
+      note
+    );
+
+    estimatedFee =
+      estimatedFee + stasUtxos.length * 9 + 1; /* Fee for fee transactio */
+    const feeUtxoSet = await this.getFeeUtxoSet();
+    const feeSatoshis = feeUtxoSet.reduce((a, x) => a + x.Satoshis, 0);
+
+    if (estimatedFee > feeSatoshis) {
+      return {
+        message: "Insufficient balance to pay fee",
+        feeSatoshis: 0,
+      };
+    }
+
+    const transactions: string[] = [];
+    const { feeTransaction, feeUtxo } = this.buildFeeTransaction(
+      feeUtxoSet,
+      estimatedFee
+    );
+
+    if (feeTransaction) transactions.push(feeTransaction);
+
+    return await this._createBundle(
+      transactions,
+      stasUtxos,
+      satoshisToSend,
+      feeUtxo,
+      to,
+      note
+    );
+  };
+
+  private _createBundle = async (
+    transactions: string[],
+    stasUtxos: OutPoint[],
+    satoshisToSend: number,
+    feeUtxo: OutPoint,
+    to: Address,
+    note?: Buffer[]
+  ) => {
+    const { mergeTransactions, mergeFeeUtxo, stasUtxo } =
+      await this.mergeStasTransactions(stasUtxos, satoshisToSend, feeUtxo);
+
+    if (mergeTransactions) {
+      for (const mergeTx of mergeTransactions) {
+        transactions.push(mergeTx);
+      }
+    }
+
+    if (stasUtxo.Satoshis === satoshisToSend) {
+      transactions.push(
+        this.buildTransferTransaction(stasUtxo, mergeFeeUtxo, to, note)
+      );
+    } else {
+      transactions.push(
+        this.buildSplitTransaction(
+          stasUtxo,
+          satoshisToSend,
+          to,
+          mergeFeeUtxo,
+          note
+        )
+      );
+    }
+
+    const transferTx = TransactionReader.readHex(
+      transactions[transactions.length - 1]
+    );
+    const feeUtxoIdx = note
+      ? transferTx.Outputs.length - 2
+      : transferTx.Outputs.length - 1;
+    const paidFee = feeUtxo.Satoshis - transferTx.Outputs[feeUtxoIdx].Satoshis;
+
+    return { transactions, feeSatoshis: paidFee };
+  };
+
+  private getStasUtxo = (utxos: OutPoint[], satoshis: number): OutPoint[] => {
+    const exactOrGreater = utxos.find((x) => x.Satoshis >= satoshis);
+
+    if (exactOrGreater && exactOrGreater.Satoshis === satoshis) {
+      return [exactOrGreater];
+    }
+
+    const result: OutPoint[] = [];
+    let accumulated = 0;
+    for (const utxo of utxos) {
+      result.push(utxo);
+      accumulated += utxo.Satoshis;
+
+      if (accumulated >= satoshis) return result;
+    }
+
+    return [exactOrGreater!];
+  };
+
+  private buildFeeTransaction = (
+    utxos: OutPoint[],
+    satoshis: number
+  ): {
+    feeTransaction?: string;
+    feeUtxo: OutPoint;
+  } => {
+    if (utxos.length === 1)
+      return {
+        feeUtxo: utxos[0],
+      };
+
+    const txBuilder = TransactionBuilder.init().addP2PkhOutput(
+      0,
+      this.feeWallet.Address
+    );
+    let accumulated = 0;
+
+    for (const utxo of utxos) {
+      txBuilder.addInput(utxo, this.feeWallet);
+
+      const fee = txBuilder.getFee(FeeRate);
+
+      accumulated += utxo.Satoshis;
+
+      if (accumulated - fee >= satoshis) break;
+    }
+
+    txBuilder.Outputs = [];
+
+    const result = txBuilder
+      .addChangeOutputWithFee(this.feeWallet.Address, accumulated, FeeRate)
+      .sign()
+      .toHex();
+
+    return { feeTransaction: result, feeUtxo: OutPoint.fromHex(result, 0) };
+  };
+
+  private mergeStasTransactions = async (
+    stasUtxos: OutPoint[],
+    satoshis: number,
+    mergeFeeUtxo: OutPoint
+  ): Promise<{
+    mergeTransactions?: string[];
+    stasUtxo: OutPoint;
+    mergeFeeUtxo: OutPoint;
+  }> => {
+    if (stasUtxos.length === 1) return { mergeFeeUtxo, stasUtxo: stasUtxos[0] };
+
+    const mergeTransactions: string[] = [];
+    const utxos = stasUtxos.map(({ TxId, Vout }) => ({ TxId, Vout }));
+    const txIds = Array.from(new Set(stasUtxos.map(({ TxId }) => TxId)));
+    const sourceTransactions = await this.getTransactions(txIds);
+    const mergeLevels: OutPoint[][] = [[]];
+
+    for (const { TxId, Vout } of utxos) {
+      const tx = sourceTransactions[TxId];
+
+      if (!tx) throw new Error(`Transaction ${TxId} not found`);
+
+      mergeLevels[0].push(OutPoint.fromTransaction(tx, Vout));
+    }
+
+    let feePayment: TPayment = {
+      OutPoint: mergeFeeUtxo,
+      Owner: this.feeWallet,
+    };
+    let currentLevel = mergeLevels[0];
+    let levelsBeforeTransfer = 0;
+    let stasUtxo = stasUtxos[0];
+
+    while (currentLevel.length !== 1) {
+      const newLevel: OutPoint[] = [];
+      mergeLevels.push(newLevel);
+
+      if (levelsBeforeTransfer === 3) {
+        levelsBeforeTransfer = 0;
+
+        for (let outPoint of currentLevel) {
+          const stasPayment: TPayment = {
+            OutPoint: outPoint,
+            Owner: this.stasWallet,
+          };
+          const txRaw = BuildTransferTx({
+            tokenScheme: this.tokenScheme,
+            stasPayment,
+            feePayment,
+            to: this.stasWallet.Address,
+          });
+          const tx = TransactionReader.readHex(txRaw);
+
+          newLevel.push(OutPoint.fromTransaction(tx, 0));
+          mergeTransactions.push(txRaw);
+
+          stasUtxo = OutPoint.fromTransaction(tx, 0);
+          feePayment.OutPoint = OutPoint.fromTransaction(tx, 1);
+        }
+      } else {
+        levelsBeforeTransfer++;
+
+        const mergeCounts = Math.floor(currentLevel.length / 2);
+        const remainder = currentLevel.length % 2;
+
+        if (remainder !== 0)
+          newLevel.push(currentLevel[currentLevel.length - 1]);
+
+        let currentIdx = 0;
+
+        for (var i = 0; i < mergeCounts; i++) {
+          const outPoint1 = currentLevel[currentIdx++];
+          const outPoint2 = currentLevel[currentIdx++];
+          const lastMerge = mergeCounts === 1 && remainder === 0;
+          const inputSatoshis = outPoint1.Satoshis + outPoint2.Satoshis;
+
+          let destination: TDestination = {
+            Address: this.stasWallet.Address,
+            Satoshis: inputSatoshis,
+          };
+          let splitDestination: TDestination | undefined = undefined;
+
+          if (lastMerge && inputSatoshis !== satoshis) {
+            destination = {
+              Address: this.stasWallet.Address,
+              Satoshis: satoshis,
+            };
+            splitDestination = {
+              Address: this.stasWallet.Address,
+              Satoshis: inputSatoshis - satoshis,
+            };
+          }
+
+          const txRaw = BuildMergeTx({
+            tokenScheme: this.tokenScheme,
+            outPoint1,
+            outPoint2,
+            owner: this.stasWallet,
+            feePayment,
+            destination,
+            splitDestination,
+          });
+          const tx = TransactionReader.readHex(txRaw);
+
+          newLevel.push(OutPoint.fromTransaction(tx, 0));
+          mergeTransactions.push(txRaw);
+
+          stasUtxo = OutPoint.fromTransaction(tx, 0);
+          feePayment.OutPoint = OutPoint.fromTransaction(
+            tx,
+            tx.Outputs.length - 1
+          );
+        }
+      }
+
+      currentLevel = newLevel;
+    }
+
+    return { mergeTransactions, mergeFeeUtxo: feePayment.OutPoint, stasUtxo };
+  };
+
+  private buildTransferTransaction = (
+    stasUtxo: OutPoint,
+    feeUtxo: OutPoint,
+    to: Address,
+    note?: Buffer[]
+  ): string =>
+    BuildTransferTx({
+      tokenScheme: this.tokenScheme,
+      stasPayment: { OutPoint: stasUtxo, Owner: this.stasWallet },
+      feePayment: { OutPoint: feeUtxo, Owner: this.feeWallet },
+      to,
+      note,
+    });
+
+  private buildSplitTransaction = (
+    stasUtxo: OutPoint,
+    satoshis: number,
+    to: Address,
+    feeUtxo: OutPoint,
+    note?: Buffer[]
+  ): string =>
+    BuildSplitTx({
+      tokenScheme: this.tokenScheme,
+      stasPayment: { OutPoint: stasUtxo, Owner: this.stasWallet },
+      feePayment: { OutPoint: feeUtxo, Owner: this.feeWallet },
+      destinations: [
+        { Satoshis: satoshis, Address: to },
+        {
+          Satoshis: stasUtxo.Satoshis - satoshis,
+          Address: this.stasWallet.Address,
+        },
+      ],
+      note,
+    });
+}