fix: tx duplicates

Author: S-FrontendDev

src/lib/adamant-api/index.js

@@ -1,7 +1,7 @@
 import Queue from 'promise-queue'
 import { Base64 } from 'js-base64'
 
-import { Transactions, Delegates, MessageType } from '@/lib/constants'
+import { Transactions, Delegates, MessageType, TransactionStatus as TS } from '@/lib/constants'
 import utils from '@/lib/adamant'
 import client from '@/lib/nodes/adm'
 import { encryptPassword } from '@/lib/idb/crypto'
@@ -10,6 +10,7 @@ import { i18n } from '@/i18n'
 import store from '@/store'
 import { isStringEqualCI } from '@/lib/textHelpers'
 import { parseCryptoAddressesKVStxs } from '@/lib/store-crypto-address'
+import { getTransactionId } from '@/utils/transactions/id'
 
 Queue.configure(Promise)
 
@@ -129,6 +130,19 @@ export function getPublicKey(address = '') {
   })
 }
 
+/**
+ * Update message in the chat store
+ * @param {{
+ *   id: number,
+ *   realId?: string,
+ *   status: number,
+ *   partnerId: string
+ * }} payload
+ */
+function updateStoreMessage(payload) {
+  store.commit('chat/updateMessage', payload)
+}
+
 /**
  * @typedef {Object} MsgParams
  * @property {string} to target address
@@ -148,27 +162,54 @@ export function getPublicKey(address = '') {
  * @returns {Promise<{success: boolean, transactionId: string}>}
  */
 export function sendMessage(params) {
-  return getPublicKey(params.to)
-    .then((publicKey) => {
+  let realId;
+
+  const { to, id, amount, type, message } = params;
+
+  return getPublicKey(to)
+    .then(async (publicKey) => {
       const text =
-        typeof params.message === 'string' ? params.message : JSON.stringify(params.message)
+        typeof message === 'string' ? message : JSON.stringify(message)
       const encoded = utils.encodeMessage(text, publicKey, myKeypair.privateKey)
       const chat = {
         message: encoded.message,
         own_message: encoded.nonce,
-        type: params.type || 1
+        type: type || 1
       }
 
       const transaction = newTransaction(Transactions.CHAT_MESSAGE)
-      transaction.amount = params.amount ? utils.prepareAmount(params.amount) : 0
+      transaction.amount = amount ? utils.prepareAmount(amount) : 0
       transaction.asset = { chat }
-      transaction.recipientId = params.to
+      transaction.recipientId = to
 
       return client.post('/api/chats/process', (endpoint) => {
-        return { transaction: signTransaction(transaction, endpoint.timeDelta) }
+        const signedTransaction = signTransaction(transaction, endpoint.timeDelta)
+
+        if (id) {
+          realId = getTransactionId(signedTransaction)
+
+          // update `message.status` to 'REGISTERED'
+          // and `message.id` with `realId` from signedTransaction
+          updateStoreMessage({
+            id,
+            realId,
+            status: TS.REGISTERED,
+            partnerId: params.to
+          })
+        }
+
+
+        return { transaction: signedTransaction }
       })
     })
     .catch((reason) => {
+      // update `message.status` to 'REJECTED'
+      updateStoreMessage({
+        id: realId ?? id,
+        status: TS.REJECTED,
+        partnerId: to
+      })
+
       return reason
     })
 }

src/lib/chat/helpers/queueMessage.js

@@ -12,12 +12,13 @@ const queue = new Queue(maxConcurent, maxQueue)
  * @param {string} recipientId
  * @returns {Promise}
  */
-export function queueMessage(message, recipientId, type) {
+export function queueMessage(message, recipientId, type, id) {
   return queue.add(() => {
     return admApi.sendMessage({
       to: recipientId,
       message,
-      type
+      type,
+      id
     })
   })
 }

src/store/modules/chat/index.js

@@ -733,32 +733,16 @@ const actions = {
         })
       : message
 
-    return queueMessage(messageAsset, recipientId, type)
-      .then((res) => {
+    return queueMessage(messageAsset, recipientId, type, messageObject.id)
+      .then(async (res) => {
         // @todo this check must be performed on the server
         if (!res.success) {
           throw new Error(i18n.global.t('chats.message_rejected'))
         }
 
-        // update `message.status` to 'REGISTERED'
-        // and `message.id` with `realId` from server
-        commit('updateMessage', {
-          id: messageObject.id,
-          realId: res.transactionId,
-          status: TS.REGISTERED, // not confirmed yet, wait to be stored in the blockchain (optional line)
-          partnerId: recipientId
-        })
-
         return res
       })
       .catch((err) => {
-        // update `message.status` to 'REJECTED'
-        commit('updateMessage', {
-          id: messageObject.id,
-          status: TS.REJECTED,
-          partnerId: recipientId
-        })
-
         throw err // call the error again so that it can be processed inside view
       })
   },

src/utils/bignumber.ts

@@ -0,0 +1,148 @@
+import BigNumber from 'bignumber.js';
+
+type Endian = 1 | -1 | 'big' | 'little';
+
+interface TransformBufferOptions {
+  endian?: Endian;
+  size?: number | 'auto';
+}
+
+type EndianMap = {
+  [K in Endian]: 'big' | 'little';
+};
+
+const endianMap: EndianMap = {
+  1: 'big',
+  '-1': 'little',
+  big: 'big',
+  little: 'little',
+};
+
+export const fromBuffer = (buf: Buffer, opts: TransformBufferOptions = {}) => {
+  const endian = resolveEndian(opts);
+
+  const size = resolveSize(opts, buf.length);
+
+  validateBufferLength(buf, size);
+
+  const hex = bufferToHexArray(buf, size, endian);
+
+  return new BigNumber(hex.join(''), 16);
+};
+
+export const toBuffer = (
+  bignumber: BigNumber,
+  opts: TransformBufferOptions | 'mpint' = {}
+) => {
+  if (typeof opts === 'string') {
+    return toMpintBuffer(bignumber);
+  }
+
+  const endian = resolveEndian(opts);
+  const hex = bignumberToHex(bignumber);
+
+  const size = resolveSize(opts, hex.length / 2);
+
+  return hexToBuffer(hex, size, endian);
+};
+
+export function resolveEndian(opts: TransformBufferOptions): Endian {
+  if (!opts.endian) {
+    return 'big';
+  }
+
+  return endianMap[opts.endian];
+}
+
+export function resolveSize(
+  opts: TransformBufferOptions,
+  defaultSize: number
+): number {
+  return opts.size === 'auto' ? Math.ceil(defaultSize) : opts.size || 1;
+}
+
+export function validateBufferLength(buf: Buffer, size: number) {
+  if (buf.length % size !== 0) {
+    throw new RangeError(
+      `Buffer length (${buf.length}) must be a multiple of size (${size})`
+    );
+  }
+}
+
+export function bufferToHexArray(
+  buf: Buffer,
+  size: number,
+  endian: Endian
+): string[] {
+  const hex: string[] = [];
+
+  for (let i = 0; i < buf.length; i += size) {
+    const chunk: string[] = [];
+    for (let j = 0; j < size; j++) {
+      const chunkIndex = endian === 'big' ? j : size - j - 1;
+      chunk.push(buf[i + chunkIndex].toString(16).padStart(2, '0'));
+    }
+    hex.push(chunk.join(''));
+  }
+
+  return hex;
+}
+
+export function bignumberToHex(bignumber: BigNumber): string {
+  const hex = bignumber.toString(16);
+  if (hex.charAt(0) === '-') {
+    throw new Error('Converting negative numbers to Buffers not supported yet');
+  }
+  return hex;
+}
+
+export function hexToBuffer(hex: string, size: number, endian: Endian): Buffer {
+  const len = Math.ceil(hex.length / (2 * size)) * size;
+  const buf = Buffer.alloc(len);
+
+  while (hex.length < 2 * len) {
+    hex = '0' + hex;
+  }
+
+  const hx = hex
+    .split(new RegExp('(.{' + 2 * size + '})'))
+    .filter(s => s.length > 0);
+
+  hx.forEach((chunk, i) => {
+    for (let j = 0; j < size; j++) {
+      const ix = i * size + (endian === 'big' ? j : size - j - 1);
+      buf[ix] = parseInt(chunk.slice(j * 2, j * 2 + 2), 16);
+    }
+  });
+
+  return buf;
+}
+
+function toMpintBuffer(bignumber: BigNumber): Buffer {
+  const buf = toBuffer(bignumber.abs(), {size: 1, endian: 'big'});
+
+  let len = buf.length === 1 && buf[0] === 0 ? 0 : buf.length;
+
+  if (buf[0] & 0x80) len++;
+
+  const ret = Buffer.alloc(4 + len);
+  if (len > 0) buf.copy(ret, 4 + (buf[0] & 0x80 ? 1 : 0));
+  if (buf[0] & 0x80) ret[4] = 0;
+
+  ret[0] = len & (0xff << 24);
+  ret[1] = len & (0xff << 16);
+  ret[2] = len & (0xff << 8);
+  ret[3] = len & (0xff << 0);
+
+  // Two's compliment for negative integers
+  const isNeg = bignumber.lt(0);
+  if (isNeg) {
+    for (let i = 4; i < ret.length; i++) {
+      ret[i] = 0xff - ret[i];
+    }
+  }
+  ret[4] = (ret[4] & 0x7f) | (isNeg ? 0x80 : 0);
+  if (isNeg) ret[ret.length - 1]++;
+
+  return ret;
+}