waves_lib 0.1.0

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

@@ -0,0 +1,352 @@
+import {
+    DataTransactionEntry,
+    GenesisTransaction,
+    MassTransferItem,
+    PaymentTransaction,
+    SignedTransaction,
+    Transaction,
+    TRANSACTION_TYPE,
+    TransactionType
+} from '@waves/ts-types/src'
+import {InvokeScriptCallArgument} from '@waves/ts-types/src/parts'
+import {EthereumTransaction} from '@waves/ts-types'
+
+export interface WithId {
+    /**
+     * Transaction ID. 32 bytes hash encoded as base58 string
+     */
+    id: string
+}
+
+export interface WithTxType {
+    type: TransactionType
+}
+
+export interface WithSender {
+    /**
+     * Account public key. This account will pay fee and this account's script will be executed if exists
+     */
+    senderPublicKey: string
+}
+
+export interface WithProofs {
+    /**
+     * ITransaction signatures
+     * @minItems 0
+     * @maxItems 8
+     */
+    proofs: string[]
+}
+
+// export interface IOrderV1<LONG = string | number> extends IOrder<LONG> {
+//   version: 1 | undefined
+// }
+//
+// export interface IOrderV2<LONG = string | number> extends IOrder<LONG> {
+//   version: 2
+// }
+//
+// export interface IOrderV3<LONG = string | number> extends IOrder<LONG> {
+//   version: 3
+//   matcherFeeAssetId?: string | null
+// }
+//
+// export type TOrder = IOrderV1 | IOrderV2 | IOrderV3
+
+/**
+ * CancelOrder object. When this object is sent to matcher, order with 'orderId' will be canceled
+ */
+export interface ICancelOrder {
+    sender: string
+    orderId: string
+    signature: string
+    hash: string
+}
+
+
+//////////////params
+export type TTxParams<LONG = string | number> =
+    | IAliasParams<LONG>
+    | IBurnParams<LONG>
+    | IInvokeScriptParams<LONG>
+    | ICancelLeaseParams<LONG>
+    | IDataParams<LONG>
+    | IIssueParams<LONG>
+    | ILeaseParams<LONG>
+    | IMassTransferParams<LONG>
+    | IReissueParams<LONG>
+    | ISetAssetScriptParams<LONG>
+    | ISetScriptParams<LONG>
+    | ISponsorshipParams<LONG>
+    | ITransferParams<LONG>
+    | IUpdateAssetInfoParams<LONG>
+    // | IInvokeExpressionParams<LONG>
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export 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
+}
+
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IAliasParams<LONG = string | number> extends IBasicParams<LONG> {
+    alias: string
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IBurnParams<LONG = string | number> extends IBasicParams<LONG> {
+    assetId: string
+    amount: LONG
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface ICancelLeaseParams<LONG = string | number> extends IBasicParams<LONG> {
+    leaseId: string
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IDataParams<LONG = string | number> extends IBasicParams<LONG> {
+    data: Array<DataTransactionEntry | { type?: undefined; value?: undefined; key: string; }> //todo separate type for delete entry
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IIssueParams<LONG = string | number> extends IBasicParams<LONG> {
+    /**
+     * @minLength 4
+     * @maxLength 16
+     */
+    name: string
+    /**
+     * @maxLength 1000
+     */
+    description: string
+    quantity: LONG
+    decimals?: number
+    reissuable?: boolean
+    script?: string
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface ILeaseParams<LONG = string | number> extends IBasicParams<LONG> {
+    recipient: string
+    amount: LONG
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IMassTransferParams<LONG = string | number> extends IBasicParams<LONG> {
+    transfers: Array<MassTransferItem<LONG>>
+    /**
+     * Bytearray encoded as base string
+     */
+    attachment?: string
+    assetId?: string | null
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IOrderParams<LONG = string | number> {
+    matcherPublicKey: string
+    price: LONG
+    amount: LONG
+    orderType: 'buy' | 'sell',
+    amountAsset: string | null
+    priceAsset: string | null
+    senderPublicKey?: string
+    matcherFee?: number
+    timestamp?: number
+    expiration?: number
+    matcherFeeAssetId?: string | null
+    priceMode?: 'fixedDecimals' | 'assetDecimals'
+}
+
+export interface ICancelOrderParams {
+    orderId: string
+    signature?: string
+    senderPublicKey?: string
+}
+
+export interface IWavesAuthParams {
+    timestamp?: number
+    publicKey?: string
+}
+
+export interface IWavesAuth {
+    timestamp: number
+    address: string
+    publicKey: string
+    hash: string
+    signature: string
+}
+
+export interface IAuthParams {
+    data: string
+    host: string
+    publicKey?: string
+}
+
+export interface IAuth {
+    data: string
+    host: string
+    address: string
+    publicKey: string
+    hash: string
+    signature: string
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IReissueParams<LONG = string | number> extends IBasicParams<LONG> {
+    assetId: string
+    quantity: LONG
+    reissuable: boolean
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface ISetAssetScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+    /**
+     * Compiled script encoded as base64 string
+     */
+    script: string
+    assetId: string
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface ISetScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+    /**
+     * Compiled script encoded as base64 string
+     */
+    script: string | null
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+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 | null
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+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
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+export interface IInvokeScriptParams<LONG = string | number> extends IBasicParams<LONG> {
+    dApp: string
+    feeAssetId?: string | null
+    call?: {
+        function: string
+        args?: Array<InvokeScriptCallArgument<LONG>>
+    } | null,
+    payment?: {
+        assetId?: string | null
+        amount: LONG
+    }[]
+}
+
+/**
+ * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+ */
+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
+}
+
+// /**
+//  * @typeparam LONG Generic type representing LONG type. Default to string | number. Since javascript number more than 2 ** 53 -1 cannot be precisely represented, generic type is used
+//  */
+// export interface IInvokeExpressionParams<LONG = string | number> extends IBasicParams<LONG> {
+//     feeAssetId?: string | null
+//     expression: string,
+// }
+
+export type TTransaction = Exclude<Transaction, GenesisTransaction | PaymentTransaction | EthereumTransaction>
+
+export type TTransactionType = Exclude<typeof TRANSACTION_TYPE[keyof typeof TRANSACTION_TYPE], 1 | 2 | 18>
+
+export type WithChainId = { chainId: number }
+
+export type TTx = SignedTransaction<TTransaction>

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

@@ -0,0 +1,12 @@
+/**
+ * @module index
+ */
+
+export type TOption<T> = T | undefined | null
+
+export interface IIndexSeedMap {
+  [key: number]: string
+}
+
+export type TPrivateKey = { privateKey: string }
+export type TSeedTypes = string | TOption<string | TPrivateKey>[] | IIndexSeedMap | TPrivateKey

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

@@ -0,0 +1,28 @@
+import {
+    isEq,
+    orEq,
+    isNumber,
+    isNumberLike,
+    isArray,
+    getError,
+    validateByShema,
+    ifElse,
+    isValidAliasName,
+    defaultValue, isPublicKey, isNaturalNumberOrZeroLike
+} from './validators'
+import {TRANSACTION_TYPE} from '@waves/ts-types'
+
+
+const aliasScheme = {
+    type: isEq(TRANSACTION_TYPE.ALIAS),
+    version: orEq([undefined, 2, 3]),
+    senderPublicKey: isPublicKey,
+    alias: isValidAliasName,
+    fee: isNaturalNumberOrZeroLike,
+    chainId: isNumber,
+    timestamp: isNumber,
+    proofs: ifElse(isArray, defaultValue(true), orEq([undefined])),
+}
+
+
+export const aliasValidator = validateByShema(aliasScheme, getError)

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

@@ -0,0 +1,14 @@
+import {
+  getError,
+  validateByShema,
+  isString
+} from './validators'
+
+
+const authScheme = {
+  data: isString,
+  host: isString,
+}
+
+
+export const authValidator = validateByShema(authScheme, getError)

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

@@ -0,0 +1,29 @@
+import {TRANSACTION_TYPE} from '@waves/ts-types'
+import {
+    defaultValue,
+    getError,
+    ifElse,
+    isArray,
+    isAssetId,
+    isEq,
+    isNaturalNumberLike,
+    isNaturalNumberOrZeroLike,
+    isNumber,
+    isPublicKey,
+    orEq,
+    validateByShema
+} from './validators'
+
+const burnScheme = {
+    type: isEq(TRANSACTION_TYPE.BURN),
+    senderPublicKey: isPublicKey,
+    version: orEq([undefined, 2, 3]),
+    assetId: isAssetId,
+    amount: isNaturalNumberLike,
+    chainId: isNaturalNumberLike,
+    fee: isNaturalNumberOrZeroLike,
+    timestamp: isNumber,
+    proofs: ifElse(isArray, defaultValue(true), orEq([ undefined ])),
+ };
+
+export const burnValidator = validateByShema(burnScheme, getError);

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

@@ -0,0 +1,27 @@
+import {TRANSACTION_TYPE} from '@waves/ts-types'
+import {
+  defaultValue,
+  getError,
+  ifElse,
+  isArray,
+  isAssetId,
+  isEq,
+  isNaturalNumberOrZeroLike,
+  isNumber,
+  isPublicKey,
+  orEq,
+  validateByShema
+} from './validators'
+
+const cancelLeaseScheme = {
+  type: isEq(TRANSACTION_TYPE.CANCEL_LEASE),
+  senderPublicKey: isPublicKey,
+  version: orEq([undefined, 2, 3]),
+  leaseId: isAssetId,
+  chainId: isNumber,
+  fee: isNaturalNumberOrZeroLike,
+  timestamp: isNumber,
+  proofs: ifElse(isArray, defaultValue(true), orEq([ undefined ])),
+}
+
+export const cancelLeaseValidator = validateByShema(cancelLeaseScheme, getError);

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

@@ -0,0 +1,17 @@
+import {
+  getError,
+  validateByShema,
+  isPublicKey,
+  isHash,
+  isBase58
+} from './validators'
+
+
+const cancelOrderScheme = {
+  sender: isPublicKey,
+  orderId: isHash,
+  signature: isBase58,
+  hash: isBase58,
+}
+
+export const cancelOrderValidator = validateByShema(cancelOrderScheme, getError)

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

@@ -0,0 +1,40 @@
+import {
+    isEq,
+    isArray,
+    getError,
+    validateByShema,
+    ifElse,
+    prop,
+    isBase64,
+    validatePipe,
+    isRequired,
+    isValidDataPair,
+    pipe
+} from './validators'
+
+const customDataV1Scheme = {
+    version: isEq(1),
+    binary: isBase64,
+}
+
+const customDataV2Scheme = {
+    version: isEq(2),
+    data: validatePipe(
+        isArray,
+        (data: Array<unknown>) => data.every(
+            validatePipe(
+                isRequired(true),
+                isValidDataPair
+            )
+        )
+    ),
+}
+
+const v1Validator = validateByShema(customDataV1Scheme, getError)
+const v2Validator = validateByShema(customDataV2Scheme, getError)
+
+export const customDataValidator = ifElse(
+    pipe(prop('version'), isEq(1)),
+    v1Validator, 
+    v2Validator
+)

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

@@ -0,0 +1,33 @@
+import {TRANSACTION_TYPE} from '@waves/ts-types'
+import {
+  isEq,
+  orEq,
+  isNumber,
+  isNumberLike,
+  isArray,
+  getError,
+  validateByShema,
+  ifElse,
+  defaultValue,
+  isPublicKey,
+  isValidData,
+  isValidDeleteRequest, isNaturalNumberOrZeroLike,
+} from './validators'
+
+
+
+const dataScheme = {
+  type: isEq(TRANSACTION_TYPE.DATA),
+  senderPublicKey: isPublicKey,
+  version: orEq([undefined, 1, 2]),
+  data: (data: Array<unknown> ) =>
+      isArray(data) &&
+      data.every(item => isValidData(item) || isValidDeleteRequest(item)),
+  fee: isNaturalNumberOrZeroLike,
+  timestamp: isNumber,
+  proofs: ifElse(isArray, defaultValue(true), orEq([ undefined ])),
+}
+
+export const dataFieldValidator = (item: unknown ) => isValidData(item) || isValidDeleteRequest(item)
+
+export const dataValidator = validateByShema(dataScheme, getError)

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

@@ -0,0 +1,36 @@
+import {TRANSACTION_TYPE} from '@waves/ts-types'
+import { orderValidator } from './order'
+import {
+    isEq,
+    orEq,
+    isNumber,
+    isNumberLike,
+    isArray,
+    getError,
+    validateByShema,
+    ifElse, defaultValue, isPublicKey, validatePipe, isRequired, isNaturalNumberOrZeroLike
+} from './validators'
+
+
+const exchangeScheme = {
+    type: isEq(TRANSACTION_TYPE.EXCHANGE),
+    senderPublicKey: isPublicKey,
+    version: orEq([undefined, 1, 2, 3]),
+    order1: validatePipe(
+        isRequired(true),
+        orderValidator
+    ),
+    order2: validatePipe(
+        isRequired(true),
+        orderValidator
+    ),
+    amount: isNumberLike,
+    price: isNumberLike,
+    buyMatcherFee: isNumberLike,
+    sellMatcherFee: isNumberLike,
+    fee: isNaturalNumberOrZeroLike,
+    timestamp: isNumber,
+    proofs: ifElse(isArray, defaultValue(true), orEq([ undefined ])),
+}
+
+export const exchangeValidator = validateByShema(exchangeScheme, getError)

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

@@ -0,0 +1,50 @@
+export * from './validators'
+
+import { transferValidator as transfer } from './transfer'
+import { massTransferValidator as massTransfer } from './mass-transfer'
+import { aliasValidator as alias } from './alias'
+import { burnValidator as burn} from './burn'
+import { cancelLeaseValidator as cancelLease } from './cancel-lease'
+import { dataFieldValidator, dataValidator as data } from './data'
+import { sponsorshipValidator as sponsorship } from './sponsorship'
+import { setAssetScriptValidator as setAssetScript } from './set-asset-script'
+import { setScriptValidator as setScript } from './set-script'
+import { reissueValidator as reissue } from './reissue'
+import { issueValidator as issue } from './issue'
+import { leaseValidator as lease } from './lease'
+import { invokeValidator as invokeScript } from './invoke-script'
+import { exchangeValidator as exchange } from './exchange'
+import { updateAssetInfoValidator as updateAssetInfo } from './update-asset-info'
+// import { invokeExpressionValidator as invokeExpression } from './invoke-expression'
+
+import { orderValidator as order } from './order'
+import { cancelOrderValidator as cancelOrder } from './cancel-order'
+import { customDataValidator as customData } from './custom-data'
+import { authValidator as auth } from './auth'
+import { authValidator as wavesAuth } from './wavesAuth'
+
+
+export const validate = {
+    transfer,
+    massTransfer,
+    alias,
+    issue,
+    reissue,
+    sponsorship,
+    burn,
+    setAssetScript,
+    cancelLease,
+    data,
+    dataFieldValidator,
+    lease,
+    setScript,
+    invokeScript,
+    exchange,
+    updateAssetInfo,
+    // invokeExpression,
+    cancelOrder,
+    customData,
+    order,
+    wavesAuth,
+    auth,
+}

data/js/node_modules/@waves/waves-transactions/src/validators/invoke-expression.ts

@@ -0,0 +1,31 @@
+// import {TRANSACTION_TYPE} from '@waves/ts-types'
+// import {
+//     isEq,
+//     orEq,
+//     isWavesOrAssetId,
+//     isNumber,
+//     isNumberLike,
+//     isArray,
+//     getError,
+//     validateByShema,
+//     ifElse,
+//     defaultValue,
+//     isPublicKey,
+//     isBase64, isNaturalNumberOrZeroLike
+// } from './validators'
+//
+//
+// const invokeScheme = {
+//     type: isEq(TRANSACTION_TYPE.INVOKE_EXPRESSION),
+//     senderPublicKey: isPublicKey,
+//     version: isEq(1),
+//     expression: isBase64,
+//     fee: isNaturalNumberOrZeroLike,
+//     feeAssetId: isWavesOrAssetId,
+//     chainId: isNumber,
+//     timestamp: isNumber,
+//     proofs: ifElse(isArray, defaultValue(true), orEq([ undefined ])),
+// }
+//
+//
+// export const invokeExpressionValidator = validateByShema(invokeScheme, getError)