mainnet-js 3.1.7 → 4.0.0-next.10

package/src/wallet/model.ts

@@ -1,352 +0,0 @@
-import { NFTCapability, UtxoId } from "../interface.js";
-import { DELIMITER } from "../constant.js";
-import {
-  Input,
-  Output,
-  binToNumberUint16LE,
-  binToUtf8,
-  hexToBin,
-  utf8ToBin,
-} from "@bitauth/libauth";
-import { Config } from "../config.js";
-import { checkTokenaddr } from "../util/deriveCashaddr.js";
-
-// These are the minimal models used to provide types for the express server
-//
-// This file will be deprecated auto-generated file in the future
-// Any business logic contained here should be moved elsewhere in src/
-
-export type SendRequestType =
-  | SendRequest
-  | TokenSendRequest
-  | OpReturnData
-  | Array<SendRequest | TokenSendRequest | OpReturnData>
-  | SendRequestArray[];
-
-export class SendRequest {
-  cashaddr: string;
-  value: bigint;
-
-  constructor({ cashaddr, value }: { cashaddr: string; value: bigint }) {
-    this.cashaddr = cashaddr;
-    this.value = BigInt(value);
-  }
-}
-
-export class TokenGenesisRequest {
-  amount?: bigint; // fungible token amount
-  nft?: {
-    capability: NFTCapability;
-    commitment: string;
-  };
-  cashaddr?: string;
-  value?: bigint; // satoshi value
-
-  constructor({
-    amount,
-    nft,
-    cashaddr,
-    value,
-  }: {
-    amount?: bigint;
-    nft?: {
-      capability: NFTCapability;
-      commitment: string;
-    };
-    cashaddr?: string;
-    value?: bigint;
-  }) {
-    this.amount = amount;
-    this.nft = nft;
-    this.cashaddr = cashaddr;
-    this.value = value;
-  }
-}
-
-export class TokenBurnRequest {
-  category: string;
-  amount?: bigint; // fungible token amount
-  nft?: {
-    capability: NFTCapability;
-    commitment: string;
-  };
-  cashaddr?: string;
-
-  constructor({
-    category,
-    amount,
-    nft,
-    cashaddr,
-  }: {
-    category: string;
-    amount?: number | bigint;
-    cashaddr?: string;
-    nft?: {
-      capability: NFTCapability;
-      commitment: string;
-    };
-  }) {
-    this.category = category;
-    this.amount = amount ? BigInt(amount) : 0n;
-    this.nft = nft;
-    this.cashaddr = cashaddr;
-  }
-}
-
-export class TokenSendRequest {
-  cashaddr: string; // cashaddr or tokenaddr to send tokens to
-  value?: bigint; // satoshi value
-  amount: bigint; // fungible token amount
-  category: string;
-  nft?: {
-    capability: NFTCapability;
-    commitment: string;
-  };
-
-  constructor({
-    cashaddr,
-    value,
-    amount,
-    category,
-    nft,
-  }: {
-    cashaddr: string;
-    value?: bigint;
-    amount?: bigint;
-    category: string;
-    nft?: {
-      capability: NFTCapability;
-      commitment: string;
-    };
-  }) {
-    checkTokenaddr(cashaddr, Config.EnforceCashTokenReceiptAddresses);
-
-    this.cashaddr = cashaddr;
-    this.value = value;
-    this.amount = amount ? BigInt(amount) : 0n;
-    this.category = category;
-    this.nft = nft;
-  }
-}
-
-export class TokenMintRequest {
-  nft?: {
-    capability: NFTCapability;
-    commitment: string;
-  };
-  cashaddr?: string;
-  value?: bigint;
-
-  constructor({
-    nft,
-    cashaddr,
-    value,
-  }: {
-    nft?: {
-      capability: NFTCapability;
-      commitment: string;
-    };
-    cashaddr?: string;
-    value?: bigint;
-  }) {
-    this.nft = nft;
-    this.cashaddr = cashaddr;
-    this.value = value;
-  }
-}
-
-export class OpReturnData {
-  buffer: Uint8Array;
-
-  public constructor(buffer: Uint8Array) {
-    this.buffer = Uint8Array.from(buffer);
-  }
-
-  /**
-   * from - Construct OP_RETURN data from arbitrary data type
-   *
-   * @param string   UTF-8 encoded string message to be converted to OP_RETURN data
-   *
-   * @returns class instance
-   */
-  public static from(data: string | Uint8Array) {
-    return this.fromArray([data]);
-  }
-
-  /**
-   * fromString - Accept data as a simple UTF-8 string message and append an OP_RETURN and PUSH_DATA1 opcodes to it
-   *
-   * @param string   UTF-8 encoded string message to be converted to OP_RETURN data
-   *
-   * @returns class instance
-   */
-  public static fromString(string: string) {
-    return this.fromArray([string]);
-  }
-
-  /**
-   * buffer - Accept OP_RETURN data as a binary buffer.
-   * If buffer lacks the OP_RETURN and OP_PUSHDATA opcodes, they will be prepended.
-   *
-   * @param buffer   Data buffer to be assigned to the OP_RETURN outpit
-   *
-   * @returns class instance
-   */
-  public static fromUint8Array(uint8Array: Uint8Array) {
-    if (uint8Array[0] !== 0x6a) {
-      return this.fromArray([uint8Array]);
-    }
-    return new this(Uint8Array.from(uint8Array));
-  }
-
-  /**
-   * fromArray - Accept array of data
-   *
-   * @param array   Array of Uint8Array or UTF-8 encoded string messages to be converted to OP_RETURN data
-   *
-   * @returns class instance
-   */
-  public static fromArray(array: Array<string | Uint8Array>) {
-    let data: Uint8Array = Uint8Array.from([0x6a]); // OP_RETURN
-    for (const element of array) {
-      let length: number;
-      let elementData: Uint8Array;
-      let lengthData: any;
-      if (typeof element === "string") {
-        elementData = utf8ToBin(element);
-        length = elementData.length;
-      } else if (element instanceof Uint8Array) {
-        elementData = element;
-        length = elementData.length;
-      } else {
-        throw new Error("Wrong data array element");
-      }
-
-      if (length < 76) {
-        // OP_PUSHDATA_1
-        lengthData = [length];
-      } else if (length < 223) {
-        // default max `-datacarriersize`
-        lengthData = [0x4c, length];
-      } else {
-        throw new Error("OP_RETURN data can not exceed 220 bytes in size");
-      }
-
-      data = Uint8Array.from([...data, ...lengthData, ...elementData]);
-    }
-
-    if (data.length > 220) {
-      throw new Error("OP_RETURN data can not exceed 220 bytes in size");
-    }
-
-    return new this(data);
-  }
-
-  /**
-   * parseBinary - parse OP_RETURN data and return pushed chunks of binary data
-   *
-   * @param opReturn   Raw OP_RETURN data
-   *
-   * @returns array of binary data chunks pushed
-   */
-  public static parseBinary(opReturn: Uint8Array): Uint8Array[] {
-    const chunks: Uint8Array[] = [];
-    let position = 1;
-
-    // handle direct push, OP_PUSHDATA1, OP_PUSHDATA2;
-    // OP_PUSHDATA4 is not supported in OP_RETURNs by consensus
-    while (opReturn[position]) {
-      let length = 0;
-      if (opReturn[position] === 0x4c) {
-        length = opReturn[position + 1];
-        position += 2;
-      } else if (opReturn[position] === 0x4d) {
-        length = binToNumberUint16LE(
-          opReturn.slice(position + 1, position + 3)
-        );
-        position += 3;
-      } else {
-        length = opReturn[position];
-        position += 1;
-      }
-
-      chunks.push(opReturn.slice(position, position + length));
-      position += length;
-    }
-
-    return chunks;
-  }
-
-  /**
-   * parse - parse OP_RETURN hex data and return pushed chunks of binary data, converted to utf8 strings
-   *
-   * @param opReturn   Raw OP_RETURN hex data
-   *
-   * @returns array of binary data chunks pushed, converted to utf8 strings
-   */
-  public static parse(opReturnHex: string): string[] {
-    return this.parseBinary(hexToBin(opReturnHex)).map((val) => binToUtf8(val));
-  }
-}
-
-export type SendRequestArray = Array<string | bigint | Uint8Array>;
-
-export type SourceOutput = Input & Output;
-
-export class SendResponse {
-  txId?: string;
-  balance?: bigint;
-  explorerUrl?: string;
-  categories?: string[];
-  unsignedTransaction?: string; // unsigned transaction hex
-  sourceOutputs?: SourceOutput[]; // source outputs for signing unsigned transactions
-
-  constructor({
-    txId,
-    balance,
-    explorerUrl,
-  }: {
-    txId?: string;
-    balance?: any;
-    explorerUrl?: string;
-  }) {
-    this.txId = txId;
-    this.balance = balance;
-    this.explorerUrl = explorerUrl;
-  }
-}
-
-export class XPubKey {
-  path: string;
-  xPubKey: string;
-
-  constructor({ path, xPubKey }: { path: string; xPubKey: string }) {
-    this.path = path;
-    this.xPubKey = xPubKey;
-  }
-
-  public async ready() {
-    await this.xPubKey;
-    return this.asObject();
-  }
-
-  public asObject() {
-    return {
-      path: this.path,
-      xPubKey: this.xPubKey,
-    };
-  }
-}
-
-export const fromUtxoId = (utxoId: string): UtxoId => {
-  const [txid, vout, satoshis] = utxoId.split(DELIMITER);
-  return {
-    satoshis: satoshis ? BigInt(parseInt(satoshis)) : 0n,
-    vout: parseInt(vout),
-    txid,
-  } as UtxoId;
-};
-
-export const toUtxoId = (utxo: UtxoId): string => {
-  return [utxo.txid, utxo.vout].join(DELIMITER).replace(/:+$/, "");
-};

package/tsconfig.browser.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig",
-  "compilerOptions": {
-    "baseUrl": "src",
-    "paths": {
-      "pg": ["false*"]
-    }
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules/**", "dist/**", "src/**/*test.ts"]
-}

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "forceConsistentCasingInFileNames": true,
-    "downlevelIteration": true,
-    "composite": true,
-    "target": "esnext",
-    "module": "esnext",
-    "outDir": "./dist/module",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "typeRoots": [
-      "node_modules/@types",
-      "../../node_modules/@types",
-      "./src/types"
-    ],
-    "types": ["node", "jest"],
-    "allowJs": false,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "noEmit": false,
-    "strictPropertyInitialization": false,
-    "useDefineForClassFields": false
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules/**", "src/**/*test.ts"],
-  "compileOnSave": false
-}

package/webpack.config.cjs

@@ -1,132 +0,0 @@
-const { merge } = require("webpack-merge");
-const packageJson = require("./package.json");
-const HtmlWebpackPlugin = require("html-webpack-plugin");
-const InjectBodyPlugin = require("inject-body-webpack-plugin").default;
-const CircularDependencyPlugin = require("circular-dependency-plugin");
-const __basedir = require("path").resolve(__dirname, "../../");
-
-const path = require("path");
-const webpack = require("webpack");
-
-const baseConfig = {
-  mode: "development",
-  resolve: {
-    extensions: [".tsx", ".ts", ".js", ".wasm"],
-    extensionAlias: {
-      ".js": [".ts", ".js"],
-    },
-  },
-  optimization: {
-    minimize: false,
-    mangleWasmImports: true,
-    usedExports: true,
-  },
-  experiments: { topLevelAwait: true, outputModule: true },
-};
-
-const prodConfig = {
-  mode: "production",
-  optimization: {
-    minimize: true,
-  },
-};
-
-const browserConfig = {
-  target: "web",
-  entry: {
-    mainnet: {
-      import: "./src/index.ts",
-      library: {
-        name: "__mainnetPromise",
-        type: "global",
-      },
-    },
-  },
-  module: {
-    rules: [
-      {
-        test: /\.tsx?$/,
-        use: [
-          {
-            loader: "ts-loader",
-            options: {
-              configFile: "tsconfig.browser.json",
-            },
-          },
-        ],
-        exclude: [/node_modules/],
-      },
-    ],
-  },
-  output: {
-    filename: `[name]-${packageJson.version}.js`,
-    path: __dirname + "/dist",
-    libraryTarget: "umd",
-  },
-  plugins: [
-    //new BundleAnalyzerPlugin(),
-    new HtmlWebpackPlugin({
-      title: "The Empty Mainnet App",
-    }),
-    new InjectBodyPlugin({
-      content:
-        '<script>document.addEventListener("DOMContentLoaded", async (event) => Object.assign(globalThis, await __mainnetPromise))</script>',
-    }),
-    new CircularDependencyPlugin({
-      include: /src/,
-      // exclude detection of files based on a RegExp
-      exclude: /node_modules/,
-      // add errors to webpack instead of warnings
-      failOnError: false,
-      // allow import cycles that include an asyncronous import,
-      // e.g. via import(/* webpackMode: "weak" */ './file.js')
-      allowAsyncCycles: false,
-      // set the current working directory for displaying module paths
-      cwd: process.cwd(),
-    }),
-  ],
-  resolve: {
-    alias: {
-      crypto: false,
-      child_process: false,
-    },
-    fallback: {},
-  },
-};
-
-const webWorkerConfig = {
-  target: "webworker",
-  output: {
-    filename: `mainnet-webworker-${packageJson.version}.js`,
-    path: __dirname + "/dist",
-    libraryTarget: "umd",
-  },
-  resolve: {
-    alias: {
-      crypto: false,
-      child_process: false,
-    },
-    fallback: {},
-  },
-};
-
-const browserTestDiff = {
-  output: {
-    filename: `[name].js`,
-    path: __basedir + "/jest/playwright/",
-  },
-};
-
-const browserTestConfig = merge(browserConfig, browserTestDiff);
-
-let config = baseConfig;
-
-if (process.env.NODE_ENV == "production") {
-  console.log("Running webpack in production mode");
-  config = merge(baseConfig, prodConfig);
-}
-
-// Join configurations with the base configuration
-module.exports = [browserConfig, browserTestConfig].map((c) =>
-  merge(config, c)
-);