waves_lib 0.1.0

data/js/node_modules/@waves/marshall/src/schemas.ts

@@ -0,0 +1,630 @@
+import {
+  ADDRESS_OR_ALIAS,
+  BASE58_STRING, BASE64_STRING,
+  BOOL,
+  BYTE, INT,
+  LEN,
+  LONG,
+  OPTION, SCRIPT,
+  SHORT,
+  STRING
+} from './serializePrimitives'
+import {
+  byteNewAliasToString, byteToAddressOrAlias, P_BOOLEAN,
+  byteToScript,
+  P_LONG, P_OPTION, P_BYTE, P_BASE58_FIXED, P_BASE58_VAR, P_SHORT, P_STRING_VAR, P_BASE64, P_INT
+} from './parsePrimitives'
+import {
+  TObject,
+  TSchema,
+  DATA_FIELD_TYPE,
+  TDataTxItem,
+  TObjectField,
+  anyOf, TPrimitive
+} from './schemaTypes'
+import {serializerFromSchema} from './serialize'
+
+
+//Todo: import this enums from ts-types package
+export enum TRANSACTION_TYPE {
+  GENESIS = 1,
+  PAYMENT = 2,
+  ISSUE = 3,
+  TRANSFER = 4,
+  REISSUE = 5,
+  BURN = 6,
+  EXCHANGE = 7,
+  LEASE = 8,
+  CANCEL_LEASE = 9,
+  ALIAS = 10,
+  MASS_TRANSFER = 11,
+  DATA = 12,
+  SET_SCRIPT = 13,
+  SPONSORSHIP = 14,
+  SET_ASSET_SCRIPT = 15,
+  INVOKE_SCRIPT = 16,
+}
+
+const shortConverter = {
+  toBytes: SHORT,
+  fromBytes: P_SHORT,
+}
+
+const intConverter = {
+  toBytes: INT,
+  fromBytes: P_INT,
+}
+export namespace txFields {
+  //Field constructors
+  export const longField = (name: string): TObjectField => ([name, {toBytes: LONG, fromBytes: P_LONG}])
+
+  export const byteField = (name: string): TObjectField => ([name, {toBytes: BYTE, fromBytes: P_BYTE}])
+
+  export const booleanField = (name: string): TObjectField => ([name, {toBytes: BOOL, fromBytes: P_BOOLEAN}])
+
+  export const stringField = (name: string): TObjectField => ([name, {
+    toBytes: LEN(SHORT)(STRING),
+    fromBytes: P_STRING_VAR(P_SHORT),
+  }])
+
+  export const base58field32 = (name: string): TObjectField => ([name, {
+    toBytes: BASE58_STRING,
+    fromBytes: P_BASE58_FIXED(32),
+  }])
+
+  // String 'WAVES' often used instead of null. That's why we should serialize it as null
+  export const base58Option32 = (name: string): TObjectField => ([name, {
+    toBytes: (s: string) => s === 'WAVES' ? OPTION(BASE58_STRING)(null) : OPTION(BASE58_STRING)(s),
+    fromBytes: P_OPTION(P_BASE58_FIXED(32)),
+  }])
+
+  export const base64field = (name: string): TObjectField => ([name, {
+    toBytes: LEN(SHORT)(BASE64_STRING),
+    fromBytes: P_BASE64(P_SHORT),
+  }])
+
+  export const byteConstant = (byte: number): TObjectField => (['noname', {
+    toBytes: () => Uint8Array.from([byte]),
+    fromBytes: () => ({value: undefined, shift: 1}),
+  }])
+
+  // Primitive fields
+  export const alias: TObjectField = ['alias', {
+    toBytes: LEN(SHORT)(STRING),
+    fromBytes: byteNewAliasToString,
+  }]
+
+  export const amount = longField('amount')
+
+  export const assetDescription = stringField('description')
+
+  export const assetId = base58field32('assetId')
+  export const assetName = stringField('name')
+
+  export const attachment: TObjectField = ['attachment', {
+    toBytes: LEN(SHORT)(BASE58_STRING),
+    fromBytes: P_BASE58_VAR(P_SHORT),
+  }]
+
+  export const chainId = byteField('chainId')
+
+  export const decimals = byteField('decimals')
+
+  export const fee = longField('fee')
+
+  export const leaseAssetId = base58Option32('leaseAssetId')
+
+  export const leaseId = base58field32('leaseId')
+
+  export const optionalAssetId = base58Option32('assetId')
+
+  export const quantity = longField('quantity')
+
+  export const reissuable = booleanField('reissuable')
+
+  export const recipient: TObjectField = ['recipient', {
+    toBytes: ADDRESS_OR_ALIAS,
+    fromBytes: byteToAddressOrAlias,
+  }]
+
+  export const script: TObjectField = ['script', {
+    toBytes: SCRIPT,
+    fromBytes: byteToScript,
+  }]
+
+  export const senderPublicKey = base58field32('senderPublicKey')
+
+  export const signature: TObjectField = ['signature', {
+    toBytes: BASE58_STRING,
+    fromBytes: P_BASE58_FIXED(64),
+  }]
+
+  export const timestamp = longField('timestamp')
+
+  export const type = byteField('type')
+
+  export const version = byteField('version')
+
+  // Complex fields
+
+  export const proofs: TObjectField = ['proofs', {
+    type: 'array',
+    items: {
+      toBytes: LEN(SHORT)(BASE58_STRING),
+      fromBytes: P_BASE58_VAR(P_SHORT),
+    },
+  }]
+
+  const transfer: TObject = {
+    type: 'object',
+    schema: [
+      recipient,
+      amount,
+    ],
+  }
+
+  export const transfers: TObjectField = ['transfers', {
+    type: 'array',
+    items: transfer,
+  }]
+
+  const dataTxItem: TDataTxItem = {
+    type: 'dataTxField',
+    items: new Map<DATA_FIELD_TYPE, TSchema>([
+      [DATA_FIELD_TYPE.INTEGER, {toBytes: LONG, fromBytes: P_LONG}],
+      [DATA_FIELD_TYPE.BOOLEAN, {toBytes: BOOL, fromBytes: P_BOOLEAN}],
+      [DATA_FIELD_TYPE.BINARY, {toBytes: LEN(SHORT)(BASE64_STRING), fromBytes: P_BASE64(P_SHORT)}],
+      [DATA_FIELD_TYPE.STRING, {toBytes: LEN(SHORT)(STRING), fromBytes: P_STRING_VAR(P_SHORT)}],
+    ]),
+  }
+
+  export const data: TObjectField = ['data', {
+    type: 'array',
+    items: dataTxItem,
+  }]
+
+  const functionArgumentPrimitives: [number, TSchema, string?][] = [
+    [0, {toBytes: LONG, fromBytes: P_LONG}, 'integer'],
+    [1, {toBytes: LEN(INT)(BASE64_STRING), fromBytes: P_BASE64(P_INT)}, 'binary'],
+    [2, {toBytes: LEN(INT)(STRING), fromBytes: P_STRING_VAR(P_INT)}, 'string'],
+    [6, {toBytes: () => Uint8Array.from([]), fromBytes: () => ({value: true, shift: 0})}, 'boolean'],
+    [7, {toBytes: () => Uint8Array.from([]), fromBytes: () => ({value: false, shift: 0})}, 'boolean'],
+  ]
+
+  const functionArgument = anyOf([
+    ...functionArgumentPrimitives,
+    [11, {  
+      type: 'array',
+      toBytes: INT,
+      fromBytes: P_INT,
+      items: anyOf(functionArgumentPrimitives, {valueField: 'value'}), 
+    }, 'list'],
+  ], {valueField: 'value'})
+
+  export const functionCall: TObjectField = ['call', {
+    type: 'object',
+    optional: true,
+    schema: [
+      // special bytes to indicate function call. Used in Serde serializer
+      byteConstant(9),
+      byteConstant(1),
+      ['function', {
+        toBytes: LEN(INT)(STRING),
+        fromBytes: P_STRING_VAR(P_INT),
+      }],
+      ['args', {
+        type: 'array',
+        toBytes: INT,
+        fromBytes: P_INT,
+        items: functionArgument,
+      }],
+    ],
+  }]
+
+  export const payment: TObject = {
+    type: 'object',
+    withLength: shortConverter,
+    schema: [
+      amount,
+      optionalAssetId
+    ],
+  }
+
+  export const payments: TObjectField = ['payment', {
+    type: 'array',
+    items: payment,
+  }]
+}
+
+export const orderSchemaV1: TObject = {
+  type: 'object',
+  schema: [
+    txFields.senderPublicKey,
+    txFields.base58field32('matcherPublicKey'),
+    ['assetPair', {
+      type: 'object',
+      schema: [
+        txFields.base58Option32('amountAsset'),
+        txFields.base58Option32('priceAsset'),
+      ],
+    }],
+    ['orderType', {
+      toBytes: (type: string) => BYTE(type === 'sell' ? 1 : 0),
+      fromBytes: (bytes: Uint8Array, start = 0) => P_BYTE(bytes, start).value === 1 ?
+        {value: 'sell', shift: 1} :
+        {value: 'buy', shift: 1},
+    }],
+    txFields.longField('price'),
+    txFields.longField('amount'),
+    txFields.timestamp,
+    txFields.longField('expiration'),
+    txFields.longField('matcherFee'),
+  ],
+}
+
+export const orderSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.version,
+    ...orderSchemaV1.schema,
+  ],
+}
+
+// In order v3 amount and price fields are flipped
+export const orderSchemaV3: TSchema = {
+  type: 'object',
+  schema: [
+    ...orderSchemaV2.schema,
+    ['matcherFeeAssetId', txFields.optionalAssetId[1]]
+  ],
+}
+
+export const aliasSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.senderPublicKey,
+    [['alias', 'chainId'], {
+      type: 'object',
+      withLength: shortConverter,
+      schema: [
+        txFields.byteConstant(2), // Alias version
+        txFields.chainId, //
+        txFields.alias, // Alias text
+      ],
+    }],
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const burnSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.assetId,
+    txFields.amount,
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const cancelLeaseSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.fee,
+    txFields.timestamp,
+    txFields.leaseId,
+  ],
+}
+
+export const invokeScriptSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    ['dApp', txFields.recipient[1]],
+    txFields.functionCall,
+    txFields.payments,
+    txFields.fee,
+    ['feeAssetId', txFields.optionalAssetId[1]],
+    txFields.timestamp,
+  ],
+}
+
+
+export const dataSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.senderPublicKey,
+    txFields.data,
+    txFields.timestamp,
+    txFields.fee,
+  ],
+}
+
+export const proofsSchemaV0: TSchema = {
+  type: 'object',
+  schema: [
+    ['signature', {
+      toBytes: BASE58_STRING,
+      fromBytes: P_BASE58_FIXED(64),
+    }],
+  ],
+}
+
+export const proofsSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.byteConstant(1), // proofs version
+    txFields.proofs,
+  ],
+}
+
+
+const orderSchemaV0WithSignature: TObject = {
+  type: 'object',
+  schema: [...orderSchemaV1.schema, txFields.signature],
+}
+//ExchangeV0 needs both orders length to be present before actual order bytes.
+// That's why there are two separate rules for oder1 and order2 fields. First one serializes order and writes length.
+// Seconds serializes and writes whole order. When deserialize, second rule overwrites order fields in js object
+export const exchangeSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    ['order1', {
+      fromBytes: () => ({value: undefined, shift: 4}),
+      toBytes: (order: any) => INT(serializerFromSchema(orderSchemaV0WithSignature)(order).length)
+    }],
+    ['order2', {
+      fromBytes: () => ({value: undefined, shift: 4}),
+      toBytes: (order: any) => INT(serializerFromSchema(orderSchemaV0WithSignature)(order).length)
+    }],
+    ['order1', orderSchemaV0WithSignature],
+    ['order2', orderSchemaV0WithSignature],
+    txFields.longField('price'),
+    txFields.longField('amount'),
+    txFields.longField('buyMatcherFee'),
+    txFields.longField('sellMatcherFee'),
+    txFields.longField('fee'),
+    txFields.longField('timestamp'),
+  ],
+}
+
+const anyOrder = anyOf([
+  [1, {
+    type: 'object',
+    //order v1 length is serialized without orderVersion
+    withLength: {
+      toBytes: (x) => INT(x - 1),
+      fromBytes: (x) => {
+        const {value, shift} = P_INT(x)
+        return {value: value + 1, shift}
+      }
+    } as TPrimitive,
+    schema: [txFields.byteConstant(1), ...orderSchemaV1.schema, ...proofsSchemaV0.schema]
+  }],
+  [2, {type: 'object', withLength: intConverter, schema: [...orderSchemaV2.schema, ...proofsSchemaV1.schema]}],
+  [3, {type: 'object', withLength: intConverter, schema: [...orderSchemaV3.schema, ...proofsSchemaV1.schema]}],
+], {discriminatorField: 'version', discriminatorBytePos: 4})
+
+export const exchangeSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.byteConstant(0),
+    txFields.type,
+    txFields.version,
+    ['order1', anyOrder],
+    ['order2', anyOrder],
+    txFields.longField('price'),
+    txFields.longField('amount'),
+    txFields.longField('buyMatcherFee'),
+    txFields.longField('sellMatcherFee'),
+    txFields.longField('fee'),
+    txFields.longField('timestamp'),
+  ],
+}
+
+export const issueSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.assetName,
+    txFields.assetDescription,
+    txFields.quantity,
+    txFields.decimals,
+    txFields.reissuable,
+    txFields.fee,
+    txFields.timestamp,
+    txFields.script,
+  ],
+}
+
+export const leaseSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.leaseAssetId,
+    txFields.senderPublicKey,
+    txFields.recipient,
+    txFields.amount,
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const massTransferSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.senderPublicKey,
+    txFields.optionalAssetId,
+    txFields.transfers,
+    txFields.timestamp,
+    txFields.fee,
+    txFields.attachment,
+  ],
+}
+
+export const reissueSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.assetId,
+    txFields.quantity,
+    txFields.reissuable,
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const setAssetScriptSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.assetId,
+    txFields.fee,
+    txFields.timestamp,
+    txFields.script,
+  ],
+}
+
+export const setScriptSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.chainId,
+    txFields.senderPublicKey,
+    txFields.script,
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const sponsorshipSchemaV1: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.senderPublicKey,
+    txFields.assetId,
+    txFields.longField('minSponsoredAssetFee'),
+    txFields.fee,
+    txFields.timestamp,
+  ],
+}
+
+export const transferSchemaV2: TSchema = {
+  type: 'object',
+  schema: [
+    txFields.type,
+    txFields.version,
+    txFields.senderPublicKey,
+    txFields.optionalAssetId,
+    ['feeAssetId', txFields.optionalAssetId[1]],
+    txFields.timestamp,
+    txFields.amount,
+    txFields.fee,
+    txFields.recipient,
+    txFields.attachment,
+  ],
+}
+
+
+/**
+ * Maps transaction types to schemas object. Schemas are written by keys. 1 equals no version or version 1
+ */
+export const schemasByTypeMap = {
+  [TRANSACTION_TYPE.GENESIS]: {},
+  [TRANSACTION_TYPE.PAYMENT]: {},
+  [TRANSACTION_TYPE.ISSUE]: {
+    2: issueSchemaV2,
+  },
+  [TRANSACTION_TYPE.TRANSFER]: {
+    2: transferSchemaV2,
+  },
+  [TRANSACTION_TYPE.REISSUE]: {
+    2: reissueSchemaV2,
+  },
+  [TRANSACTION_TYPE.BURN]: {
+    2: burnSchemaV2,
+  },
+  [TRANSACTION_TYPE.EXCHANGE]: {
+    1: exchangeSchemaV1,
+    2: exchangeSchemaV2,
+  },
+  [TRANSACTION_TYPE.LEASE]: {
+    2: leaseSchemaV2,
+  },
+  [TRANSACTION_TYPE.CANCEL_LEASE]: {
+    2: cancelLeaseSchemaV2,
+  },
+  [TRANSACTION_TYPE.ALIAS]: {
+    2: aliasSchemaV2,
+  },
+  [TRANSACTION_TYPE.MASS_TRANSFER]: {
+    1: massTransferSchemaV1,
+  },
+  [TRANSACTION_TYPE.DATA]: {
+    1: dataSchemaV1,
+  },
+  [TRANSACTION_TYPE.SET_SCRIPT]: {
+    1: setScriptSchemaV1,
+  },
+  [TRANSACTION_TYPE.SPONSORSHIP]: {
+    1: sponsorshipSchemaV1,
+  },
+  [TRANSACTION_TYPE.SET_ASSET_SCRIPT]: {
+    1: setAssetScriptSchemaV1,
+  },
+  [TRANSACTION_TYPE.INVOKE_SCRIPT]: {
+    1: invokeScriptSchemaV1,
+  },
+}
+
+export const orderVersionMap: Record<number, TObject> = {
+  1: orderSchemaV1,
+  2: orderSchemaV2,
+  3: orderSchemaV3
+}
+
+export function getTransactionSchema(type: TRANSACTION_TYPE, version?: number): TSchema {
+  const schemas = (<any>schemasByTypeMap)[type]
+  if (typeof schemas !== 'object') {
+    throw new Error(`Incorrect tx type: ${type}`)
+  }
+
+  const schema = schemas[version || 1]
+  if (typeof schema !== 'object') {
+    throw new Error(`Incorrect tx version: ${version}`)
+  }
+
+  return schema
+}
+
+