feat: validate printable ASCII

src/Polymesh.ts

@@ -48,7 +48,7 @@ import {
   tickerToString,
   u32ToBigNumber,
 } from '~/utils/conversion';
-import { createProcedureMethod, getDid, stringIsClean } from '~/utils/internal';
+import { createProcedureMethod, getDid, isPrintableASCII, stringIsClean } from '~/utils/internal';
 
 import { Claims } from './Claims';
 // import { Governance } from './Governance';
@@ -345,6 +345,13 @@ export class Polymesh {
     args: { ticker: string },
     callback?: SubCallback<boolean>
   ): Promise<boolean | UnsubCallback> {
+    if (!isPrintableASCII(args.ticker)) {
+      throw new PolymeshError({
+        code: ErrorCode.ValidationError,
+        message: 'Only printable ASCII is alowed as ticker name',
+      });
+    }
+
     const reservation = new TickerReservation(args, this.context);
 
     if (callback) {

src/__tests__/Polymesh.ts

@@ -387,6 +387,23 @@ describe('Polymesh Class', () => {
       entityMockUtils.cleanup();
     });
 
+    test('should throw if ticker reservation does not exist', async () => {
+      entityMockUtils.getTickerReservationDetailsStub().resolves({
+        owner: entityMockUtils.getIdentityInstance(),
+        expiryDate: new Date(),
+        status: TickerReservationStatus.Free,
+      });
+
+      const polymesh = await Polymesh.connect({
+        nodeUrl: 'wss://some.url',
+        accountUri: '//uri',
+      });
+
+      return expect(
+        polymesh.isTickerAvailable({ ticker: String.fromCharCode(10000000) })
+      ).rejects.toThrow('Only printable ASCII is alowed as ticker name');
+    });
+
     test('should return true if ticker is available to reserve it', async () => {
       entityMockUtils.getTickerReservationDetailsStub().resolves({
         owner: entityMockUtils.getIdentityInstance(),

src/api/procedures/__tests__/reserveTicker.ts

@@ -90,6 +90,14 @@ describe('reserveTicker procedure', () => {
 
     let error;
 
+    try {
+      await prepareReserveTicker.call(proc, { ticker: String.fromCharCode(10000000) });
+    } catch (err) {
+      error = err;
+    }
+
+    expect(error.message).toBe('Only printable ASCII is alowed as ticker name');
+
     try {
       await prepareReserveTicker.call(proc, { ticker: '' });
     } catch (err) {

src/api/procedures/reserveTicker.ts

@@ -11,7 +11,7 @@ import {
 import { ErrorCode, RoleType, TickerReservationStatus } from '~/types';
 import { ProcedureAuthorization } from '~/types/internal';
 import { stringToTicker, tickerToString } from '~/utils/conversion';
-import { findEventRecord } from '~/utils/internal';
+import { findEventRecord, isPrintableASCII } from '~/utils/internal';
 
 export interface ReserveTickerParams {
   ticker: string;
@@ -47,6 +47,13 @@ export async function prepareReserveTicker(
   } = this;
   const { ticker, extendPeriod = false } = args;
 
+  if (!isPrintableASCII(ticker)) {
+    throw new PolymeshError({
+      code: ErrorCode.ValidationError,
+      message: 'Only printable ASCII is alowed as ticker name',
+    });
+  }
+
   if (ticker.length < 1 || ticker.length > 12 || ticker !== ticker.toUpperCase()) {
     throw new PolymeshError({
       code: ErrorCode.ValidationError,

src/utils/__tests__/internal.ts

@@ -18,6 +18,7 @@ import {
   delay,
   findEventRecord,
   getDid,
+  isPrintableASCII,
   padString,
   removePadding,
   requestAtBlock,
@@ -424,15 +425,25 @@ describe('calculateNextKey', () => {
 
     expect(nextKey).toEqual(30);
   });
+});
 
-  describe('stringIsClean', () => {
-    test('should return false if the string contains charcode 65533', () => {
-      expect(stringIsClean(String.fromCharCode(65533))).toBe(false);
-    });
+describe('stringIsClean', () => {
+  test('should return false if the string contains charcode 65533', () => {
+    expect(stringIsClean(String.fromCharCode(65533))).toBe(false);
+  });
 
-    test("should return true if the string doesn't contain any forbidden characters", () => {
-      expect(stringIsClean('Clean String')).toBe(true);
-    });
+  test("should return true if the string doesn't contain any forbidden characters", () => {
+    expect(stringIsClean('Clean String')).toBe(true);
+  });
+});
+
+describe('isPrintableASCII', () => {
+  test('should return true if the string contains printable ASCII', () => {
+    expect(isPrintableASCII('TICKET')).toBe(true);
+  });
+
+  test("should return false if the string doesn't contain printable ASCII", () => {
+    expect(isPrintableASCII(String.fromCharCode(10000000))).toBe(false);
   });
 });
 

src/utils/internal.ts

@@ -229,6 +229,15 @@ export function stringIsClean(value: string): boolean {
   return !range(value.length).some(index => forbiddenCharCodes.includes(value.charCodeAt(index)));
 }
 
+/**
+ * @hidden
+ *
+ * Return whether the string is fully printable ASCII
+ */
+export function isPrintableASCII(value: string): boolean {
+  return new RegExp('^[\\\x00-\\\x7F]*$').test(value);
+}
+
 /**
  * @hidden
  *