waves_lib 0.1.0

data/js/node_modules/@waves/ts-types/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "dist",
+    "lib": ["es2017"]
+  },
+  "files": [
+    "src/index.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

data/js/node_modules/@waves/waves-transactions/README.md

@@ -0,0 +1,432 @@
+# waves-transactions  [![npm version](https://badge.fury.io/js/%40waves%2Fwaves-transactions.svg)](https://badge.fury.io/js/%40waves%2Fwaves-transactions)
+
+[![License][license-image]][license-url]
+
+[license-url]: https://opensource.org/licenses/MIT
+[license-image]: https://img.shields.io/npm/l/make-coverage-badge.svg
+
+Using this library you can easily create and sign transactions for Waves blockchain.
+It also allows you to multi-sign existing transactions or create them without signature at all.
+
+- [Transactions](#Transactions) 
+  - [Creation](#Creation)
+  - [Signing](#Signing)
+  - [Params](#Params)
+- [Orders](#Orders)
+- [Broadcast](#Broadcast)
+- [Dependencies](#Dependencies)
+## Transactions
+
+### Creation
+
+Transactions are created via transaction creating functions. There are 15 of them:
+```typescript
+const {
+ alias, burn, cancelLease, data, exchange,
+ invokeScript, issue, lease, massTransfer, reissue,
+ setAssetScript, setScript, sponsorship, transfer, updateAssetInfo
+} = require('@waves/waves-transactions')
+```
+Example:
+```typescript
+const issueTx = issue({
+  name: 'foo',
+  description: 'bar',
+  quantity: 10000,
+  senderPublicKey: 'GucCLYU7aqzcVUwVXX4nosceDisky9UpbmpFK39tVYom',
+  chainId: 'T'
+})
+const burnTx = burn({
+  assetId: '6toKooURvF3CpRQV8hzhNbHjK3Rb3L9Krd7TFnzcoe8L',
+  senderPublicKey: 'GucCLYU7aqzcVUwVXX4nosceDisky9UpbmpFK39tVYom',
+  chainId: 'T'
+})
+```
+### Signing
+You can provide seed or private key to transaction creating function to sign it. If you do, senderPublicKey can be omitted.
+```typescript
+const signedTranfer = transfer({
+    recipient:'3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+    amount: 100000}, 'secret seed phraze'
+)
+const signedTranferViaPrivateKey = transfer({
+    recipient:'3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+    amount: 100000}, {privateKey: 'GucCLYU7aqzcVUwVXX4nosceDisky9UpbmpFK39tVYom'}
+)
+```
+
+### Params
+Type LONG represents string or number. Strings are allowed since max js int is 2**53
+#### Common params:
+Present in all transactions
+```typescript
+interface IBasicParams<LONG = string | number> {
+  /**
+   * Transaction fee. If not set, fee will be calculated automatically
+   */
+  fee?: LONG
+  /**
+   * If fee is not set, this value will be added to automatically calculated fee. E.x.:
+   * Account is scripted and 400000 fee more is required.
+   */
+  additionalFee?: number
+  /**
+   * If not set, public key will be derived from seed phrase. You should provide senderPublicKey in two cases:
+   * 1. Account, from which this tx should be sent, differs from tx signer. E.g., we have smart account that requires 2 signatures.
+   * 2. You to create tx without proof. Therefore no seed is provided.
+   */
+  senderPublicKey?: string
+  /**
+   * Transaction timestamp. If not set current timestamp will be used. Date.now()
+   */
+  timestamp?: number
+  /**
+   * Network byte. Could be set as number or as char.
+   * If set as char(string), charCodeAt(0) will be used. E.g.,
+   * 'W' will be converted to '87'
+   * If not set, 87 will be used as default
+   */
+  chainId?: string | number
+}
+```
+
+#### Issue transaction. Type 3
+```typescript
+export interface IIssueParams<LONG = string | number> extends IBasicParams<LONG> {
+  name: string
+  description: string
+  quantity: LONG
+  decimals?: number
+  reissuable?: boolean
+  script?: string
+}
+```
+#### Transfer transaction. Type 4
+```typescript
+export interface ITransferParams<LONG = string | number> extends IBasicParams<LONG> {
+  /**
+   * Can be either address(base58 encoded 24 byte address) or alias.
+   * Alias should be used like 'alias:{chainId}:{alias}>'. E.g.:
+   * If we have alias 'foo', and we want TESTNET transaction, recipient should be 'alias:T:foo'
+   */
+  recipient: string
+  amount: LONG
+  assetId?: string | null
+  /**
+   * Fee can be paid in custom token if sponsorship has been set for this token
+   */
+  feeAssetId?: string | null
+  /**
+   * Bytearray encoded as base58 string
+   */
+  attachment?: string | TTypedData
+}
+```
+#### Reissue transaction. Type 5
+```typescript
+export interface IReissueParams<LONG = string | number> extends IBasicParams<LONG> {
+  assetId: string
+  quantity: LONG
+  reissuable: boolean
+}
+```
+#### Burn transaction. Type 6
+```typescript
+export interface IBurnParams<LONG = string | number> extends IBasicParams<LONG> {
+  assetId: string
+  quantity: LONG
+}
+```
+#### Exchange transaction. Type 7
+Exchange transactions are used by DEX mather. If you want to create your own exchange transaction,
+ there is no params. You need to construct it by hand(see interface below, IOrder is described in Order section) 
+```typescript
+export interface IExchangeTransaction<LONG = string | number> extends ITransaction<LONG> {
+  type: 7
+  order1: IOrder
+  order2: IOrder
+  price: LONG
+  amount: LONG
+  buyMatcherFee: LONG
+  sellMatcherFee: LONG
+}
+```
+#### Lease transaction. Type 8
+```typescript
+export interface ILeaseParams<LONG = string | number> extends IBasicParams<LONG> {
+  recipient: string
+  amount: LONG
+}
+```
+#### CancelLease transaction. Type 9
+```typescript
+export interface ICancelLeaseParams<LONG = string | number> extends IBasicParams<LONG> {
+  leaseId: string
+}
+```
+#### Alias transaction. Type 10
+```typescript
+export interface IAliasParams<LONG = string | number> extends IBasicParams<LONG> {
+  alias: string
+}
+```
+#### MassTransfer transaction. Type 11
+```typescript
+export interface IMassTransferParams<LONG = string | number> extends IBasicParams<LONG> {
+  transfers: IMassTransferItem[]
+  /**
+   * Bytearray encoded as base string
+   */
+  attachment?: string | TTypedData
+  assetId?: string | null
+}
+
+export interface IMassTransferItem<LONG = string | number> {
+  recipient: string
+  amount: LONG
+}
+```
+#### Data transaction. Type 12
+```typescript
+export interface IDataParams<LONG = string | number> extends IBasicParams<LONG> {
+  data: Array<IBooleanData | IIntegerData | IStringData | IBinaryData| TDeleteRequest>
+}
+export type TDeleteRequest = {
+  type?: null
+  value?: null
+  key: string
+}
+
+export interface IBooleanData {
+  key: string
+  type: 'boolean'
+  value: boolean
+}
+export interface IIntegerData<LONG = string | number> {
+  key: string
+  type: 'integer'
+  value: LONG
+}
+export interface IStringData {
+  key: string
+  type: 'string'
+  value: string
+}
+export interface IBinaryData {
+  key: string
+  type: 'binary'
+  value: string
+}
+
+
+```
+#### SetScript transaction. Type 13
+```typescript
+export interface ISetScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+  /**
+   * Compiled script encoded as base64 string
+   */
+  script: string | null
+}
+```
+#### Sponsorship transaction. Type 14
+```typescript
+export interface ISponsorshipParams<LONG = string | number> extends IBasicParams<LONG> {
+  /**
+   * AssetID of sponsored token
+   */
+  assetId: string
+  /**
+   * Minimal fee amount in sponsored asset. To disable sponsorship set it to 0
+   */
+  minSponsoredAssetFee: LONG
+}
+```
+#### SetAssetScript transaction. Type 15
+```typescript
+export interface ISetAssetScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+  /**
+   * Compiled script encoded as base64 string
+   */
+  script: string
+  assetId: string
+}
+```
+#### InvokeScript transaction. Type 16
+```typescript
+export interface IInvokeScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+  dApp: string
+  feeAssetId?: string | null
+  call?: {
+    function: string
+    args?: {
+      type: 'binary' | 'integer' | 'boolean' | 'string',
+      value: string | LONG | boolean
+    }[]
+  },
+  payment?: {
+    assetId?: string | null
+    amount: LONG
+  }[]
+}
+```
+#### UpdateAssetInfo transaction. Type 17
+```typescript
+export interface IUpdateAssetInfoParams<LONG = string | number> extends IBasicParams<LONG> {
+  /**
+   * Id of previously issued asset
+   */
+  assetId: string
+  /**
+   * New asset name
+   */
+  name: string
+  /**
+   * New asset description
+   */
+  description: string
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+If you want to create  the minimum you need to provide is **amount** and **recipient** as defined in Transfer params:
+```js
+
+const { transfer } = require('@waves/waves-transactions')
+const seed = 'some example seed phrase'
+const signedTranserTx = transfer({ 
+  amount: 1,
+  recipient: '3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+  //Timestamp is optional but it was overrided, in case timestamp is not provided it will fallback to Date.now(). You can set any oftional params yourself. go check full docs
+  timestamp: 1536917842558 
+}, seed)
+
+// or using alias
+
+const signedTranserTx = transfer({ 
+  amount: 1,
+  recipient: 'alias:W:aliasForMyAddress'
+}, seed)
+```
+
+Output will be a signed transfer transaction:
+```js
+{
+  id: '8NrUwgKRCMFbUbqXKQAHkGnspmWHEjKUSi5opEC6Havq',
+  type: 4,
+  version: 2,
+  recipient: '3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+  attachment: undefined,
+  feeAssetId: undefined,
+  assetId: undefined,
+  amount: 1,
+  fee: 100000,
+  senderPublicKey: '6nR7CXVV7Zmt9ew11BsNzSvVmuyM5PF6VPbWHW9BHgPq',
+  timestamp: 1536917842558,
+  proofs: [
+    '25kyX6HGjS3rkPTJRj5NVH6LLuZe6SzCzFtoJ8GDkojY9U5oPfVrnwBgrCHXZicfsmLthPUjTrfT9TQL2ciYrPGE'
+  ]
+}
+```
+
+You can also create transaction, but not sign it:
+```javascript
+const unsignedTransferTx = transfer({ 
+  amount: 1,
+  recipient: '3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+  //senderPublicKey is required if you omit seed
+  senderPublicKey: '6nR7CXVV7Zmt9ew11BsNzSvVmuyM5PF6VPbWHW9BHgPq' 
+})
+```
+
+Now you are able to POST it to Waves API or store for future purpose or you can add another signature from other party:
+```js
+const otherPartySeed = 'other party seed phrase'
+const transferSignedWithTwoParties = transfer(signedTranserTx, seed)
+```
+
+So now there are two proofs:
+```js
+{
+  id: '8NrUwgKRCMFbUbqXKQAHkGnspmWHEjKUSi5opEC6Havq',
+  type: 4,
+  version: 2,
+  recipient: '3N4mLCaHq2twRKnbUjdvAHyXjoccQE9KDRE',
+  attachment: undefined,
+  feeAssetId: undefined,
+  assetId: undefined,
+  amount: 1,
+  fee: 100000,
+  senderPublicKey: '6nR7CXVV7Zmt9ew11BsNzSvVmuyM5PF6VPbWHW9BHgPq',
+  timestamp: 1536917842558,
+  proofs: [
+    '25kyX6HGjS3rkPTJRj5NVH6LLuZe6SzCzFtoJ8GDkojY9U5oPfVrnwBgrCHXZicfsmLthPUjTrfT9TQL2ciYrPGE',
+    'CM9emPzpe6Ram7ZxcYax6s7Hkw6698wXCMPSckveFAS2Yh9vqJpy1X9nL7p4RKgU3UEa8c9RGXfUK6mFFq4dL9z'
+  ]
+}
+```
+
+### Orders
+Order is created the same way as transaction
+```typescript
+const { order } = require('@waves/waves-transactions')
+const params = {
+    amount: 100000000, //1 waves
+    price: 10, //for 0.00000010 BTC
+    priceAsset: '8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS',
+    matcherPublicKey: '7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy',
+    orderType: 'buy'
+}
+  
+const signedOrder = order(params, 'Some seed ')
+```
+### Broadcast
+To send transaction you can use either node [REST API](https://nodes.wavesplatform.com/api-docs/index.html#!/transactions/broadcast) or [broadcast](https://wavesplatform.github.io/waves-transactions/globals.html#broadcast) helper function:
+```javascript
+const {broadcast} =  require('@waves/waves-transactions');
+const nodeUrl = 'https://nodes.wavesplatform.com';
+
+broadcast(signedTx, nodeUrl).then(resp => console.log(resp))
+```
+You can send tx to any waves node you like:. E.g.:
+* https://nodes-testnet.wavesnodes.com - waves TESTNET nodes hosted by Wavesplatform
+* https://nodes.wavesplatform.com - waves MAINNET nodes hosted by Wavesplatform
+#### Important!!!
+Most transactions require chainId as parameter, e.g: [IBurnParams](https://wavesplatform.github.io/waves-transactions/interfaces/_transactions_.iburnparams.html). By default chainId is 'W', which means MAINNET. To make transaction in TESTNET be sure to pass chainId if it is present in params interface and then send it to TESTNET node
+
+### Dependencies
+This library uses `@waves/ts-lib-crypto` for cryptography and `@waves/node-api-js` for interacting with node. 
+You can access them this way:
+```typescript
+const libCrypto = require('@waves/waves-transactions').libs.crypto
+const libApi = require('@waves/waves-transactions').libs.nodeApiJs
+```

data/js/node_modules/@waves/waves-transactions/dist/defaultVersions.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_VERSIONS: {
+    ISSUE: number;
+    TRANSFER: number;
+    REISSUE: number;
+    BURN: number;
+    EXCHANGE: number;
+    LEASE: number;
+    CANCEL_LEASE: number;
+    ALIAS: number;
+    MASS_TRANSFER: number;
+    DATA: number;
+    SET_SCRIPT: number;
+    SPONSORSHIP: number;
+    SET_ASSET_SCRIPT: number;
+    INVOKE_SCRIPT: number;
+    UPDATE_ASSET_INFO: number;
+    INVOKE_EXPRESSION: number;
+};

data/js/node_modules/@waves/waves-transactions/dist/defaultVersions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_VERSIONS = void 0;
+exports.DEFAULT_VERSIONS = {
+    ISSUE: 3,
+    TRANSFER: 3,
+    REISSUE: 3,
+    BURN: 3,
+    EXCHANGE: 3,
+    LEASE: 3,
+    CANCEL_LEASE: 3,
+    ALIAS: 3,
+    MASS_TRANSFER: 2,
+    DATA: 2,
+    SET_SCRIPT: 2,
+    SPONSORSHIP: 2,
+    SET_ASSET_SCRIPT: 2,
+    INVOKE_SCRIPT: 2,
+    UPDATE_ASSET_INFO: 1,
+    INVOKE_EXPRESSION: 1,
+};
+//# sourceMappingURL=defaultVersions.js.map

data/js/node_modules/@waves/waves-transactions/dist/defaultVersions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultVersions.js","sourceRoot":"","sources":["../src/defaultVersions.ts"],"names":[],"mappings":";;;AAAa,QAAA,gBAAgB,GAAG;IAC5B,KAAK,EAAE,CAAC;IACR,QAAQ,EAAE,CAAC;IACX,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,QAAQ,EAAE,CAAC;IACX,KAAK,EAAE,CAAC;IACR,YAAY,EAAE,CAAC;IACf,KAAK,EAAE,CAAC;IACR,aAAa,EAAE,CAAC;IAChB,IAAI,EAAE,CAAC;IACP,UAAU,EAAE,CAAC;IACb,WAAW,EAAE,CAAC;IACd,gBAAgB,EAAE,CAAC;IACnB,aAAa,EAAE,CAAC;IAChB,iBAAiB,EAAE,CAAC;IACpB,iBAAiB,EAAE,CAAC;CACvB,CAAA"}

data/js/node_modules/@waves/waves-transactions/dist/general.d.ts

@@ -0,0 +1,68 @@
+import { TSeedTypes } from './types';
+import { TSignedData } from './requests/custom-data';
+import { ExchangeTransactionOrder, SignedIExchangeTransactionOrder, SignedTransaction, Transaction } from '@waves/ts-types';
+import { IAuthParams, ICancelOrder, TTransaction, TTxParams, WithProofs, WithSender, WithTxType } from './transactions';
+declare type TLong = string | number;
+export declare const txTypeMap: {
+    [type: number]: {
+        sign: (tx: Transaction<TLong> | (TTxParams & WithTxType), seed: TSeedTypes) => SignedTransaction<Transaction<TLong>>;
+    };
+};
+/**
+ * Signs arbitrary transaction. Can also create signed transaction if provided params have type field
+ * @param tx
+ * @param seed
+ */
+export declare function signTx(tx: Transaction | TTxParams & WithTxType, seed: TSeedTypes): SignedTransaction<Transaction>;
+/**
+ * Converts transaction or order object to Uint8Array
+ * @param obj transaction or order
+ */
+export declare function serialize(obj: Transaction | SignedIExchangeTransactionOrder<ExchangeTransactionOrder>): Uint8Array;
+/**
+ * Verifies signature of transaction or order
+ * @param obj
+ * @param proofN - proof index. Takes first proof by default
+ * @param publicKey - takes senderPublicKey by default
+ */
+export declare function verify(obj: (TTransaction & WithProofs) | SignedIExchangeTransactionOrder<ExchangeTransactionOrder>, proofN?: number, publicKey?: string): boolean;
+export declare function verifyCustomData(data: TSignedData): boolean;
+export declare function verifyAuthData(authData: {
+    signature: string;
+    publicKey: string;
+    address: string;
+}, params: IAuthParams, chainId?: string | number): boolean;
+export declare function verifyWavesAuthData(authData: {
+    signature: string;
+    publicKey: string;
+    address: string;
+    timestamp: number;
+}, params: {
+    publicKey: string;
+    timestamp: number;
+}, chainId?: string | number): boolean;
+/**
+ * Sends order to matcher
+ * @param ord - transaction to send
+ * @param options - matcher address to send order to. E.g. https://matcher.waves.exchange/. Optional 'market' flag to send market order
+ */
+export declare function submitOrder(ord: ExchangeTransactionOrder & WithProofs & WithSender, options: {
+    matcherUrl: string;
+    market?: boolean;
+}): Promise<any>;
+/**
+ * Sends order to matcher
+ * @param ord - transaction to send
+ * @param matcherUrl - matcher address to send order to. E.g. https://matcher.waves.exchange/
+ */
+export declare function submitOrder(ord: ExchangeTransactionOrder & WithProofs & WithSender, matcherUrl: string): Promise<any>;
+/**
+ * Sends cancel order command to matcher. Since matcher api requires amountAsset and priceAsset in request url,
+ * this function requires them as params
+ * @param co - signed cancelOrder object
+ * @param amountAsset - amount asset of the order to be canceled
+ * @param priceAsset - price asset of the order to be canceled
+ * @param matcherUrl - matcher address to send order cancel to. E.g. https://matcher.waves.exchange/
+ */
+export declare function cancelSubmittedOrder(co: ICancelOrder, amountAsset: string | null, priceAsset: string | null, matcherUrl: string): Promise<unknown>;
+export {};

data/js/node_modules/@waves/waves-transactions/dist/general.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelSubmittedOrder = exports.submitOrder = exports.verifyWavesAuthData = exports.verifyAuthData = exports.verifyCustomData = exports.verify = exports.serialize = exports.signTx = exports.txTypeMap = void 0;
+const marshall_1 = require("@waves/marshall");
+const ts_lib_crypto_1 = require("@waves/ts-lib-crypto");
+const request_1 = __importDefault(require("@waves/node-api-js/cjs/tools/request"));
+const stringify_1 = __importDefault(require("@waves/node-api-js/cjs/tools/stringify"));
+const issue_1 = require("./transactions/issue");
+const transfer_1 = require("./transactions/transfer");
+const reissue_1 = require("./transactions/reissue");
+const burn_1 = require("./transactions/burn");
+const lease_1 = require("./transactions/lease");
+const cancel_lease_1 = require("./transactions/cancel-lease");
+const data_1 = require("./transactions/data");
+const mass_transfer_1 = require("./transactions/mass-transfer");
+const alias_1 = require("./transactions/alias");
+const set_script_1 = require("./transactions/set-script");
+const generic_1 = require("./generic");
+const set_asset_script_1 = require("./transactions/set-asset-script");
+const exchange_1 = require("./transactions/exchange");
+const sponsorship_1 = require("./transactions/sponsorship");
+const invoke_script_1 = require("./transactions/invoke-script");
+const custom_data_1 = require("./requests/custom-data");
+const auth_1 = require("./requests/auth");
+const wavesAuth_1 = require("./requests/wavesAuth");
+const ts_types_1 = require("@waves/ts-types");
+const update_asset_info_1 = require("./transactions/update-asset-info");
+exports.txTypeMap = {
+    [ts_types_1.TRANSACTION_TYPE.ISSUE]: { sign: (x, seed) => issue_1.issue(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.TRANSFER]: { sign: (x, seed) => transfer_1.transfer(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.REISSUE]: { sign: (x, seed) => reissue_1.reissue(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.BURN]: { sign: (x, seed) => burn_1.burn(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.LEASE]: { sign: (x, seed) => lease_1.lease(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.CANCEL_LEASE]: { sign: (x, seed) => cancel_lease_1.cancelLease(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.ALIAS]: { sign: (x, seed) => alias_1.alias(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.MASS_TRANSFER]: { sign: (x, seed) => mass_transfer_1.massTransfer(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.DATA]: { sign: (x, seed) => data_1.data(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.SET_SCRIPT]: { sign: (x, seed) => set_script_1.setScript(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.SET_ASSET_SCRIPT]: { sign: (x, seed) => set_asset_script_1.setAssetScript(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.SPONSORSHIP]: { sign: (x, seed) => sponsorship_1.sponsorship(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.EXCHANGE]: { sign: (x, seed) => exchange_1.exchange(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.INVOKE_SCRIPT]: { sign: (x, seed) => invoke_script_1.invokeScript(x, seed) },
+    [ts_types_1.TRANSACTION_TYPE.UPDATE_ASSET_INFO]: { sign: (x, seed) => update_asset_info_1.updateAssetInfo(x, seed) },
+};
+/**
+ * Signs arbitrary transaction. Can also create signed transaction if provided params have type field
+ * @param tx
+ * @param seed
+ */
+function signTx(tx, seed) {
+    if (!exports.txTypeMap[tx.type])
+        throw new Error(`Unknown tx type: ${tx.type}`);
+    return exports.txTypeMap[tx.type].sign(tx, seed);
+}
+exports.signTx = signTx;
+/**
+ * Converts transaction or order object to Uint8Array
+ * @param obj transaction or order
+ */
+function serialize(obj) {
+    if (generic_1.isOrder(obj))
+        return marshall_1.binary.serializeOrder(obj);
+    return marshall_1.binary.serializeTx(obj);
+}
+exports.serialize = serialize;
+/**
+ * Verifies signature of transaction or order
+ * @param obj
+ * @param proofN - proof index. Takes first proof by default
+ * @param publicKey - takes senderPublicKey by default
+ */
+function verify(obj, proofN = 0, publicKey) {
+    publicKey = publicKey || obj.senderPublicKey;
+    const bytes = serialize(obj);
+    const signature = obj.version == null ? obj.signature : obj.proofs[proofN];
+    return ts_lib_crypto_1.verifySignature(publicKey, bytes, signature);
+}
+exports.verify = verify;
+function verifyCustomData(data) {
+    const bytes = custom_data_1.serializeCustomData(data);
+    return ts_lib_crypto_1.verifySignature(data.publicKey, bytes, data.signature);
+}
+exports.verifyCustomData = verifyCustomData;
+function verifyAuthData(authData, params, chainId) {
+    chainId = chainId || 'W';
+    const bytes = auth_1.serializeAuthData(params);
+    const myAddress = ts_lib_crypto_1.address({ publicKey: authData.publicKey }, chainId);
+    return myAddress === authData.address && ts_lib_crypto_1.verifySignature(authData.publicKey, bytes, authData.signature);
+}
+exports.verifyAuthData = verifyAuthData;
+function verifyWavesAuthData(authData, params, chainId) {
+    chainId = chainId || 'W';
+    const bytes = wavesAuth_1.serializeWavesAuthData(params);
+    const myAddress = ts_lib_crypto_1.address({ publicKey: authData.publicKey }, chainId);
+    return myAddress === authData.address && ts_lib_crypto_1.verifySignature(authData.publicKey, bytes, authData.signature);
+}
+exports.verifyWavesAuthData = verifyWavesAuthData;
+function submitOrder(ord, opts) {
+    let endpoint, matcherUrl;
+    if (typeof opts === 'string') {
+        matcherUrl = opts;
+        endpoint = 'matcher/orderbook';
+    }
+    else {
+        matcherUrl = opts.matcherUrl;
+        endpoint = opts.market ? 'matcher/orderbook/market' : 'matcher/orderbook';
+    }
+    return request_1.default({
+        base: matcherUrl,
+        url: endpoint,
+        options: { method: 'POST', body: stringify_1.default(ord), headers: { 'Content-Type': 'application/json' } },
+    });
+}
+exports.submitOrder = submitOrder;
+/**
+ * Sends cancel order command to matcher. Since matcher api requires amountAsset and priceAsset in request url,
+ * this function requires them as params
+ * @param co - signed cancelOrder object
+ * @param amountAsset - amount asset of the order to be canceled
+ * @param priceAsset - price asset of the order to be canceled
+ * @param matcherUrl - matcher address to send order cancel to. E.g. https://matcher.waves.exchange/
+ */
+function cancelSubmittedOrder(co, amountAsset, priceAsset, matcherUrl) {
+    const endpoint = `matcher/orderbook/${amountAsset || 'WAVES'}/${priceAsset || 'WAVES'}/cancel`;
+    return request_1.default({
+        base: matcherUrl,
+        url: endpoint,
+        options: { method: 'POST', body: stringify_1.default(co), headers: { 'Content-Type': 'application/json' } },
+    });
+}
+exports.cancelSubmittedOrder = cancelSubmittedOrder;
+//# sourceMappingURL=general.js.map