starknet 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [2.3.1](https://github.com/seanjameshan/starknet.js/compare/v2.3.0...v2.3.1) (2021-12-01)
+
+### Bug Fixes
+
+- allow structs in calldata ([fd2bdc0](https://github.com/seanjameshan/starknet.js/commit/fd2bdc0a1756544e4162fa5baaa7d3aec6f97bee))
+- struct compiling ([84617ae](https://github.com/seanjameshan/starknet.js/commit/84617aefe1218f421ca446b2a3c9959252d326e6))
+- struct data ([313dff5](https://github.com/seanjameshan/starknet.js/commit/313dff57f54050747c65b32b3378762c349d9c8c))
+- uint256 type ([2e05902](https://github.com/seanjameshan/starknet.js/commit/2e05902268f76bda2ae9b4e75782fa78876c2f00))
+
 # [2.3.0](https://github.com/seanjameshan/starknet.js/compare/v2.2.0...v2.3.0) (2021-12-01)
 
 ### Features

package/contract.d.ts

@@ -2,7 +2,13 @@ import { Provider } from './provider';
 import { Abi, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
 export declare type Args = {
-  [inputName: string]: string | string[];
+  [inputName: string]:
+    | string
+    | string[]
+    | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+      };
 };
 export declare type Calldata = string[];
 export declare function compileCalldata(args: Args): Calldata;

package/contract.js

@@ -216,6 +216,18 @@ function compileCalldata(args) {
         ),
         false
       );
+    if (typeof value === 'object' && 'type' in value)
+      return Object.entries(value)
+        .filter(function (_a) {
+          var _b = __read(_a, 1),
+            k = _b[0];
+          return k !== 'type';
+        })
+        .map(function (_a) {
+          var _b = __read(_a, 2),
+            v = _b[1];
+          return (0, number_1.toBN)(v).toString();
+        });
     return (0, number_1.toBN)(value).toString();
   });
 }
@@ -274,22 +286,28 @@ var Contract = /** @class */ (function () {
       return abi.name === method && abi.type === 'function';
     });
     methodAbi.inputs.forEach(function (input) {
-      if (args[input.name] !== undefined) {
+      var arg = args[input.name];
+      if (arg !== undefined) {
         if (input.type === 'felt') {
           (0, minimalistic_assert_1.default)(
-            typeof args[input.name] === 'string',
+            typeof arg === 'string',
             'arg ' + input.name + ' should be a felt (string)'
           );
           (0, minimalistic_assert_1.default)(
-            isFelt(args[input.name]),
+            isFelt(arg),
             'arg ' + input.name + ' should be decimal or hexadecimal'
           );
+        } else if (typeof arg === 'object' && 'type' in arg) {
+          (0, minimalistic_assert_1.default)(
+            arg.type === 'struct',
+            'arg ' + input.name + ' should be a struct'
+          );
         } else {
           (0, minimalistic_assert_1.default)(
-            Array.isArray(args[input.name]),
+            Array.isArray(arg),
             'arg ' + input.name + ' should be a felt* (string[])'
           );
-          args[input.name].forEach(function (felt, i) {
+          arg.forEach(function (felt, i) {
             (0,
             minimalistic_assert_1.default)(typeof felt === 'string', 'arg ' + input.name + '[' + i + '] should be a felt (string) as part of a felt* (string[])');
             (0,

package/dist/contract.d.ts

@@ -2,7 +2,10 @@ import { Provider } from './provider';
 import { Abi, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
 export declare type Args = {
-    [inputName: string]: string | string[];
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
 };
 export declare type Calldata = string[];
 export declare function compileCalldata(args: Args): Calldata;

package/dist/contract.js

@@ -101,6 +101,16 @@ function compileCalldata(args) {
     return Object.values(args).flatMap(function (value) {
         if (Array.isArray(value))
             return __spreadArray([(0, number_1.toBN)(value.length).toString()], __read(value.map(function (x) { return (0, number_1.toBN)(x).toString(); })), false);
+        if (typeof value === 'object' && 'type' in value)
+            return Object.entries(value)
+                .filter(function (_a) {
+                var _b = __read(_a, 1), k = _b[0];
+                return k !== 'type';
+            })
+                .map(function (_a) {
+                var _b = __read(_a, 2), v = _b[1];
+                return (0, number_1.toBN)(v).toString();
+            });
         return (0, number_1.toBN)(value).toString();
     });
 }
@@ -145,14 +155,18 @@ var Contract = /** @class */ (function () {
         // ensure args match abi type
         var methodAbi = this.abi.find(function (abi) { return abi.name === method && abi.type === 'function'; });
         methodAbi.inputs.forEach(function (input) {
-            if (args[input.name] !== undefined) {
+            var arg = args[input.name];
+            if (arg !== undefined) {
                 if (input.type === 'felt') {
-                    (0, minimalistic_assert_1.default)(typeof args[input.name] === 'string', "arg " + input.name + " should be a felt (string)");
-                    (0, minimalistic_assert_1.default)(isFelt(args[input.name]), "arg " + input.name + " should be decimal or hexadecimal");
+                    (0, minimalistic_assert_1.default)(typeof arg === 'string', "arg " + input.name + " should be a felt (string)");
+                    (0, minimalistic_assert_1.default)(isFelt(arg), "arg " + input.name + " should be decimal or hexadecimal");
+                }
+                else if (typeof arg === 'object' && 'type' in arg) {
+                    (0, minimalistic_assert_1.default)(arg.type === 'struct', "arg " + input.name + " should be a struct");
                 }
                 else {
-                    (0, minimalistic_assert_1.default)(Array.isArray(args[input.name]), "arg " + input.name + " should be a felt* (string[])");
-                    args[input.name].forEach(function (felt, i) {
+                    (0, minimalistic_assert_1.default)(Array.isArray(arg), "arg " + input.name + " should be a felt* (string[])");
+                    arg.forEach(function (felt, i) {
                         (0, minimalistic_assert_1.default)(typeof felt === 'string', "arg " + input.name + "[" + i + "] should be a felt (string) as part of a felt* (string[])");
                         (0, minimalistic_assert_1.default)(isFelt(felt), "arg " + input.name + "[" + i + "] should be decimal or hexadecimal as part of a felt* (string[])");
                     });

package/dist/utils/stark.d.ts

@@ -19,6 +19,3 @@ 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.compileStructToCalldata = exports.formatSignature = exports.makeAddress = exports.randomAddress = exports.getSelectorFromName = exports.compressProgram = void 0;
+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,7 +52,3 @@ function formatSignature(sig) {
     }
 }
 exports.formatSignature = formatSignature;
-function compileStructToCalldata(struct) {
-    return Object.values(struct);
-}
-exports.compileStructToCalldata = compileStructToCalldata;

package/package.json

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

package/src/contract.ts

@@ -6,7 +6,9 @@ import { Abi, AbiEntry, FunctionAbi, StructAbi } from './types';
 import { BigNumberish, toBN } from './utils/number';
 import { getSelectorFromName } from './utils/stark';
 
-export type Args = { [inputName: string]: string | string[] };
+export type Args = {
+  [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
+};
 export type Calldata = string[];
 
 function parseFelt(candidate: string): BN {
@@ -30,6 +32,10 @@ export function compileCalldata(args: Args): Calldata {
   return Object.values(args).flatMap((value) => {
     if (Array.isArray(value))
       return [toBN(value.length).toString(), ...value.map((x) => toBN(x).toString())];
+    if (typeof value === 'object' && 'type' in value)
+      return Object.entries(value)
+        .filter(([k]) => k !== 'type')
+        .map(([, v]) => toBN(v).toString());
     return toBN(value).toString();
   });
 }
@@ -88,19 +94,16 @@ export class Contract {
       (abi) => abi.name === method && abi.type === 'function'
     ) as FunctionAbi;
     methodAbi.inputs.forEach((input) => {
-      if (args[input.name] !== undefined) {
+      const arg = args[input.name];
+      if (arg !== undefined) {
         if (input.type === 'felt') {
-          assert(
-            typeof args[input.name] === 'string',
-            `arg ${input.name} should be a felt (string)`
-          );
-          assert(
-            isFelt(args[input.name] as string),
-            `arg ${input.name} should be decimal or hexadecimal`
-          );
+          assert(typeof arg === 'string', `arg ${input.name} should be a felt (string)`);
+          assert(isFelt(arg as string), `arg ${input.name} should be decimal or hexadecimal`);
+        } else if (typeof arg === 'object' && 'type' in arg) {
+          assert(arg.type === 'struct', `arg ${input.name} should be a struct`);
         } else {
-          assert(Array.isArray(args[input.name]), `arg ${input.name} should be a felt* (string[])`);
-          (args[input.name] as string[]).forEach((felt, i) => {
+          assert(Array.isArray(arg), `arg ${input.name} should be a felt* (string[])`);
+          (arg as string[]).forEach((felt, i) => {
             assert(
               typeof felt === 'string',
               `arg ${input.name}[${i}] should be a felt (string) as part of a felt* (string[])`

package/src/utils/stark.ts

@@ -49,7 +49,3 @@ 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/utils/stark.d.ts

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