starknet 2.7.2 → 3.1.0

package/dist/signer/default.d.ts

@@ -1,34 +1,10 @@
-import { Provider } from '../provider';
-import { AddTransactionResponse, KeyPair, Signature, Transaction } from '../types';
+import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
-export declare class Signer extends Provider implements SignerInterface {
-    address: string;
-    private keyPair;
-    constructor(provider: Provider, address: string, keyPair: KeyPair);
-    /**
-     * Invoke a function on the starknet contract
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-     *
-     * @param transaction - transaction to be invoked
-     * @returns a confirmation of invoking a function on the starknet contract
-     */
-    addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
-    /**
-     * Sign an JSON object with the starknet private key and return the signature
-     *
-     * @param json - JSON object to be signed
-     * @returns the signature of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
-    signMessage(typedData: TypedData): Promise<Signature>;
-    /**
-     * Hash a JSON object with pederson hash and return the hash
-     *
-     * @param json - JSON object to be hashed
-     * @returns the hash of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
-    hashMessage(typedData: TypedData): Promise<string>;
+export declare class Signer implements SignerInterface {
+    protected keyPair: KeyPair;
+    constructor(keyPair: KeyPair);
+    getPubKey(): Promise<string>;
+    signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
+    signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
 }

package/dist/signer/default.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -50,136 +35,55 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Signer = void 0;
-var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-var provider_1 = require("../provider");
 var ellipticCurve_1 = require("../utils/ellipticCurve");
 var encode_1 = require("../utils/encode");
 var hash_1 = require("../utils/hash");
 var number_1 = require("../utils/number");
 var stark_1 = require("../utils/stark");
 var typedData_1 = require("../utils/typedData");
-var Signer = /** @class */ (function (_super) {
-    __extends(Signer, _super);
-    function Signer(provider, address, keyPair) {
-        var _this = _super.call(this, provider) || this;
-        _this.keyPair = keyPair;
-        _this.address = address;
-        return _this;
+var Signer = /** @class */ (function () {
+    function Signer(keyPair) {
+        this.keyPair = keyPair;
     }
-    /**
-     * Invoke a function on the starknet contract
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-     *
-     * @param transaction - transaction to be invoked
-     * @returns a confirmation of invoking a function on the starknet contract
-     */
-    Signer.prototype.addTransaction = function (transaction) {
+    Signer.prototype.getPubKey = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var nonceBn, result, calldataDecimal, msgHash, signature;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (transaction.type === 'DEPLOY')
-                            return [2 /*return*/, _super.prototype.addTransaction.call(this, transaction)];
-                        (0, minimalistic_assert_1.default)(!transaction.signature, "Adding signatures to a signer transaction currently isn't supported");
-                        if (!transaction.nonce) return [3 /*break*/, 1];
-                        nonceBn = (0, number_1.toBN)(transaction.nonce);
-                        return [3 /*break*/, 3];
-                    case 1: return [4 /*yield*/, this.callContract({
-                            contract_address: this.address,
-                            entry_point_selector: (0, stark_1.getSelectorFromName)('get_nonce'),
-                        })];
-                    case 2:
-                        result = (_a.sent()).result;
-                        nonceBn = (0, number_1.toBN)(result[0]);
-                        _a.label = 3;
-                    case 3:
-                        calldataDecimal = (transaction.calldata || []).map(function (x) { return (0, number_1.toBN)(x).toString(); });
-                        msgHash = (0, encode_1.addHexPrefix)((0, hash_1.hashMessage)(this.address, transaction.contract_address, transaction.entry_point_selector, calldataDecimal, nonceBn.toString()));
-                        signature = (0, ellipticCurve_1.sign)(this.keyPair, msgHash);
-                        return [2 /*return*/, _super.prototype.addTransaction.call(this, {
-                                type: 'INVOKE_FUNCTION',
-                                entry_point_selector: (0, stark_1.getSelectorFromName)('execute'),
-                                calldata: __spreadArray(__spreadArray([
-                                    transaction.contract_address,
-                                    transaction.entry_point_selector,
-                                    calldataDecimal.length.toString()
-                                ], __read(calldataDecimal), false), [
-                                    nonceBn.toString(),
-                                ], false).map(function (x) { return (0, number_1.toBN)(x).toString(); }),
-                                contract_address: this.address,
-                                signature: signature,
-                            })];
-                }
+                return [2 /*return*/, (0, ellipticCurve_1.getStarkKey)(this.keyPair)];
             });
         });
     };
-    /**
-     * Sign an JSON object with the starknet private key and return the signature
-     *
-     * @param json - JSON object to be signed
-     * @returns the signature of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
-    Signer.prototype.signMessage = function (typedData) {
+    Signer.prototype.signTransaction = function (transactions, transactionsDetail, abis) {
+        if (abis === void 0) { abis = []; }
         return __awaiter(this, void 0, void 0, function () {
-            var _a, _b;
+            var _a, contractAddress, entrypoint, _b, calldata, nonce, walletAddress, nonceBn, entrypointSelector, calldataDecimal, msgHash;
             return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = ellipticCurve_1.sign;
-                        _b = [this.keyPair];
-                        return [4 /*yield*/, this.hashMessage(typedData)];
-                    case 1: return [2 /*return*/, _a.apply(void 0, _b.concat([_c.sent()]))];
+                if (transactions.length !== 1) {
+                    throw new Error('Only one transaction at a time is currently supported by this signer');
+                }
+                if ((abis === null || abis === void 0 ? void 0 : abis.length) !== 0 && abis.length !== transactions.length) {
+                    throw new Error('ABI must be provided for each transaction or no transaction');
                 }
+                _a = transactions[0], contractAddress = _a.contractAddress, entrypoint = _a.entrypoint, _b = _a.calldata, calldata = _b === void 0 ? [] : _b;
+                nonce = transactionsDetail.nonce, walletAddress = transactionsDetail.walletAddress;
+                nonceBn = (0, number_1.toBN)(nonce);
+                entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
+                calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
+                msgHash = (0, encode_1.addHexPrefix)((0, hash_1.hashMessage)(walletAddress, contractAddress, entrypointSelector, calldataDecimal, nonceBn.toString()));
+                return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });
     };
-    /**
-     * Hash a JSON object with pederson hash and return the hash
-     *
-     * @param json - JSON object to be hashed
-     * @returns the hash of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
-    Signer.prototype.hashMessage = function (typedData) {
+    Signer.prototype.signMessage = function (typedData, walletAddress) {
         return __awaiter(this, void 0, void 0, function () {
+            var msgHash;
             return __generator(this, function (_a) {
-                return [2 /*return*/, (0, typedData_1.getMessageHash)(typedData, this.address)];
+                msgHash = (0, typedData_1.getMessageHash)(typedData, walletAddress);
+                return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });
     };
     return Signer;
-}(provider_1.Provider));
+}());
 exports.Signer = Signer;

package/dist/signer/index.d.ts

@@ -1,2 +1,2 @@
-export * from './default';
 export * from './interface';
+export * from './default';

package/dist/signer/index.js

@@ -10,5 +10,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./default"), exports);
 __exportStar(require("./interface"), exports);
+__exportStar(require("./default"), exports);

package/dist/signer/interface.d.ts

@@ -1,17 +1,12 @@
-import { Provider } from '../provider';
-import { AddTransactionResponse, Signature, Transaction } from '../types';
-import { TypedData } from '../utils/typedData/types';
-export declare abstract class SignerInterface extends Provider {
-    abstract address: string;
+import { Abi, Invocation, InvocationsSignerDetails, Signature } from '../types';
+import { TypedData } from '../utils/typedData';
+export declare abstract class SignerInterface {
     /**
-     * Invoke a function on the starknet contract
+     * Method to get the public key of the signer
      *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-     *
-     * @param transaction - transaction to be invoked
-     * @returns a confirmation of invoking a function on the starknet contract
+     * @returns public key of signer as hex string with 0x prefix
      */
-    abstract addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
+    abstract getPubKey(): Promise<string>;
     /**
      * Sign an JSON object for off-chain usage with the starknet private key and return the signature
      * This adds a message prefix so it cant be interchanged with transactions
@@ -20,14 +15,18 @@ export declare abstract class SignerInterface extends Provider {
      * @returns the signature of the JSON object
      * @throws {Error} if the JSON object is not a valid JSON
      */
-    abstract signMessage(typedData: TypedData): Promise<Signature>;
+    abstract signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
     /**
-     * Hash a JSON object with pederson hash and return the hash
-     * This adds a message prefix so it cant be interchanged with transactions
+     * Signs a transaction with the starknet private key and returns the signature
      *
-     * @param json - JSON object to be hashed
-     * @returns the hash of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
+     * @param invocation the invocation object containing:
+     * - contractAddress - the address of the contract
+     * - entrypoint - the entrypoint of the contract
+     * - calldata - (defaults to []) the calldata
+     * - signature - (defaults to []) the signature
+     * @param abi (optional) the abi of the contract for better displaying
+     *
+     * @returns signature
      */
-    abstract hashMessage(typedData: TypedData): Promise<string>;
+    abstract signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
 }

package/dist/signer/interface.js

@@ -1,27 +1,9 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignerInterface = void 0;
-var provider_1 = require("../provider");
-var SignerInterface = /** @class */ (function (_super) {
-    __extends(SignerInterface, _super);
+var SignerInterface = /** @class */ (function () {
     function SignerInterface() {
-        return _super !== null && _super.apply(this, arguments) || this;
     }
     return SignerInterface;
-}(provider_1.Provider));
+}());
 exports.SignerInterface = SignerInterface;

package/dist/types/api.d.ts

@@ -0,0 +1,147 @@
+import { BlockIdentifier } from '../provider/utils';
+import { BigNumberish } from '../utils/number';
+import { Abi, BlockNumber, CompressedCompiledContract, EntryPointType, RawCalldata, Signature, Status, TransactionStatus } from './lib';
+export declare type Endpoints = {
+    get_contract_addresses: {
+        QUERY: never;
+        REQUEST: never;
+        RESPONSE: GetContractAddressesResponse;
+    };
+    add_transaction: {
+        QUERY: never;
+        REQUEST: Transaction;
+        RESPONSE: AddTransactionResponse;
+    };
+    get_transaction: {
+        QUERY: {
+            transactionHash: string;
+        };
+        REQUEST: never;
+        RESPONSE: GetTransactionResponse;
+    };
+    get_transaction_status: {
+        QUERY: {
+            transactionHash: string;
+        };
+        REQUEST: never;
+        RESPONSE: GetTransactionStatusResponse;
+    };
+    get_storage_at: {
+        QUERY: {
+            contractAddress: string;
+            key: number;
+            blockIdentifier: BlockIdentifier;
+        };
+        REQUEST: never;
+        RESPONSE: object;
+    };
+    get_code: {
+        QUERY: {
+            contractAddress: string;
+            blockIdentifier: BlockIdentifier;
+        };
+        REQUEST: never;
+        RESPONSE: GetCodeResponse;
+    };
+    get_block: {
+        QUERY: {
+            blockIdentifier: BlockIdentifier;
+        };
+        REQUEST: never;
+        RESPONSE: GetBlockResponse;
+    };
+    call_contract: {
+        QUERY: {
+            blockIdentifier: BlockIdentifier;
+        };
+        REQUEST: CallContractTransaction;
+        RESPONSE: CallContractResponse;
+    };
+};
+export declare type GetContractAddressesResponse = {
+    Starknet: string;
+    GpsStatementVerifier: string;
+};
+export declare type DeployTransaction = {
+    type: 'DEPLOY';
+    contract_definition: CompressedCompiledContract;
+    contract_address_salt: BigNumberish;
+    constructor_calldata: string[];
+    nonce?: BigNumberish;
+};
+export declare type InvokeFunctionTransaction = {
+    type: 'INVOKE_FUNCTION';
+    contract_address: string;
+    signature?: Signature;
+    entry_point_type?: EntryPointType;
+    entry_point_selector: string;
+    calldata?: RawCalldata;
+    nonce?: BigNumberish;
+};
+export declare type CallContractTransaction = Omit<InvokeFunctionTransaction, 'type' | 'entry_point_type' | 'nonce'>;
+export declare type Transaction = DeployTransaction | InvokeFunctionTransaction;
+export declare type CallContractResponse = {
+    result: string[];
+};
+export declare type GetBlockResponse = {
+    block_number: number;
+    state_root: string;
+    block_hash: string;
+    transactions: {
+        [txHash: string]: Transaction;
+    };
+    timestamp: number;
+    transaction_receipts: {
+        [txHash: string]: {
+            block_hash: string;
+            transaction_hash: string;
+            l2_to_l1_messages: {
+                to_address: string;
+                payload: string[];
+                from_address: string;
+            }[];
+            block_number: BlockNumber;
+            status: Status;
+            transaction_index: number;
+        };
+    };
+    previous_block_hash: string;
+    status: Status;
+};
+export declare type GetCodeResponse = {
+    bytecode: string[];
+    abi: Abi;
+};
+export declare type GetTransactionStatusResponse = {
+    tx_status: Status;
+    block_hash: string;
+};
+export declare type GetTransactionResponse = {
+    status: Status;
+    transaction: Transaction;
+    block_hash: string;
+    block_number: BlockNumber;
+    transaction_index: number;
+    transaction_hash: string;
+};
+export declare type AddTransactionResponse = {
+    code: TransactionStatus;
+    transaction_hash: string;
+    address?: string;
+};
+export declare type TransactionReceipt = {
+    status: Status;
+    transaction_hash: string;
+    transaction_index: number;
+    block_hash: string;
+    block_number: BlockNumber;
+    l2_to_l1_messages: string[];
+    events: string[];
+};
+export declare type RawArgs = {
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
+};
+export declare type Calldata = string[];

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib';
+export * from './api';
+export * from './signer';

package/dist/types/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./signer"), exports);

package/dist/types/lib.d.ts

@@ -0,0 +1,57 @@
+import type { ec as EC } from 'elliptic';
+import type { BigNumberish } from '../utils/number';
+export declare type KeyPair = EC.KeyPair;
+export declare type Signature = BigNumberish[];
+export declare type RawCalldata = BigNumberish[];
+export declare type DeployContractPayload = {
+    contract: CompiledContract | string;
+    constructorCalldata?: RawCalldata;
+    addressSalt?: BigNumberish;
+};
+export declare type Invocation = {
+    contractAddress: string;
+    entrypoint: string;
+    calldata?: RawCalldata;
+    signature?: Signature;
+};
+export declare type ExecuteInvocation = Omit<Invocation, 'signature'>;
+export declare type InvocationsDetails = {
+    nonce?: BigNumberish;
+};
+export declare type Call = Omit<Invocation, 'signature' | 'nonce'>;
+export declare type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+export declare type TransactionStatus = 'TRANSACTION_RECEIVED';
+export declare type Type = 'DEPLOY' | 'INVOKE_FUNCTION';
+export declare type EntryPointType = 'EXTERNAL';
+export declare type CompressedProgram = string;
+export declare type AbiEntry = {
+    name: string;
+    type: 'felt' | 'felt*' | string;
+};
+export declare type FunctionAbi = {
+    inputs: AbiEntry[];
+    name: string;
+    outputs: AbiEntry[];
+    stateMutability?: 'view';
+    type: 'function';
+};
+export declare type StructAbi = {
+    members: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'struct';
+};
+export declare type Abi = Array<FunctionAbi | StructAbi>;
+export declare type EntryPointsByType = object;
+export declare type Program = Record<any, any>;
+export declare type BlockNumber = 'pending' | null | number;
+export declare type CompiledContract = {
+    abi: Abi;
+    entry_points_by_type: EntryPointsByType;
+    program: Program;
+};
+export declare type CompressedCompiledContract = Omit<CompiledContract, 'program'> & {
+    program: CompressedProgram;
+};

package/dist/types/lib.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/signer.d.ts

@@ -0,0 +1,4 @@
+import { InvocationsDetails } from './lib';
+export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
+    walletAddress: string;
+}

package/dist/types/signer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/address.d.ts

@@ -0,0 +1,2 @@
+export declare function addAddressPadding(address: string): string;
+export declare function validateAndParseAddress(address: string): string;

package/dist/utils/address.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndParseAddress = exports.addAddressPadding = void 0;
+var constants_1 = require("../constants");
+var encode_1 = require("./encode");
+var number_1 = require("./number");
+function addAddressPadding(address) {
+    return (0, encode_1.addHexPrefix)((0, encode_1.removeHexPrefix)(address).padStart(64, '0'));
+}
+exports.addAddressPadding = addAddressPadding;
+function validateAndParseAddress(address) {
+    if (typeof address !== 'string') {
+        throw new Error('Invalid Address Type');
+    }
+    (0, number_1.assertInRange)(address, constants_1.ZERO, constants_1.MASK_251, 'Starknet Address');
+    var result = addAddressPadding(address);
+    if (!result.match(/^(0x)?[0-9a-fA-F]{64}$/)) {
+        throw new Error('Invalid Address Format');
+    }
+    return result;
+}
+exports.validateAndParseAddress = validateAndParseAddress;

package/dist/utils/number.d.ts

@@ -4,4 +4,6 @@ export declare function isHex(hex: string): boolean;
 export declare function toBN(number: BigNumberish, base?: number | 'hex'): BN;
 export declare function toHex(number: BN): string;
 export declare function hexToDecimalString(hex: string): string;
+export declare function toFelt(num: BigNumberish): string;
 export declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
+export declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];

package/dist/utils/number.js

@@ -1,10 +1,29 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertInRange = exports.hexToDecimalString = exports.toHex = exports.toBN = exports.isHex = void 0;
-var bn_js_1 = __importDefault(require("bn.js"));
+exports.bigNumberishArrayToDecimalStringArray = exports.assertInRange = exports.toFelt = exports.hexToDecimalString = exports.toHex = exports.toBN = exports.isHex = void 0;
+var bn_js_1 = __importStar(require("bn.js"));
 var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
 var encode_1 = require("./encode");
 function isHex(hex) {
@@ -25,6 +44,13 @@ function hexToDecimalString(hex) {
     return toBN("0x" + hex.replace(/^0x/, '')).toString();
 }
 exports.hexToDecimalString = hexToDecimalString;
+function toFelt(num) {
+    if ((0, bn_js_1.isBN)(num)) {
+        return num.toString();
+    }
+    return toBN(num).toString();
+}
+exports.toFelt = toFelt;
 /*
  Asserts input is equal to or greater then lowerBound and lower then upperBound.
  Assert message specifies inputName.
@@ -38,3 +64,7 @@ function assertInRange(input, lowerBound, upperBound, inputName) {
     (0, minimalistic_assert_1.default)(inputBn.gte(toBN(lowerBound)) && inputBn.lt(toBN(upperBound)), "Message not signable, " + messageSuffix + ".");
 }
 exports.assertInRange = assertInRange;
+function bigNumberishArrayToDecimalStringArray(rawCalldata) {
+    return rawCalldata.map(function (x) { return toBN(x).toString(10); });
+}
+exports.bigNumberishArrayToDecimalStringArray = bigNumberishArrayToDecimalStringArray;

package/dist/utils/stark.d.ts

@@ -1,4 +1,4 @@
-import { CompressedProgram, Program, Signature } from '../types';
+import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 /**
  * Function to compress compiled cairo program
  *
@@ -18,3 +18,4 @@ export declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
 export declare function formatSignature(sig?: Signature): string[];
+export declare function compileCalldata(args: RawArgs): Calldata;