@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

package/dist/starknet/chain/modules/StarknetFees.d.ts

@@ -1,77 +1,77 @@
-import { Provider } from "starknet";
-export type StarknetFeeRate = {
-    l1GasCost: bigint;
-    l2GasCost: bigint;
-    l1DataGasCost: bigint;
-};
-export type StarknetGas = {
-    l1Gas: number;
-    l2Gas: number;
-    l1DataGas: number;
-};
-export declare function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas;
-export declare function starknetGasAdd(a: StarknetGas, b: StarknetGas): StarknetGas;
-export declare class StarknetFees {
-    private readonly logger;
-    private readonly feeDA;
-    private readonly nonceDA;
-    private readonly provider;
-    private readonly maxFeeRate;
-    private readonly feeMultiplierPPM;
-    private blockFeeCache;
-    constructor(provider: Provider, maxFeeRate?: StarknetFeeRate, feeMultiplier?: number, da?: {
-        fee?: "L1" | "L2";
-        nonce?: "L1" | "L2";
-    });
-    /**
-     * Gets starknet fee rate
-     *
-     * @private
-     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
-     */
-    private _getFeeRate;
-    /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
-     *
-     * @private
-     */
-    getFeeRate(): Promise<string>;
-    getDefaultGasToken(): string;
-    /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
-     *
-     * @param gas
-     * @param feeRate
-     */
-    static getGasFee(gas: {
-        l1DataGas: number;
-        l2Gas: number;
-        l1Gas: number;
-    }, feeRate: string): bigint;
-    static getGasToken(feeRate: string): string;
-    getFeeDetails(gas: {
-        l1DataGas: number;
-        l2Gas: number;
-        l1Gas: number;
-    }, feeRate: string): {
-        version: "0x3";
-        resourceBounds: {
-            l1_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
-            };
-            l2_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
-            };
-            l1_data_gas: {
-                max_amount: string;
-                max_price_per_unit: string;
-            };
-        };
-        tip: string;
-        paymasterData: any[];
-        nonceDataAvailabilityMode: "L1" | "L2";
-        feeDataAvailabilityMode: "L1" | "L2";
-    };
-}
+import { Provider } from "starknet";
+export type StarknetFeeRate = {
+    l1GasCost: bigint;
+    l2GasCost: bigint;
+    l1DataGasCost: bigint;
+};
+export type StarknetGas = {
+    l1Gas: number;
+    l2Gas: number;
+    l1DataGas: number;
+};
+export declare function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas;
+export declare function starknetGasAdd(a: StarknetGas, b: StarknetGas): StarknetGas;
+export declare class StarknetFees {
+    private readonly logger;
+    private readonly feeDA;
+    private readonly nonceDA;
+    private readonly provider;
+    private readonly maxFeeRate;
+    private readonly feeMultiplierPPM;
+    private blockFeeCache;
+    constructor(provider: Provider, maxFeeRate?: StarknetFeeRate, feeMultiplier?: number, da?: {
+        fee?: "L1" | "L2";
+        nonce?: "L1" | "L2";
+    });
+    /**
+     * Gets starknet fee rate
+     *
+     * @private
+     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
+     */
+    private _getFeeRate;
+    /**
+     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @private
+     */
+    getFeeRate(): Promise<string>;
+    getDefaultGasToken(): string;
+    /**
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    static getGasFee(gas: {
+        l1DataGas: number;
+        l2Gas: number;
+        l1Gas: number;
+    }, feeRate: string): bigint;
+    static getGasToken(feeRate: string): string;
+    getFeeDetails(gas: {
+        l1DataGas: number;
+        l2Gas: number;
+        l1Gas: number;
+    }, feeRate: string): {
+        version: "0x3";
+        resourceBounds: {
+            l1_gas: {
+                max_amount: bigint;
+                max_price_per_unit: bigint;
+            };
+            l2_gas: {
+                max_amount: bigint;
+                max_price_per_unit: bigint;
+            };
+            l1_data_gas: {
+                max_amount: bigint;
+                max_price_per_unit: bigint;
+            };
+        };
+        tip: bigint;
+        paymasterData: any[];
+        nonceDataAvailabilityMode: "L1" | "L2";
+        feeDataAvailabilityMode: "L1" | "L2";
+    };
+}

package/dist/starknet/chain/modules/StarknetFees.js

@@ -1,114 +1,114 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetFees = exports.starknetGasAdd = exports.starknetGasMul = void 0;
-const Utils_1 = require("../../../utils/Utils");
-const StarknetTokens_1 = require("./StarknetTokens");
-const MAX_FEE_AGE = 5000;
-function starknetGasMul(gas, scalar) {
-    return { l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar };
-}
-exports.starknetGasMul = starknetGasMul;
-function starknetGasAdd(a, b) {
-    return { l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas };
-}
-exports.starknetGasAdd = starknetGasAdd;
-class StarknetFees {
-    constructor(provider, maxFeeRate = { l1GasCost: 1000000000000000n, l2GasCost: 1000000000000000n, l1DataGasCost: 1000000000000000n } /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
-        this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
-        this.blockFeeCache = null;
-        this.provider = provider;
-        this.maxFeeRate = maxFeeRate;
-        this.feeDA = da?.fee ?? "L1";
-        this.nonceDA = da?.nonce ?? "L1";
-        this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1000000));
-    }
-    /**
-     * Gets starknet fee rate
-     *
-     * @private
-     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
-     */
-    async _getFeeRate() {
-        const block = await this.provider.getBlock("latest");
-        let l1GasCost = (0, Utils_1.toBigInt)(block.l1_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
-        let l1DataGasCost = (0, Utils_1.toBigInt)(block.l1_data_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
-        let l2GasCost = (0, Utils_1.toBigInt)(block.l2_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
-        this.logger.debug("_getFeeRate(): L1 fee rate: ", [l1GasCost.toString(10), l1DataGasCost.toString(10), l2GasCost.toString(10)]);
-        return {
-            l1GasCost, l2GasCost, l1DataGasCost
-        };
-    }
-    /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
-     *
-     * @private
-     */
-    async getFeeRate() {
-        if (this.blockFeeCache == null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
-            let obj = {
-                timestamp: Date.now(),
-                feeRate: null
-            };
-            obj.feeRate = this._getFeeRate().catch(e => {
-                if (this.blockFeeCache === obj)
-                    this.blockFeeCache = null;
-                throw e;
-            });
-            this.blockFeeCache = obj;
-        }
-        let { l1GasCost, l2GasCost, l1DataGasCost } = await this.blockFeeCache.feeRate;
-        if (l1GasCost > this.maxFeeRate.l1GasCost)
-            l1GasCost = this.maxFeeRate.l1GasCost;
-        if (l2GasCost > this.maxFeeRate.l2GasCost)
-            l2GasCost = this.maxFeeRate.l2GasCost;
-        if (l1DataGasCost > this.maxFeeRate.l1DataGasCost)
-            l1DataGasCost = this.maxFeeRate.l1DataGasCost;
-        const fee = l1GasCost.toString(10) + "," + l2GasCost.toString(10) + "," + l1DataGasCost.toString(10) + ";v3";
-        this.logger.debug("getFeeRate(): calculated fee: " + fee);
-        return fee;
-    }
-    getDefaultGasToken() {
-        return StarknetTokens_1.StarknetTokens.ERC20_STRK;
-    }
-    /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
-     *
-     * @param gas
-     * @param feeRate
-     */
-    static getGasFee(gas, feeRate) {
-        if (feeRate == null)
-            return 0n;
-        const arr = feeRate.split(";");
-        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
-        return (BigInt(gas.l1Gas) * BigInt(l1GasCostStr)) +
-            (BigInt(gas.l2Gas) * BigInt(l2GasCostStr)) +
-            (BigInt(gas.l1DataGas) * BigInt(l1DataGasCostStr));
-    }
-    static getGasToken(feeRate) {
-        if (feeRate == null)
-            return null;
-        const arr = feeRate.split(";");
-        const txVersion = arr[1];
-        return txVersion === "v1" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
-    }
-    getFeeDetails(gas, feeRate) {
-        if (feeRate == null)
-            return null;
-        const arr = feeRate.split(";");
-        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
-        return {
-            version: "0x3",
-            resourceBounds: {
-                l1_gas: { max_amount: (0, Utils_1.toHex)(gas.l1Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1GasCostStr), 16) },
-                l2_gas: { max_amount: (0, Utils_1.toHex)(gas.l2Gas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l2GasCostStr), 16) },
-                l1_data_gas: { max_amount: (0, Utils_1.toHex)(gas.l1DataGas, 16), max_price_per_unit: (0, Utils_1.toHex)(BigInt(l1DataGasCostStr), 16) }
-            },
-            tip: "0x0",
-            paymasterData: [],
-            nonceDataAvailabilityMode: this.nonceDA,
-            feeDataAvailabilityMode: this.feeDA
-        };
-    }
-}
-exports.StarknetFees = StarknetFees;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetFees = exports.starknetGasAdd = exports.starknetGasMul = void 0;
+const Utils_1 = require("../../../utils/Utils");
+const StarknetTokens_1 = require("./StarknetTokens");
+const MAX_FEE_AGE = 5000;
+function starknetGasMul(gas, scalar) {
+    return { l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar };
+}
+exports.starknetGasMul = starknetGasMul;
+function starknetGasAdd(a, b) {
+    return { l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas };
+}
+exports.starknetGasAdd = starknetGasAdd;
+class StarknetFees {
+    constructor(provider, maxFeeRate = { l1GasCost: 1000000000000000n, l2GasCost: 1000000000000000n, l1DataGasCost: 1000000000000000n } /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
+        this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
+        this.blockFeeCache = null;
+        this.provider = provider;
+        this.maxFeeRate = maxFeeRate;
+        this.feeDA = da?.fee ?? "L1";
+        this.nonceDA = da?.nonce ?? "L1";
+        this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1000000));
+    }
+    /**
+     * Gets starknet fee rate
+     *
+     * @private
+     * @returns {Promise<StarknetFeeRate>} L1 gas price denominated in Wei
+     */
+    async _getFeeRate() {
+        const block = await this.provider.getBlock("latest");
+        let l1GasCost = (0, Utils_1.toBigInt)(block.l1_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l1DataGasCost = (0, Utils_1.toBigInt)(block.l1_data_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l2GasCost = (0, Utils_1.toBigInt)(block.l2_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        this.logger.debug("_getFeeRate(): L1 fee rate: ", [l1GasCost.toString(10), l1DataGasCost.toString(10), l2GasCost.toString(10)]);
+        return {
+            l1GasCost, l2GasCost, l1DataGasCost
+        };
+    }
+    /**
+     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @private
+     */
+    async getFeeRate() {
+        if (this.blockFeeCache == null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
+            let obj = {
+                timestamp: Date.now(),
+                feeRate: null
+            };
+            obj.feeRate = this._getFeeRate().catch(e => {
+                if (this.blockFeeCache === obj)
+                    this.blockFeeCache = null;
+                throw e;
+            });
+            this.blockFeeCache = obj;
+        }
+        let { l1GasCost, l2GasCost, l1DataGasCost } = await this.blockFeeCache.feeRate;
+        if (l1GasCost > this.maxFeeRate.l1GasCost)
+            l1GasCost = this.maxFeeRate.l1GasCost;
+        if (l2GasCost > this.maxFeeRate.l2GasCost)
+            l2GasCost = this.maxFeeRate.l2GasCost;
+        if (l1DataGasCost > this.maxFeeRate.l1DataGasCost)
+            l1DataGasCost = this.maxFeeRate.l1DataGasCost;
+        const fee = l1GasCost.toString(10) + "," + l2GasCost.toString(10) + "," + l1DataGasCost.toString(10) + ";v3";
+        this.logger.debug("getFeeRate(): calculated fee: " + fee);
+        return fee;
+    }
+    getDefaultGasToken() {
+        return StarknetTokens_1.StarknetTokens.ERC20_STRK;
+    }
+    /**
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    static getGasFee(gas, feeRate) {
+        if (feeRate == null)
+            return 0n;
+        const arr = feeRate.split(";");
+        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+        return (BigInt(gas.l1Gas) * BigInt(l1GasCostStr)) +
+            (BigInt(gas.l2Gas) * BigInt(l2GasCostStr)) +
+            (BigInt(gas.l1DataGas) * BigInt(l1DataGasCostStr));
+    }
+    static getGasToken(feeRate) {
+        if (feeRate == null)
+            return null;
+        const arr = feeRate.split(";");
+        const txVersion = arr[1];
+        return txVersion === "v1" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
+    }
+    getFeeDetails(gas, feeRate) {
+        if (feeRate == null)
+            return null;
+        const arr = feeRate.split(";");
+        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+        return {
+            version: "0x3",
+            resourceBounds: {
+                l1_gas: { max_amount: BigInt(gas.l1Gas), max_price_per_unit: BigInt(l1GasCostStr) },
+                l2_gas: { max_amount: BigInt(gas.l2Gas), max_price_per_unit: BigInt(l2GasCostStr) },
+                l1_data_gas: { max_amount: BigInt(gas.l1DataGas), max_price_per_unit: BigInt(l1DataGasCostStr) }
+            },
+            tip: 0n,
+            paymasterData: [],
+            nonceDataAvailabilityMode: this.nonceDA,
+            feeDataAvailabilityMode: this.feeDA
+        };
+    }
+}
+exports.StarknetFees = StarknetFees;

package/dist/starknet/chain/modules/StarknetSignatures.d.ts

@@ -1,29 +1,29 @@
-import { Buffer } from "buffer";
-import { StarknetModule } from "../StarknetModule";
-import { StarknetSigner } from "../../wallet/StarknetSigner";
-import { StarknetType, TypedData } from "starknet";
-import { StarknetChainInterface } from "../StarknetChainInterface";
-export declare class StarknetSignatures extends StarknetModule {
-    private readonly domain;
-    constructor(root: StarknetChainInterface, domainName?: string);
-    getTypedMessage(type: StarknetType[], typeName: string, message: object): TypedData;
-    signTypedMessage(signer: StarknetSigner, type: StarknetType[], typeName: string, message: object): Promise<string>;
-    isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object): Promise<boolean>;
-    /**
-     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
-     *  expose their private key (i.e. backend based, not browser wallet based)
-     *
-     * @param signer
-     * @param data data to sign
-     */
-    getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string>;
-    /**
-     * Checks whether a signature is a valid signature produced by the account over a data message (computes
-     *  sha256 hash of the message)
-     *
-     * @param data signed data
-     * @param signature data signature
-     * @param address public key of the signer
-     */
-    isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean>;
-}
+import { Buffer } from "buffer";
+import { StarknetModule } from "../StarknetModule";
+import { StarknetSigner } from "../../wallet/StarknetSigner";
+import { StarknetType, TypedData } from "starknet";
+import { StarknetChainInterface } from "../StarknetChainInterface";
+export declare class StarknetSignatures extends StarknetModule {
+    private readonly domain;
+    constructor(root: StarknetChainInterface, domainName?: string);
+    getTypedMessage(type: StarknetType[], typeName: string, message: object): TypedData;
+    signTypedMessage(signer: StarknetSigner, type: StarknetType[], typeName: string, message: object): Promise<string>;
+    isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object): Promise<boolean>;
+    /**
+     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
+     *  expose their private key (i.e. backend based, not browser wallet based)
+     *
+     * @param signer
+     * @param data data to sign
+     */
+    getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string>;
+    /**
+     * Checks whether a signature is a valid signature produced by the account over a data message (computes
+     *  sha256 hash of the message)
+     *
+     * @param data signed data
+     * @param signature data signature
+     * @param address public key of the signer
+     */
+    isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean>;
+}

package/dist/starknet/chain/modules/StarknetSignatures.js

@@ -1,72 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSignatures = void 0;
-const buffer_1 = require("buffer");
-const StarknetModule_1 = require("../StarknetModule");
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../../utils/Utils");
-const sha2_1 = require("@noble/hashes/sha2");
-const StarknetDomain = [
-    { name: 'name', type: 'shortstring' },
-    { name: 'version', type: 'shortstring' },
-    { name: 'chainId', type: 'shortstring' },
-    { name: 'revision', type: 'shortstring' },
-];
-const DataHash = [
-    { name: 'Data hash', type: 'u256' }
-];
-class StarknetSignatures extends StarknetModule_1.StarknetModule {
-    constructor(root, domainName = "atomiq.exchange") {
-        super(root);
-        this.domain = {
-            name: domainName,
-            version: '1',
-            chainId: starknet_1.shortString.decodeShortString(root.starknetChainId),
-            revision: '1'
-        };
-    }
-    getTypedMessage(type, typeName, message) {
-        return {
-            types: {
-                StarknetDomain,
-                [typeName]: type,
-            },
-            primaryType: typeName,
-            domain: this.domain,
-            message
-        };
-    }
-    async signTypedMessage(signer, type, typeName, message) {
-        const signature = await signer.account.signMessage(this.getTypedMessage(type, typeName, message));
-        return JSON.stringify(starknet_1.stark.formatSignature(signature));
-    }
-    async isValidSignature(signature, address, type, typeName, message) {
-        return this.provider.verifyMessageInStarknet(this.getTypedMessage(type, typeName, message), JSON.parse(signature), address);
-    }
-    ///////////////////
-    //// Data signatures
-    /**
-     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
-     *  expose their private key (i.e. backend based, not browser wallet based)
-     *
-     * @param signer
-     * @param data data to sign
-     */
-    getDataSignature(signer, data) {
-        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
-        return this.signTypedMessage(signer, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
-    }
-    /**
-     * Checks whether a signature is a valid signature produced by the account over a data message (computes
-     *  sha256 hash of the message)
-     *
-     * @param data signed data
-     * @param signature data signature
-     * @param address public key of the signer
-     */
-    isValidDataSignature(data, signature, address) {
-        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
-        return this.isValidSignature(signature, address, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
-    }
-}
-exports.StarknetSignatures = StarknetSignatures;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSignatures = void 0;
+const buffer_1 = require("buffer");
+const StarknetModule_1 = require("../StarknetModule");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+const sha2_1 = require("@noble/hashes/sha2");
+const StarknetDomain = [
+    { name: 'name', type: 'shortstring' },
+    { name: 'version', type: 'shortstring' },
+    { name: 'chainId', type: 'shortstring' },
+    { name: 'revision', type: 'shortstring' },
+];
+const DataHash = [
+    { name: 'Data hash', type: 'u256' }
+];
+class StarknetSignatures extends StarknetModule_1.StarknetModule {
+    constructor(root, domainName = "atomiq.exchange") {
+        super(root);
+        this.domain = {
+            name: domainName,
+            version: '1',
+            chainId: starknet_1.shortString.decodeShortString(root.starknetChainId),
+            revision: '1'
+        };
+    }
+    getTypedMessage(type, typeName, message) {
+        return {
+            types: {
+                StarknetDomain,
+                [typeName]: type,
+            },
+            primaryType: typeName,
+            domain: this.domain,
+            message
+        };
+    }
+    async signTypedMessage(signer, type, typeName, message) {
+        const signature = await signer.account.signMessage(this.getTypedMessage(type, typeName, message));
+        return JSON.stringify(starknet_1.stark.formatSignature(signature));
+    }
+    async isValidSignature(signature, address, type, typeName, message) {
+        return this.provider.verifyMessageInStarknet(this.getTypedMessage(type, typeName, message), JSON.parse(signature), address);
+    }
+    ///////////////////
+    //// Data signatures
+    /**
+     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
+     *  expose their private key (i.e. backend based, not browser wallet based)
+     *
+     * @param signer
+     * @param data data to sign
+     */
+    getDataSignature(signer, data) {
+        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
+        return this.signTypedMessage(signer, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
+    }
+    /**
+     * Checks whether a signature is a valid signature produced by the account over a data message (computes
+     *  sha256 hash of the message)
+     *
+     * @param data signed data
+     * @param signature data signature
+     * @param address public key of the signer
+     */
+    isValidDataSignature(data, signature, address) {
+        const buff = buffer_1.Buffer.from((0, sha2_1.sha256)(data));
+        return this.isValidSignature(signature, address, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
+    }
+}
+exports.StarknetSignatures = StarknetSignatures;