@atomiqlabs/chain-starknet 3.0.0-dev.0 → 3.0.0-dev.1

package/src/starknet/chain/modules/StarknetFees.ts

@@ -1,133 +1,155 @@
-import {getLogger, toBigInt, toHex} from "../../../utils/Utils";
-import {Provider} from "starknet";
-import {StarknetTokens} from "./StarknetTokens";
-
-const MAX_FEE_AGE = 5000;
-
-export class StarknetFees {
-
-    private readonly logger = getLogger("StarknetFees: ");
-
-    private readonly feeDA: "L1" | "L2";
-    private readonly nonceDA: "L1" | "L2";
-    private readonly provider: Provider;
-    private readonly gasToken: "ETH" | "STRK";
-    private readonly maxFeeRate: bigint;
-    private readonly feeMultiplierPPM: bigint;
-
-    private blockFeeCache: {
-        timestamp: number,
-        feeRate: Promise<bigint>
-    } = null;
-
-    constructor(
-        provider: Provider,
-        gasToken: "ETH" | "STRK" = "STRK",
-        maxFeeRate: number = gasToken==="ETH" ? 100_000_000_000 /*100 GWei*/ : 1_000_000_000_000_000 /*100 * 10000 GWei*/,
-        feeMultiplier: number = 1.25,
-        da?: {fee?: "L1" | "L2", nonce?: "L1" | "L2"}
-    ) {
-        this.provider = provider;
-        this.gasToken = gasToken;
-        this.maxFeeRate = BigInt(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<BN>} L1 gas price denominated in Wei
-     */
-    private async _getFeeRate(): Promise<bigint> {
-        const block = await this.provider.getBlockWithTxHashes("latest");
-        let l1GasCost = toBigInt(this.gasToken==="ETH" ? block.l1_gas_price.price_in_wei : block.l1_gas_price.price_in_fri);
-        l1GasCost = l1GasCost * this.feeMultiplierPPM / 1000000n;
-
-        this.logger.debug("_getFeeRate(): L1 fee rate: "+l1GasCost.toString(10));
-
-        return l1GasCost;
-    }
-
-    /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
-     *
-     * @private
-     */
-    public async getFeeRate(): Promise<string> {
-        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 feeRate = await this.blockFeeCache.feeRate;
-        if(feeRate>this.maxFeeRate) feeRate = this.maxFeeRate;
-
-        const fee = feeRate.toString(10)+";"+(this.gasToken === "ETH" ? "v1" : "v3");
-
-        this.logger.debug("getFeeRate(): calculated fee: "+fee);
-
-        return fee;
-    }
-
-    public getDefaultGasToken(): string {
-        return this.gasToken==="ETH" ? StarknetTokens.ERC20_ETH : StarknetTokens.ERC20_STRK;
-    }
-
-    /**
-     * Calculates the total gas fee fee paid for a given gas limit at a given fee rate
-     *
-     * @param gas
-     * @param feeRate
-     */
-    public static getGasFee(gas: number, feeRate: string): bigint {
-        if(feeRate==null) return 0n;
-
-        const arr = feeRate.split(";");
-        const gasPrice = BigInt(arr[0]);
-
-        return gasPrice * BigInt(gas);
-    }
-
-    public static getGasToken(feeRate: string): string {
-        if(feeRate==null) return null;
-
-        const arr = feeRate.split(";");
-        const txVersion = arr[1] as "v1" | 'v3';
-
-        return txVersion==="v1" ? StarknetTokens.ERC20_ETH : StarknetTokens.ERC20_STRK;
-    }
-
-    getFeeDetails(L1GasLimit: number, L2GasLimit: number, feeRate: string) {
-        if(feeRate==null) return null;
-
-        const arr = feeRate.split(";");
-        const gasPrice = BigInt(arr[0]);
-        const version = arr[1] as "v1" | "v3";
-
-        const maxFee = toHex(BigInt(L1GasLimit) * gasPrice, 16);
-
-        return {
-            maxFee: maxFee,
-            version: version==="v1" ? "0x1" : "0x3" as "0x1" | "0x3",
-            resourceBounds: {
-                l1_gas: {max_amount: toHex(L1GasLimit, 16), max_price_per_unit: toHex(gasPrice, 16)},
-                l2_gas: {max_amount: "0x0", max_price_per_unit: "0x0"}
-            },
-            tip: "0x0",
-            paymasterData: [],
-            nonceDataAvailabilityMode: this.nonceDA,
-            feeDataAvailabilityMode: this.feeDA
-        }
-    }
-
+import {getLogger, toBigInt, toHex} from "../../../utils/Utils";
+import {Provider} from "starknet";
+import {StarknetTokens} from "./StarknetTokens";
+
+const MAX_FEE_AGE = 5000;
+
+export type StarknetFeeRate = {
+    l1GasCost: bigint;
+    l2GasCost: bigint;
+    l1DataGasCost: bigint;
+};
+
+export type StarknetGas = {
+    l1Gas: number,
+    l2Gas: number,
+    l1DataGas: number
+};
+
+export function starknetGasMul(gas: StarknetGas, scalar: number): StarknetGas {
+    return {l1Gas: gas.l1Gas * scalar, l2Gas: gas.l2Gas * scalar, l1DataGas: gas.l1DataGas * scalar};
+}
+
+export function starknetGasAdd(a: StarknetGas, b: StarknetGas): StarknetGas {
+    return {l1Gas: a.l1Gas + b.l1Gas, l2Gas: a.l2Gas + b.l2Gas, l1DataGas: a.l1DataGas + b.l1DataGas};
+}
+
+export class StarknetFees {
+
+    private readonly logger = getLogger("StarknetFees: ");
+
+    private readonly feeDA: "L1" | "L2";
+    private readonly nonceDA: "L1" | "L2";
+    private readonly provider: Provider;
+    private readonly maxFeeRate: StarknetFeeRate;
+    private readonly feeMultiplierPPM: bigint;
+
+    private blockFeeCache: {
+        timestamp: number,
+        feeRate: Promise<StarknetFeeRate>
+    } = null;
+
+    constructor(
+        provider: Provider,
+        maxFeeRate: StarknetFeeRate = {l1GasCost: 1_000_000_000_000_000n, l2GasCost: 1_000_000_000_000_000n, l1DataGasCost: 1_000_000_000_000_000n} /*100 * 10000 GWei*/,
+        feeMultiplier: number = 1.25,
+        da?: {fee?: "L1" | "L2", nonce?: "L1" | "L2"}
+    ) {
+        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
+     */
+    private async _getFeeRate(): Promise<StarknetFeeRate> {
+        const block = await this.provider.getBlock("latest");
+
+        let l1GasCost = toBigInt(block.l1_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l1DataGasCost = toBigInt(block.l1_data_gas_price.price_in_fri) * this.feeMultiplierPPM / 1000000n;
+        let l2GasCost = 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
+     */
+    public async getFeeRate(): Promise<string> {
+        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;
+    }
+
+    public getDefaultGasToken(): string {
+        return StarknetTokens.ERC20_STRK;
+    }
+
+    /**
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    public static getGasFee(gas: {l1DataGas: number, l2Gas: number, l1Gas: number}, feeRate: string): bigint {
+        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));
+    }
+
+    public static getGasToken(feeRate: string): string {
+        if(feeRate==null) return null;
+
+        const arr = feeRate.split(";");
+        const txVersion = arr[1] as "v1" | 'v3';
+
+        return txVersion==="v1" ? StarknetTokens.ERC20_ETH : StarknetTokens.ERC20_STRK;
+    }
+
+    getFeeDetails(gas: {l1DataGas: number, l2Gas: number, l1Gas: number}, feeRate: string) {
+        if(feeRate==null) return null;
+
+        const arr = feeRate.split(";");
+        const [l1GasCostStr, l2GasCostStr, l1DataGasCostStr] = arr[0].split(",");
+
+        return {
+            version: "0x3" as const,
+            resourceBounds: {
+                l1_gas: {max_amount: toHex(gas.l1Gas, 16), max_price_per_unit: toHex(toBigInt(l1GasCostStr), 16)},
+                l2_gas: {max_amount: toHex(gas.l2Gas, 16), max_price_per_unit: toHex(toBigInt(l2GasCostStr), 16)},
+                l1_data_gas: {max_amount: toHex(gas.l1DataGas, 16), max_price_per_unit: toHex(toBigInt(l1DataGasCostStr), 16)}
+            },
+            tip: "0x0",
+            paymasterData: [],
+            nonceDataAvailabilityMode: this.nonceDA,
+            feeDataAvailabilityMode: this.feeDA
+        }
+    }
+
 }

package/src/starknet/chain/modules/StarknetSignatures.ts

@@ -1,91 +1,92 @@
-import {Buffer} from "buffer";
-import {StarknetModule} from "../StarknetModule";
-import {StarknetSigner} from "../../wallet/StarknetSigner";
-import {
-    Account, cairo,
-    shortString,
-    stark,
-    StarknetDomain, StarknetType,
-    TypedData
-} from "starknet";
-import {StarknetChainInterface} from "../StarknetChainInterface";
-import {toHex} from "../../../utils/Utils";
-import {sha256} from "@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' }
-];
-
-export class StarknetSignatures extends StarknetModule {
-
-    private readonly domain: StarknetDomain;
-
-    constructor(root: StarknetChainInterface, domainName: string = "atomiq.exchange") {
-        super(root);
-        this.domain = {
-            name: domainName,
-            version: '1',
-            chainId: shortString.decodeShortString(root.starknetChainId),
-            revision: '1'
-        };
-    }
-
-    public getTypedMessage(type: StarknetType[], typeName: string, message: object): TypedData {
-        return {
-            types: {
-                StarknetDomain,
-                [typeName]: type,
-            },
-            primaryType: typeName,
-            domain: this.domain,
-            message
-        };
-    }
-
-    public async signTypedMessage(signer: StarknetSigner, type: StarknetType[], typeName: string, message: object): Promise<string> {
-        const signature = await signer.account.signMessage(this.getTypedMessage(type, typeName, message));
-        return JSON.stringify(stark.formatSignature(signature));
-    }
-
-    public async isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object) {
-        return new Account(this.provider, address, null).verifyMessage(
-            this.getTypedMessage(type, typeName, message),
-            JSON.parse(signature)
-        )
-    }
-
-    ///////////////////
-    //// 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
-     */
-    public getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string> {
-        const buff = Buffer.from(sha256(data));
-        return this.signTypedMessage(signer, DataHash, 'DataHash', {"Data hash": cairo.uint256(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
-     */
-    public isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean> {
-        const buff = Buffer.from(sha256(data));
-        return this.isValidSignature(signature, address, DataHash, 'DataHash', {"Data hash": cairo.uint256(toHex(buff))});
-    }
-
+import {Buffer} from "buffer";
+import {StarknetModule} from "../StarknetModule";
+import {StarknetSigner} from "../../wallet/StarknetSigner";
+import {
+    Account, cairo,
+    shortString,
+    stark,
+    StarknetDomain, StarknetType,
+    TypedData
+} from "starknet";
+import {StarknetChainInterface} from "../StarknetChainInterface";
+import {toHex} from "../../../utils/Utils";
+import {sha256} from "@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' }
+];
+
+export class StarknetSignatures extends StarknetModule {
+
+    private readonly domain: StarknetDomain;
+
+    constructor(root: StarknetChainInterface, domainName: string = "atomiq.exchange") {
+        super(root);
+        this.domain = {
+            name: domainName,
+            version: '1',
+            chainId: shortString.decodeShortString(root.starknetChainId),
+            revision: '1'
+        };
+    }
+
+    public getTypedMessage(type: StarknetType[], typeName: string, message: object): TypedData {
+        return {
+            types: {
+                StarknetDomain,
+                [typeName]: type,
+            },
+            primaryType: typeName,
+            domain: this.domain,
+            message
+        };
+    }
+
+    public async signTypedMessage(signer: StarknetSigner, type: StarknetType[], typeName: string, message: object): Promise<string> {
+        const signature = await signer.account.signMessage(this.getTypedMessage(type, typeName, message));
+        return JSON.stringify(stark.formatSignature(signature));
+    }
+
+    public async isValidSignature(signature: string, address: string, type: StarknetType[], typeName: string, message: object): Promise<boolean> {
+        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
+     */
+    public getDataSignature(signer: StarknetSigner, data: Buffer): Promise<string> {
+        const buff = Buffer.from(sha256(data));
+        return this.signTypedMessage(signer, DataHash, 'DataHash', {"Data hash": cairo.uint256(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
+     */
+    public isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean> {
+        const buff = Buffer.from(sha256(data));
+        return this.isValidSignature(signature, address, DataHash, 'DataHash', {"Data hash": cairo.uint256(toHex(buff))});
+    }
+
 }