waves_lib 0.1.0

data/js/node_modules/@waves/waves-transactions/src/requests/custom-data.ts

@@ -0,0 +1,73 @@
+/**
+ * @module index
+ */
+import { signBytes, blake2b, base58Encode, publicKey, concat, TSeed } from '@waves/ts-lib-crypto'
+import { schemas, serializePrimitives } from '@waves/marshall'
+import { binary } from '@waves/marshall'
+import { validate } from '../validators'
+import { TPrivateKey } from '../types'
+import {DataFiledType, DataTransactionEntry} from '@waves/ts-types'
+import {DataTransactionDeleteRequest} from '@waves/ts-types/src/parts'
+
+export interface ICustomDataV1 {
+  version: 1
+  /**
+   * base64 encoded UInt8Array
+   */
+  binary: string // base64
+
+  publicKey?: string
+}
+
+export interface ICustomDataV2 {
+  version: 2
+  data: Exclude<DataTransactionEntry, DataTransactionDeleteRequest>[]
+  publicKey?: string
+}
+
+export type TCustomData = ICustomDataV1 | ICustomDataV2
+
+export type TSignedData = TCustomData & {
+  /**
+   * base58 public key
+   */
+  publicKey: string | undefined
+  /**
+   * base58 encoded blake2b(serialized data)
+   */
+  hash: string
+  /**
+   * base58 encoded signature
+   */
+  signature: string | undefined
+}
+
+/**
+ * Signs [[TCustomData]]
+ */
+export function customData(cData: TCustomData, seed?: TSeed | TPrivateKey): TSignedData {
+
+  validate.customData(cData)
+
+  let bytes = serializeCustomData(cData)
+
+  const hash = base58Encode(blake2b(bytes))
+
+  const pk = cData.publicKey ? cData.publicKey : seed && publicKey(seed)
+
+  const signature = seed && signBytes(seed, bytes)
+
+  return {...cData, hash, publicKey: pk, signature}
+}
+
+export function serializeCustomData(d: TCustomData){
+  if (d.version === 1) {
+    return concat([255, 255, 255, 1], serializePrimitives.BASE64_STRING(d.binary))
+  } else if (d.version === 2) {
+    const ser = binary.serializerFromSchema(schemas.txFields.data[1])
+    return concat([255, 255, 255, 2], ser(d.data))
+  } else {
+    //@ts-ignore
+    throw new Error(`Invalid CustomData version: ${d!.version}`)
+  }
+}

data/js/node_modules/@waves/waves-transactions/src/requests/order.ts

@@ -0,0 +1,121 @@
+/**
+ * @module index
+ */
+import {signBytes, blake2b, base58Encode} from '@waves/ts-lib-crypto'
+import {addProof, getSenderPublicKey, convertToPairs, isOrder, networkByte} from '../generic'
+import {IOrderParams, WithId, WithProofs, WithSender} from '../transactions'
+import {TSeedTypes} from '../types'
+import {binary} from '@waves/marshall'
+import {validate} from '../validators'
+import {ExchangeTransactionOrder, SignedIExchangeTransactionOrder} from '@waves/ts-types'
+import {orderToProtoBytes} from '../proto-serialize'
+
+
+/**
+ * Creates and signs [[TOrder]].
+ *
+ * You can use this function with multiple seeds. In this case it will sign order accordingly and will add one proof per seed.
+ * Also you can use already signed [[Order]] as a second agrument.
+ *
+ * ### Usage
+ * ```js
+ * const { order } = require('@waves/waves-transactions')
+ *
+ * const seed = 'b716885e9ba64442b4f1263c8e2d8671e98b800c60ec4dc2a27c83e5f9002b18'
+ *
+ * const params = {
+ *   amount: 100000000, //1 waves
+ *   price: 10, //for 0.00000010 BTC
+ *   priceAsset: '8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS',
+ *   matcherPublicKey: '7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy',
+ *   orderType: 'buy'
+ * }
+ *
+ *
+ * const signedOrder = order(params, seed)
+ * ```
+ * ### Output
+ * ```json
+ * {
+ *   "id": "47YGqHdHtNPjcjE69E9EX9aD9bpC8PRKr4kp5AcZKHFq",
+ *   "orderType": "buy",
+ *   "assetPair": {
+ *     "priceAsset": "8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS"
+ *   },
+ *   "price": 10,
+ *   "amount": 100000000,
+ *   "timestamp": 1540898977249,
+ *   "expiration": 1542626977249,
+ *   "matcherFee": 300000,
+ *   "matcherPublicKey": "7kPFrHDiGw1rCm7LPszuECwWYL3dMf6iMifLRDJQZMzy",
+ *   "senderPublicKey": "G62H1XE5rnaCgCCURV5pWwQHzWezZB7VkkVgqthdKgkj",
+ *   "proofs": [
+ *     "4MbaDLkx9ezV1DrcGRfXRfnMBtYLaeLYBe6YGqkkuq1Pe6U9Qc5Cv7Fy1zYyGatbg47U5j374iAQFbLLZiYBChgU"
+ *   ]
+ * }
+ * ```
+ *
+ */
+export function order(paramsOrOrder: IOrderParams, seed: TSeedTypes): SignedIExchangeTransactionOrder<ExchangeTransactionOrder>
+export function order(paramsOrOrder: IOrderParams & WithSender | ExchangeTransactionOrder & WithProofs & WithSender, seed?: TSeedTypes): SignedIExchangeTransactionOrder<ExchangeTransactionOrder>
+export function order(paramsOrOrder: any, seed?: TSeedTypes): SignedIExchangeTransactionOrder<ExchangeTransactionOrder> {
+
+    const amountAsset = isOrder(paramsOrOrder) ? paramsOrOrder.assetPair.amountAsset : paramsOrOrder.amountAsset
+    const priceAsset = isOrder(paramsOrOrder) ? paramsOrOrder.assetPair.priceAsset : paramsOrOrder.priceAsset
+    const proofs = isOrder(paramsOrOrder) ? paramsOrOrder.proofs : []
+
+    const {matcherFee, matcherPublicKey, price, amount, orderType, expiration, timestamp} = paramsOrOrder
+    const t = timestamp || Date.now()
+
+    const seedsAndIndexes = convertToPairs(seed)
+    const senderPublicKey = paramsOrOrder.senderPublicKey || getSenderPublicKey(seedsAndIndexes, paramsOrOrder)
+
+    // Use old versionless order only if it is set to null explicitly
+    const version = paramsOrOrder.version === null ? undefined : paramsOrOrder.version
+    const ord: SignedIExchangeTransactionOrder<ExchangeTransactionOrder> & WithId & WithProofs = {
+        orderType,
+        version,
+        assetPair: {
+            amountAsset,
+            priceAsset,
+        },
+        price,
+        amount,
+        timestamp: t,
+        expiration: expiration || t + 29 * 24 * 60 * 60 * 1000,
+        matcherFee: matcherFee || 300000,
+        matcherPublicKey,
+        senderPublicKey,
+        proofs,
+        matcherFeeAssetId: null,
+        id: '',
+        priceMode: paramsOrOrder.priceMode,
+    }
+
+    if (ord.version >= 3) {
+        ord.matcherFeeAssetId = paramsOrOrder.matcherFeeAssetId === 'WAVES' ? null : paramsOrOrder.matcherFeeAssetId
+    }
+
+    if (ord.version === 4) {
+        ord.priceMode = paramsOrOrder.priceMode || 'fixedDecimals'
+        // @ts-ignore
+        ord.chainId = networkByte(paramsOrOrder.chainId, 87)
+        if (paramsOrOrder.eip712Signature) ord.eip712Signature = paramsOrOrder.eip712Signature
+    }
+
+    const bytes = ord.version > 3 ? orderToProtoBytes(ord) : binary.serializeOrder(ord)
+
+    seedsAndIndexes.forEach(([s, i]) => addProof(ord, signBytes(s, bytes), i))
+
+    validate.order(ord)
+
+    ord.id = base58Encode(blake2b(bytes))
+
+    // OrderV1 uses signature instead of proofs
+    // @ts-ignore
+    if (ord.version === undefined || ord.version === 1) (ord as any).signature = ord.proofs && ord.proofs[0]
+
+    return ord
+}
+
+

data/js/node_modules/@waves/waves-transactions/src/requests/wavesAuth.ts

@@ -0,0 +1,40 @@
+/**
+ * @module index
+ */
+import {base58Encode, blake2b, concat, signBytes, address} from '@waves/ts-lib-crypto'
+import {serializePrimitives} from '@waves/marshall'
+
+const {LONG, BASE58_STRING} = serializePrimitives
+import {getSenderPublicKey, convertToPairs} from '../generic'
+import {IWavesAuthParams, IWavesAuth} from '../transactions'
+import {validate} from '../validators'
+import {TSeedTypes} from '../types'
+
+export const serializeWavesAuthData = (auth: { publicKey: string; timestamp: number }) => concat(
+    BASE58_STRING(auth.publicKey),
+    LONG(auth.timestamp)
+)
+
+export function wavesAuth(params: IWavesAuthParams, seed?: TSeedTypes, chainId?: string | number): IWavesAuth {
+    const seedsAndIndexes = convertToPairs(seed)
+    const publicKey = params.publicKey || getSenderPublicKey(seedsAndIndexes, {senderPublicKey: undefined})
+    const timestamp = params.timestamp || Date.now()
+    validate.wavesAuth({publicKey, timestamp})
+
+    const rx = {
+        hash: '',
+        signature: '',
+        timestamp,
+        publicKey,
+        address: address({publicKey}, chainId),
+    }
+
+    const bytes = serializeWavesAuthData(rx)
+
+    rx.signature = seedsAndIndexes.map(([seed]) => signBytes(seed, bytes))[0] || ''
+    rx.hash = base58Encode(blake2b(Uint8Array.from(bytes)))
+
+    return rx
+}
+
+

data/js/node_modules/@waves/waves-transactions/src/seedUtils/index.ts

@@ -0,0 +1,124 @@
+/**
+ * @module seedUtils
+ */
+import {
+  address,
+  privateKey,
+  publicKey,
+  sha256,
+  base16Encode,
+  encryptSeed,
+  decryptSeed,
+  randomSeed
+} from '@waves/ts-lib-crypto'
+import { serializePrimitives } from '@waves/marshall'
+
+export class Seed {
+
+  public readonly phrase: string
+  public readonly address: string
+  public readonly keyPair: {
+    publicKey: string,
+    privateKey: string
+  }
+
+  constructor(phrase: string, chainId?: string) {
+    if (phrase.length < 12) {
+      throw new Error('Your seed length is less than allowed in config')
+    }
+
+
+    this.phrase = phrase
+    this.address = address(phrase, chainId)
+    this.keyPair = {
+      privateKey: privateKey(phrase),
+      publicKey: publicKey(phrase),
+    }
+
+    Object.freeze(this)
+    Object.freeze(this.keyPair)
+  }
+
+  public encrypt(password: string, encryptionRounds?: number) {
+    return Seed.encryptSeedPhrase(this.phrase, password, encryptionRounds)
+  }
+
+  public static encryptSeedPhrase(seedPhrase: string, password: string, encryptionRounds: number = 5000): string {
+    if (password && password.length < 8) {
+      // logger.warn('Your password may be too weak');
+    }
+
+    if (encryptionRounds < 1000) {
+      // logger.warn('Encryption rounds may be too few');
+    }
+
+    if (seedPhrase.length < 12) {
+      throw new Error('The seed phrase you are trying to encrypt is too short')
+    }
+
+    return encryptSeed(seedPhrase, password, encryptionRounds)
+  }
+
+  public static decryptSeedPhrase(encryptedSeedPhrase: string, password: string, encryptionRounds: number = 5000): string {
+
+    const wrongPasswordMessage = 'The password is wrong'
+
+    let phrase
+
+    try {
+      phrase = decryptSeed(encryptedSeedPhrase, password, encryptionRounds)
+    } catch (e) {
+      throw new Error(wrongPasswordMessage)
+    }
+
+    if (phrase === '' || phrase.length < 12) {
+      throw new Error(wrongPasswordMessage)
+    }
+
+    return phrase
+
+  }
+
+  public static create(words: number = 15): Seed {
+    const phrase = generateNewSeed(words)
+    const minimumSeedLength = 12
+
+    if (phrase.length < minimumSeedLength) {
+      // If you see that error you should increase the number of words in the generated seed
+      throw new Error(`The resulted seed length is less than the minimum length (${minimumSeedLength})`)
+    }
+
+    return new Seed(phrase)
+  }
+
+  public static fromExistingPhrase(phrase: string): Seed {
+    const minimumSeedLength = 12
+
+    if (phrase.length < minimumSeedLength) {
+      // If you see that error you should increase the number of words or set it lower in the config
+      throw new Error(`The resulted seed length is less than the minimum length (${minimumSeedLength})`)
+    }
+
+    return new Seed(phrase)
+  }
+
+}
+
+
+export function generateNewSeed(length = 15) {
+  return randomSeed(length)
+}
+
+
+export function strengthenPassword(password: string, rounds: number = 5000): string {
+  while (rounds--) {
+    const bytes = serializePrimitives.STRING(password)
+    password = base16Encode(sha256(bytes))
+  }
+  return password
+}
+
+export {
+  encryptSeed,
+  decryptSeed
+}

data/js/node_modules/@waves/waves-transactions/src/transactions/alias.ts

@@ -0,0 +1,46 @@
+/**
+ * @module index
+ */
+import {IAliasParams, WithId, WithProofs, WithSender} from '../transactions'
+import {binary} from '@waves/marshall'
+import {base58Encode, blake2b, signBytes} from '@waves/ts-lib-crypto'
+import {txToProtoBytes} from '../proto-serialize'
+import {addProof, convertToPairs, fee, getSenderPublicKey, networkByte} from '../generic'
+import {TSeedTypes} from '../types'
+import {validate} from '../validators'
+import {DEFAULT_VERSIONS} from '../defaultVersions'
+import {AliasTransaction, TRANSACTION_TYPE} from '@waves/ts-types'
+
+
+/* @echo DOCS */
+export function alias(params: IAliasParams, seed: TSeedTypes): AliasTransaction & WithId & WithProofs
+export function alias(paramsOrTx: IAliasParams & WithSender | AliasTransaction, seed?: TSeedTypes): AliasTransaction & WithId & WithProofs
+export function alias(paramsOrTx: any, seed?: TSeedTypes): AliasTransaction & WithId & WithProofs {
+    const type = TRANSACTION_TYPE.ALIAS
+    const version = paramsOrTx.version || DEFAULT_VERSIONS.ALIAS
+    const seedsAndIndexes = convertToPairs(seed)
+    const senderPublicKey = getSenderPublicKey(seedsAndIndexes, paramsOrTx)
+
+    const tx: AliasTransaction & WithId & WithProofs = {
+        type,
+        version,
+        senderPublicKey,
+        alias: paramsOrTx.alias,
+        fee: fee(paramsOrTx, 100000),
+        timestamp: paramsOrTx.timestamp || Date.now(),
+        chainId: networkByte(paramsOrTx.chainId, 87),
+        proofs: paramsOrTx.proofs || [],
+        id: '',
+    }
+
+    validate.alias(tx)
+
+    const bytes = version > 2 ? txToProtoBytes(tx) : binary.serializeTx(tx)
+    const idBytes = version > 2 ? bytes : [bytes[0], ...bytes.slice(36, -16)]
+
+    seedsAndIndexes.forEach(([s, i]) => addProof(tx, signBytes(s, bytes), i))
+
+    tx.id = base58Encode(blake2b(Uint8Array.from(idBytes)))
+
+    return tx
+}

data/js/node_modules/@waves/waves-transactions/src/transactions/burn.ts

@@ -0,0 +1,45 @@
+/**
+ * @module index
+ */
+import {IBurnParams, WithId, WithProofs, WithSender} from '../transactions'
+import { binary } from '@waves/marshall'
+import { signBytes, blake2b, base58Encode } from '@waves/ts-lib-crypto'
+import {addProof, getSenderPublicKey, convertToPairs, networkByte, fee, normalizeAssetId} from '../generic'
+import { TSeedTypes } from '../types'
+import { validate } from '../validators'
+import { txToProtoBytes } from '../proto-serialize'
+import { DEFAULT_VERSIONS } from '../defaultVersions'
+import {BurnTransaction, TRANSACTION_TYPE} from '@waves/ts-types'
+
+
+/* @echo DOCS */
+export function burn(params: IBurnParams, seed: TSeedTypes): BurnTransaction & WithId & WithProofs
+export function burn(paramsOrTx: IBurnParams & WithSender | BurnTransaction, seed?: TSeedTypes): BurnTransaction & WithId & WithProofs
+export function burn(paramsOrTx: any, seed?: TSeedTypes): BurnTransaction & WithId & WithProofs{
+  const type = TRANSACTION_TYPE.BURN
+  const version = paramsOrTx.version || DEFAULT_VERSIONS.BURN
+  const seedsAndIndexes = convertToPairs(seed)
+  const senderPublicKey = getSenderPublicKey(seedsAndIndexes, paramsOrTx)
+
+  const tx: BurnTransaction & WithId & WithProofs = {
+    type,
+    version,
+    senderPublicKey,
+    assetId: paramsOrTx.assetId,
+    amount: paramsOrTx.amount,
+    chainId: networkByte(paramsOrTx.chainId, 87),
+    fee: fee(paramsOrTx, 100000),
+    timestamp: paramsOrTx.timestamp || Date.now(),
+    proofs: paramsOrTx.proofs || [],
+    id: '',
+  }
+
+  validate.burn(tx)
+
+  const bytes = version > 2 ? txToProtoBytes(tx) : binary.serializeTx(tx)
+
+  seedsAndIndexes.forEach(([s, i]) => addProof(tx, signBytes(s, bytes), i))
+  tx.id = base58Encode(blake2b(bytes))
+
+  return tx
+}

data/js/node_modules/@waves/waves-transactions/src/transactions/cancel-lease.ts

@@ -0,0 +1,44 @@
+/**
+ * @module index
+ */
+import {ICancelLeaseParams, WithId, WithProofs, WithSender} from '../transactions'
+import { binary } from '@waves/marshall'
+import { signBytes, blake2b, base58Encode } from '@waves/ts-lib-crypto'
+import {addProof, getSenderPublicKey, convertToPairs, networkByte, fee} from '../generic'
+import { TSeedTypes } from '../types'
+import { validate } from '../validators'
+import { txToProtoBytes } from '../proto-serialize'
+import { DEFAULT_VERSIONS } from '../defaultVersions'
+import {CancelLeaseTransaction, TRANSACTION_TYPE} from '@waves/ts-types'
+
+
+/* @echo DOCS */
+export function cancelLease(params: ICancelLeaseParams, seed: TSeedTypes): CancelLeaseTransaction & WithId & WithProofs
+export function cancelLease(paramsOrTx: ICancelLeaseParams & WithSender | CancelLeaseTransaction, seed?: TSeedTypes): CancelLeaseTransaction & WithId & WithProofs
+export function cancelLease(paramsOrTx: any, seed?: TSeedTypes): CancelLeaseTransaction & WithId & WithProofs{
+  const type = TRANSACTION_TYPE.CANCEL_LEASE
+  const version = paramsOrTx.version || DEFAULT_VERSIONS.CANCEL_LEASE
+  const seedsAndIndexes = convertToPairs(seed)
+  const senderPublicKey = getSenderPublicKey(seedsAndIndexes, paramsOrTx)
+
+  const tx: CancelLeaseTransaction & WithId & WithProofs = {
+    type,
+    version,
+    senderPublicKey,
+    leaseId: paramsOrTx.leaseId,
+    fee: fee(paramsOrTx, 100000),
+    timestamp: paramsOrTx.timestamp || Date.now(),
+    chainId: networkByte(paramsOrTx.chainId, 87),
+    proofs: paramsOrTx.proofs || [],
+    id: '',
+  }
+
+  validate.cancelLease(tx)
+
+  const bytes = version > 2 ? txToProtoBytes(tx) : binary.serializeTx(tx)
+
+  seedsAndIndexes.forEach(([s, i]) => addProof(tx, signBytes(s, bytes), i))
+  tx.id = base58Encode(blake2b(bytes))
+
+  return tx
+}

data/js/node_modules/@waves/waves-transactions/src/transactions/data.ts

@@ -0,0 +1,122 @@
+/**
+ * @module index
+ */
+import * as wavesProto from '@waves/protobuf-serialization'
+import {binary, serializePrimitives} from '@waves/marshall'
+import {base58Encode, blake2b, concat, signBytes} from '@waves/ts-lib-crypto'
+import {IDataParams, WithId, WithProofs, WithSender} from '../transactions'
+import {addProof, convertToPairs, fee, getSenderPublicKey, networkByte} from '../generic'
+import {TSeedTypes} from '../types'
+import {validate} from '../validators'
+import {dataEntryToProto, txToProtoBytes} from '../proto-serialize'
+import {DEFAULT_VERSIONS} from '../defaultVersions'
+import {DataFiledType, DataTransaction, DataTransactionEntry, TRANSACTION_TYPE} from '@waves/ts-types'
+
+const {
+    BASE58_STRING,
+    BASE64_STRING,
+    BYTE,
+    BYTES,
+    COUNT,
+    LEN,
+    LONG,
+    SHORT,
+    STRING,
+} = serializePrimitives
+
+const typeMap: any = {
+    integer: ['integer', 0, LONG],
+    number: ['integer', 0, LONG],
+    boolean: ['boolean', 1, BYTE],
+    string: ['string', 3, LEN(SHORT)(STRING)],
+    binary: ['binary', 2, (s: string) => LEN(SHORT)(BASE64_STRING)(s)],
+    _: ['binary', 2, LEN(SHORT)(BYTES)],
+}
+
+const mapType = <T>(value: T, type: string | undefined | null): [DataFiledType, number, (value: T) => Uint8Array] => {
+    return !!type ? typeMap[type] : typeMap[typeof value] || typeMap['_']
+}
+
+const convertValue = (type: 'integer' | 'string' | 'binary' | 'boolean', value: Uint8Array | string | number | boolean, opt: string) => {
+    return type === 'binary' && (Uint8Array.prototype.isPrototypeOf(value) || Array.isArray(value))
+        ? 'base64:' + Buffer.from(value as unknown as any[]).toString('base64')
+        : value
+}
+
+/* @echo DOCS */
+export function data(params: IDataParams, seed: TSeedTypes): DataTransaction & WithId & WithProofs
+export function data(paramsOrTx: IDataParams & WithSender | DataTransaction, seed?: TSeedTypes): DataTransaction & WithId & WithProofs
+export function data(paramsOrTx: any, seed?: TSeedTypes): DataTransaction & WithId & WithProofs {
+    const type = TRANSACTION_TYPE.DATA
+    const version = paramsOrTx.version || DEFAULT_VERSIONS.DATA
+    const seedsAndIndexes = convertToPairs(seed)
+    const senderPublicKey = getSenderPublicKey(seedsAndIndexes, paramsOrTx)
+
+    if (!Array.isArray(paramsOrTx.data)) throw new Error('["data should be array"]')
+
+    if (paramsOrTx.data.some((x: any) => x.value === null) && paramsOrTx.version === 1) throw new Error('The value of the "value" field can only be null in a version greater than 1.')
+
+    const _timestamp = paramsOrTx.timestamp || Date.now()
+
+    const dataEntriesWithTypes = (paramsOrTx.data as any ?? []).map((x: DataTransactionEntry) => {
+        if (x.value == null) return x
+        if ((<any>x).type) {
+            if(validate.dataFieldValidator(x)) {
+            return {
+                ...x,
+                value: convertValue(x.type, x.value, 'defined'),
+            }} else throw new Error(`type "${x.type}" does not match value "${x.value}"(${typeof x.value})`)
+        } else {
+            const type = mapType(x.value, x.type)[0]
+
+            return {
+                type,
+                key: x.key,
+                value: convertValue(type, x.value, 'not defined'),
+            }
+        }
+    })
+
+    const schema = (x: DataTransactionEntry) => {
+        return concat(LEN(SHORT)(STRING)(x.key), [mapType(x.value, x.type)[1]], mapType(x.value, x.type)[2](x.value))
+    }
+
+    let computedFee
+    if (version < 2) {
+        let bytes = concat(
+            BYTE(TRANSACTION_TYPE.DATA),
+            BYTE(1),
+            BASE58_STRING(senderPublicKey),
+            COUNT(SHORT)(schema)(dataEntriesWithTypes),
+            LONG(_timestamp)
+        )
+
+        computedFee = (Math.floor(1 + (bytes.length - 1) / 1024) * 100000)
+    } else {
+        let protoEntries = dataEntriesWithTypes.map(dataEntryToProto)
+        let dataBytes = wavesProto.waves.DataTransactionData.encode({data: protoEntries}).finish()
+        computedFee = (Math.ceil(dataBytes.length / 1024) * 100000)
+    }
+
+
+    const tx: DataTransaction & WithId & WithProofs = {
+        type,
+        version,
+        senderPublicKey,
+        fee: fee(paramsOrTx, computedFee),
+        timestamp: _timestamp,
+        proofs: paramsOrTx.proofs || [],
+        chainId: networkByte(paramsOrTx.chainId, 87),
+        id: '',
+        data: dataEntriesWithTypes,
+    }
+
+    validate.data(tx)
+
+    const bytes1 = version > 1 ? txToProtoBytes(tx) : binary.serializeTx(tx)
+
+    seedsAndIndexes.forEach(([s, i]) => addProof(tx, signBytes(s, bytes1), i))
+    tx.id = base58Encode(blake2b(bytes1))
+
+    return tx
+}

data/js/node_modules/@waves/waves-transactions/src/transactions/exchange.ts

@@ -0,0 +1,47 @@
+/**
+ * @module index
+ */
+import {WithId, WithProofs} from '../transactions'
+import {binary} from '@waves/marshall'
+import {base58Encode, blake2b, signBytes} from '@waves/ts-lib-crypto'
+import {addProof, convertToPairs, fee, getSenderPublicKey, networkByte} from '../generic'
+import {TSeedTypes} from '../types'
+import {validate} from '../validators'
+import {txToProtoBytes} from '../proto-serialize'
+import {DEFAULT_VERSIONS} from '../defaultVersions'
+import {ExchangeTransaction, TRANSACTION_TYPE} from '@waves/ts-types'
+
+/* @echo DOCS */
+export function exchange(paramsOrTx: ExchangeTransaction & WithProofs, seed?: TSeedTypes): ExchangeTransaction & WithId & WithProofs{
+
+    const type = TRANSACTION_TYPE.EXCHANGE
+    const version = paramsOrTx.version || DEFAULT_VERSIONS.EXCHANGE
+    const seedsAndIndexes = convertToPairs(seed)
+    const senderPublicKey = getSenderPublicKey(seedsAndIndexes, paramsOrTx)
+
+
+    const tx: ExchangeTransaction & WithId & WithProofs = {
+        type,
+        version,
+        senderPublicKey,
+        order1: paramsOrTx.order1,
+        order2: paramsOrTx.order2,
+        price: paramsOrTx.price,
+        amount: paramsOrTx.amount,
+        buyMatcherFee: paramsOrTx.buyMatcherFee,
+        sellMatcherFee: paramsOrTx.sellMatcherFee,
+        fee: fee(paramsOrTx, 100000),
+        timestamp: paramsOrTx.timestamp || Date.now(),
+        proofs: paramsOrTx.proofs || [],
+        chainId: networkByte(paramsOrTx.chainId, 87),
+        id: '',
+    }
+
+    validate.exchange(tx)
+
+    const bytes = version > 2 ? txToProtoBytes(tx) : binary.serializeTx(tx)
+
+    seedsAndIndexes.forEach(([s, i]) => addProof(tx, signBytes(s, bytes), i))
+
+    return {...tx, id: base58Encode(blake2b(bytes))}
+}