starknet 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [2.3.0](https://github.com/seanjameshan/starknet.js/compare/v2.2.0...v2.3.0) (2021-12-01)
+
+### Features
+
+- add compileStructToCalldata ([e5bdb18](https://github.com/seanjameshan/starknet.js/commit/e5bdb1890e0bc53b03d4b145069cf7fbc639e830))
+- **utils:** support shortstring and uint256 ([f7ff057](https://github.com/seanjameshan/starknet.js/commit/f7ff05753d9bc39b31bdd4e7f893ee04cab77823))
+
 # [2.2.0](https://github.com/seanjameshan/starknet.js/compare/v2.1.0...v2.2.0) (2021-11-30)
 
 ### Bug Fixes

package/__tests__/utils/shortString.test.ts

@@ -0,0 +1,22 @@
+import { decodeShortString, encodeShortString } from '../../src/utils/shortString';
+
+describe('shortString', () => {
+  test('should convert string to number', () => {
+    expect(encodeShortString('hello')).toMatchInlineSnapshot(`"0x68656c6c6f"`);
+  });
+  test('should convert number to string', () => {
+    expect(decodeShortString('0x68656c6c6f')).toMatchInlineSnapshot(`"hello"`);
+  });
+  test('should throw if string is too long', () => {
+    expect(() =>
+      encodeShortString('hello world hello world hello world hello world hello world hello world')
+    ).toThrowErrorMatchingInlineSnapshot(
+      `"hello world hello world hello world hello world hello world hello world is too long"`
+    );
+  });
+  test('should throw if string contains non ascii chars', () => {
+    expect(() => encodeShortString('hello\uD83D\uDE00')).toThrowErrorMatchingInlineSnapshot(
+      `"hello😀 is not an ASCII string"`
+    );
+  });
+});

package/__tests__/utils/uint256.test.ts

@@ -0,0 +1,32 @@
+import { ONE } from '../../src/constants';
+import { toBN } from '../../src/utils/number';
+import { UINT_128_MAX, UINT_256_MAX, bnToUint256, uint256ToBN } from '../../src/utils/uint256';
+
+describe('cairo uint256', () => {
+  test('should convert 0 from BN to uint256 struct', () => {
+    const uint256 = bnToUint256('0');
+    expect(uint256).toMatchInlineSnapshot(`
+      Object {
+        "high": "0x0",
+        "low": "0x0",
+      }
+    `);
+  });
+  test('should convert 0 from uint256 to BN', () => {
+    expect(uint256ToBN({ low: '0x0', high: '0x0' }).toString()).toMatchInlineSnapshot(`"0"`);
+  });
+  test('should convert BN over 2^128 to uint256 struct', () => {
+    const uint256 = bnToUint256(UINT_128_MAX.add(ONE));
+    expect(uint256).toMatchInlineSnapshot(`
+      Object {
+        "high": "0x1",
+        "low": "0x0",
+      }
+    `);
+  });
+  test('should throw if BN over uint256 range', () => {
+    expect(() => bnToUint256(UINT_256_MAX.add(toBN(1)))).toThrowErrorMatchingInlineSnapshot(
+      `"Number is too large"`
+    );
+  });
+});

package/constants.d.ts

@@ -1,9 +1,9 @@
-import BN from 'bn.js';
+/// <reference types="bn.js" />
 export { IS_BROWSER } from './utils/encode';
-export declare const ZERO: BN;
-export declare const ONE: BN;
-export declare const TWO: BN;
-export declare const MASK_250: BN;
+export declare const ZERO: import('bn.js');
+export declare const ONE: import('bn.js');
+export declare const TWO: import('bn.js');
+export declare const MASK_250: import('bn.js');
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.

package/dist/constants.d.ts

@@ -1,9 +1,9 @@
-import BN from 'bn.js';
+/// <reference types="bn.js" />
 export { IS_BROWSER } from './utils/encode';
-export declare const ZERO: BN;
-export declare const ONE: BN;
-export declare const TWO: BN;
-export declare const MASK_250: BN;
+export declare const ZERO: import("bn.js");
+export declare const ONE: import("bn.js");
+export declare const TWO: import("bn.js");
+export declare const MASK_250: import("bn.js");
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.

package/dist/index.d.ts

@@ -15,3 +15,5 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 export * as stark from './utils/stark';
 export * as ec from './utils/ellipticCurve';
+export * as uint256 from './utils/uint256';
+export * as shortString from './utils/shortString';

package/dist/index.js

@@ -22,7 +22,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ec = exports.stark = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
+exports.shortString = exports.uint256 = exports.ec = exports.stark = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
 /**
  * Main
  */
@@ -40,3 +40,5 @@ exports.json = __importStar(require("./utils/json"));
 exports.number = __importStar(require("./utils/number"));
 exports.stark = __importStar(require("./utils/stark"));
 exports.ec = __importStar(require("./utils/ellipticCurve"));
+exports.uint256 = __importStar(require("./utils/uint256"));
+exports.shortString = __importStar(require("./utils/shortString"));

package/dist/utils/shortString.d.ts

@@ -0,0 +1,4 @@
+export declare function isASCII(str: string): boolean;
+export declare function isShortString(str: string): boolean;
+export declare function encodeShortString(str: string): string;
+export declare function decodeShortString(str: string): string;

package/dist/utils/shortString.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeShortString = exports.encodeShortString = exports.isShortString = exports.isASCII = void 0;
+var encode_1 = require("./encode");
+function isASCII(str) {
+    // eslint-disable-next-line no-control-regex
+    return /^[\x00-\x7F]*$/.test(str);
+}
+exports.isASCII = isASCII;
+// function to check if string has less or equal 31 characters
+function isShortString(str) {
+    return str.length <= 31;
+}
+exports.isShortString = isShortString;
+function encodeShortString(str) {
+    if (!isASCII(str))
+        throw new Error(str + " is not an ASCII string");
+    if (!isShortString(str))
+        throw new Error(str + " is too long");
+    return (0, encode_1.addHexPrefix)(str.replace(/./g, function (char) { return char.charCodeAt(0).toString(16); }));
+}
+exports.encodeShortString = encodeShortString;
+function decodeShortString(str) {
+    return (0, encode_1.removeHexPrefix)(str).replace(/.{2}/g, function (hex) { return String.fromCharCode(parseInt(hex, 16)); });
+}
+exports.decodeShortString = decodeShortString;

package/dist/utils/stark.d.ts

@@ -19,3 +19,6 @@ export declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
 export declare function formatSignature(sig?: [BigNumberish, BigNumberish]): [string, string] | [];
+export declare function compileStructToCalldata<S extends {
+    [k: string]: string;
+}>(struct: S): string[];

package/dist/utils/stark.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatSignature = exports.makeAddress = exports.randomAddress = exports.getSelectorFromName = exports.compressProgram = void 0;
+exports.compileStructToCalldata = exports.formatSignature = exports.makeAddress = exports.randomAddress = exports.getSelectorFromName = exports.compressProgram = void 0;
 var pako_1 = require("pako");
 var ellipticCurve_1 = require("./ellipticCurve");
 var encode_1 = require("./encode");
@@ -52,3 +52,7 @@ function formatSignature(sig) {
     }
 }
 exports.formatSignature = formatSignature;
+function compileStructToCalldata(struct) {
+    return Object.values(struct);
+}
+exports.compileStructToCalldata = compileStructToCalldata;

package/dist/utils/uint256.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BigNumberish } from './number';
+export interface Uint256 {
+    low: BigNumberish;
+    high: BigNumberish;
+}
+export declare function uint256ToBN(uint256: Uint256): import("bn.js");
+export declare const UINT_128_MAX: import("bn.js");
+export declare const UINT_256_MAX: import("bn.js");
+export declare function isUint256(bn: BigNumberish): boolean;
+export declare function bnToUint256(bignumber: BigNumberish): Uint256;

package/dist/utils/uint256.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bnToUint256 = exports.isUint256 = exports.UINT_256_MAX = exports.UINT_128_MAX = exports.uint256ToBN = void 0;
+var encode_1 = require("./encode");
+var number_1 = require("./number");
+// function to convert Uint256 to BN
+function uint256ToBN(uint256) {
+    return (0, number_1.toBN)(uint256.high).shln(128).add((0, number_1.toBN)(uint256.low));
+}
+exports.uint256ToBN = uint256ToBN;
+exports.UINT_128_MAX = (0, number_1.toBN)(1).shln(128).sub((0, number_1.toBN)(1));
+exports.UINT_256_MAX = (0, number_1.toBN)(1).shln(256).sub((0, number_1.toBN)(1));
+// function to check if BN is smaller or equal 2**256-1
+function isUint256(bn) {
+    return (0, number_1.toBN)(bn).lte(exports.UINT_256_MAX);
+}
+exports.isUint256 = isUint256;
+// function to convert BN to Uint256
+function bnToUint256(bignumber) {
+    var bn = (0, number_1.toBN)(bignumber);
+    if (!isUint256(bn))
+        throw new Error('Number is too large');
+    return {
+        low: (0, encode_1.addHexPrefix)(bn.maskn(128).toString(16)),
+        high: (0, encode_1.addHexPrefix)(bn.shrn(128).toString(16)),
+    };
+}
+exports.bnToUint256 = bnToUint256;

package/index.d.ts

@@ -15,3 +15,5 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 export * as stark from './utils/stark';
 export * as ec from './utils/ellipticCurve';
+export * as uint256 from './utils/uint256';
+export * as shortString from './utils/shortString';

package/index.js

@@ -44,7 +44,9 @@ var __importStar =
     return result;
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.ec =
+exports.shortString =
+  exports.uint256 =
+  exports.ec =
   exports.stark =
   exports.number =
   exports.json =
@@ -69,3 +71,5 @@ exports.json = __importStar(require('./utils/json'));
 exports.number = __importStar(require('./utils/number'));
 exports.stark = __importStar(require('./utils/stark'));
 exports.ec = __importStar(require('./utils/ellipticCurve'));
+exports.uint256 = __importStar(require('./utils/uint256'));
+exports.shortString = __importStar(require('./utils/shortString'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/constants.ts

@@ -1,13 +1,11 @@
-import BN from 'bn.js';
-
 import { toBN } from './utils/number';
 
 export { IS_BROWSER } from './utils/encode';
 
-export const ZERO: BN = toBN(0);
-export const ONE: BN = toBN(1);
-export const TWO: BN = toBN(2);
-export const MASK_250: BN = TWO.pow(toBN(250)).sub(ONE); // 2 ** 250 - 1
+export const ZERO = toBN(0);
+export const ONE = toBN(1);
+export const TWO = toBN(2);
+export const MASK_250 = TWO.pow(toBN(250)).sub(ONE); // 2 ** 250 - 1
 
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default

package/src/index.ts

@@ -16,3 +16,5 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 export * as stark from './utils/stark';
 export * as ec from './utils/ellipticCurve';
+export * as uint256 from './utils/uint256';
+export * as shortString from './utils/shortString';

package/src/utils/shortString.ts

@@ -0,0 +1,21 @@
+import { addHexPrefix, removeHexPrefix } from './encode';
+
+export function isASCII(str: string) {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\x7F]*$/.test(str);
+}
+
+// function to check if string has less or equal 31 characters
+export function isShortString(str: string) {
+  return str.length <= 31;
+}
+
+export function encodeShortString(str: string) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str)) throw new Error(`${str} is too long`);
+  return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+}
+
+export function decodeShortString(str: string) {
+  return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+}

package/src/utils/stark.ts

@@ -49,3 +49,7 @@ export function formatSignature(sig?: [BigNumberish, BigNumberish]): [string, st
     return [];
   }
 }
+
+export function compileStructToCalldata<S extends { [k: string]: string }>(struct: S): string[] {
+  return Object.values(struct);
+}

package/src/utils/uint256.ts

@@ -0,0 +1,32 @@
+import { addHexPrefix } from './encode';
+import { BigNumberish, toBN } from './number';
+
+// Represents an integer in the range [0, 2^256).
+export interface Uint256 {
+  // The low 128 bits of the value.
+  low: BigNumberish;
+  // The high 128 bits of the value.
+  high: BigNumberish;
+}
+
+// function to convert Uint256 to BN
+export function uint256ToBN(uint256: Uint256) {
+  return toBN(uint256.high).shln(128).add(toBN(uint256.low));
+}
+
+export const UINT_128_MAX = toBN(1).shln(128).sub(toBN(1));
+export const UINT_256_MAX = toBN(1).shln(256).sub(toBN(1));
+// function to check if BN is smaller or equal 2**256-1
+export function isUint256(bn: BigNumberish): boolean {
+  return toBN(bn).lte(UINT_256_MAX);
+}
+
+// function to convert BN to Uint256
+export function bnToUint256(bignumber: BigNumberish): Uint256 {
+  const bn = toBN(bignumber);
+  if (!isUint256(bn)) throw new Error('Number is too large');
+  return {
+    low: addHexPrefix(bn.maskn(128).toString(16)),
+    high: addHexPrefix(bn.shrn(128).toString(16)),
+  };
+}

package/utils/shortString.d.ts

@@ -0,0 +1,4 @@
+export declare function isASCII(str: string): boolean;
+export declare function isShortString(str: string): boolean;
+export declare function encodeShortString(str: string): string;
+export declare function decodeShortString(str: string): string;

package/utils/shortString.js

@@ -0,0 +1,34 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.decodeShortString =
+  exports.encodeShortString =
+  exports.isShortString =
+  exports.isASCII =
+    void 0;
+var encode_1 = require('./encode');
+function isASCII(str) {
+  // eslint-disable-next-line no-control-regex
+  return /^[\x00-\x7F]*$/.test(str);
+}
+exports.isASCII = isASCII;
+// function to check if string has less or equal 31 characters
+function isShortString(str) {
+  return str.length <= 31;
+}
+exports.isShortString = isShortString;
+function encodeShortString(str) {
+  if (!isASCII(str)) throw new Error(str + ' is not an ASCII string');
+  if (!isShortString(str)) throw new Error(str + ' is too long');
+  return (0, encode_1.addHexPrefix)(
+    str.replace(/./g, function (char) {
+      return char.charCodeAt(0).toString(16);
+    })
+  );
+}
+exports.encodeShortString = encodeShortString;
+function decodeShortString(str) {
+  return (0, encode_1.removeHexPrefix)(str).replace(/.{2}/g, function (hex) {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+}
+exports.decodeShortString = decodeShortString;

package/utils/stark.d.ts

@@ -19,3 +19,8 @@ export declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
 export declare function formatSignature(sig?: [BigNumberish, BigNumberish]): [string, string] | [];
+export declare function compileStructToCalldata<
+  S extends {
+    [k: string]: string;
+  }
+>(struct: S): string[];

package/utils/stark.js

@@ -1,6 +1,7 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.formatSignature =
+exports.compileStructToCalldata =
+  exports.formatSignature =
   exports.makeAddress =
   exports.randomAddress =
   exports.getSelectorFromName =
@@ -62,3 +63,7 @@ function formatSignature(sig) {
   }
 }
 exports.formatSignature = formatSignature;
+function compileStructToCalldata(struct) {
+  return Object.values(struct);
+}
+exports.compileStructToCalldata = compileStructToCalldata;

package/utils/uint256.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BigNumberish } from './number';
+export interface Uint256 {
+  low: BigNumberish;
+  high: BigNumberish;
+}
+export declare function uint256ToBN(uint256: Uint256): import('bn.js');
+export declare const UINT_128_MAX: import('bn.js');
+export declare const UINT_256_MAX: import('bn.js');
+export declare function isUint256(bn: BigNumberish): boolean;
+export declare function bnToUint256(bignumber: BigNumberish): Uint256;

package/utils/uint256.js

@@ -0,0 +1,38 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.bnToUint256 =
+  exports.isUint256 =
+  exports.UINT_256_MAX =
+  exports.UINT_128_MAX =
+  exports.uint256ToBN =
+    void 0;
+var encode_1 = require('./encode');
+var number_1 = require('./number');
+// function to convert Uint256 to BN
+function uint256ToBN(uint256) {
+  return (0, number_1.toBN)(uint256.high)
+    .shln(128)
+    .add((0, number_1.toBN)(uint256.low));
+}
+exports.uint256ToBN = uint256ToBN;
+exports.UINT_128_MAX = (0, number_1.toBN)(1)
+  .shln(128)
+  .sub((0, number_1.toBN)(1));
+exports.UINT_256_MAX = (0, number_1.toBN)(1)
+  .shln(256)
+  .sub((0, number_1.toBN)(1));
+// function to check if BN is smaller or equal 2**256-1
+function isUint256(bn) {
+  return (0, number_1.toBN)(bn).lte(exports.UINT_256_MAX);
+}
+exports.isUint256 = isUint256;
+// function to convert BN to Uint256
+function bnToUint256(bignumber) {
+  var bn = (0, number_1.toBN)(bignumber);
+  if (!isUint256(bn)) throw new Error('Number is too large');
+  return {
+    low: (0, encode_1.addHexPrefix)(bn.maskn(128).toString(16)),
+    high: (0, encode_1.addHexPrefix)(bn.shrn(128).toString(16)),
+  };
+}
+exports.bnToUint256 = bnToUint256;