@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/starknet/base/modules/StarknetAccounts.d.ts

@@ -0,0 +1,6 @@
+import { StarknetModule } from "../StarknetModule";
+import { StarknetTx } from "./StarknetTransactions";
+import { DeployAccountContractPayload } from "starknet";
+export declare class StarknetAccounts extends StarknetModule {
+    getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx>;
+}

package/dist/starknet/base/modules/StarknetAccounts.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetAccounts = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetAccounts extends StarknetModule_1.StarknetModule {
+    async getAccountDeployTransaction(deploymentData) {
+        const feeDetails = this.root.Fees.getFeeDetails(5000, 0, await this.root.Fees.getFeeRate());
+        const details = {
+            ...feeDetails,
+            walletAddress: deploymentData.contractAddress,
+            cairoVersion: "1",
+            chainId: this.root.starknetChainId,
+            nonce: 0,
+            accountDeploymentData: [],
+            skipValidate: false
+        };
+        return {
+            type: "DEPLOY_ACCOUNT",
+            tx: deploymentData,
+            details
+        };
+    }
+}
+exports.StarknetAccounts = StarknetAccounts;

package/dist/starknet/base/modules/StarknetAddresses.d.ts

@@ -0,0 +1,9 @@
+import { StarknetModule } from "../StarknetModule";
+export declare class StarknetAddresses extends StarknetModule {
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    isValidAddress(value: string): boolean;
+}

package/dist/starknet/base/modules/StarknetAddresses.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetAddresses = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+const starknet_1 = require("starknet");
+class StarknetAddresses extends StarknetModule_1.StarknetModule {
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    isValidAddress(value) {
+        if (value.length !== 66)
+            return false;
+        try {
+            (0, starknet_1.validateAndParseAddress)(value);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.StarknetAddresses = StarknetAddresses;

package/dist/starknet/base/modules/StarknetBlocks.d.ts

@@ -0,0 +1,19 @@
+import { StarknetModule } from "../StarknetModule";
+export type StarknetBlockTag = "pending" | "latest";
+export declare class StarknetBlocks extends StarknetModule {
+    private BLOCK_CACHE_TIME;
+    private blockCache;
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime;
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlockTime(blockTag: StarknetBlockTag): Promise<number>;
+}

package/dist/starknet/base/modules/StarknetBlocks.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetBlocks = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetBlocks extends StarknetModule_1.StarknetModule {
+    constructor() {
+        super(...arguments);
+        this.BLOCK_CACHE_TIME = 5 * 1000;
+        this.blockCache = {};
+    }
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    fetchAndSaveBlockTime(blockTag) {
+        const blockTimePromise = this.provider.getBlockWithTxHashes(blockTag).then(result => result.timestamp);
+        const timestamp = Date.now();
+        this.blockCache[blockTag] = {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+        blockTimePromise.catch(e => {
+            if (this.blockCache[blockTag] != null && this.blockCache[blockTag].blockTime === blockTimePromise)
+                delete this.blockCache[blockTag];
+            throw e;
+        });
+        return {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+    }
+    ///////////////////
+    //// Slots
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlockTime(blockTag) {
+        let cachedBlockData = this.blockCache[blockTag];
+        if (cachedBlockData == null || Date.now() - cachedBlockData.timestamp > this.BLOCK_CACHE_TIME) {
+            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
+        }
+        return cachedBlockData.blockTime;
+    }
+}
+exports.StarknetBlocks = StarknetBlocks;

package/dist/starknet/base/modules/StarknetEvents.d.ts

@@ -0,0 +1,44 @@
+import { StarknetModule } from "../StarknetModule";
+export type StarknetEvent = {
+    block_hash: string;
+    block_number: number;
+    transaction_hash: string;
+    from_address: string;
+    keys: string[];
+    data: string[];
+};
+export declare class StarknetEvents extends StarknetModule {
+    readonly EVENTS_LIMIT = 100;
+    readonly FORWARD_BLOCK_RANGE = 2000;
+    /**
+     * Returns the all the events occuring in a block range as identified by the contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param startBlock
+     * @param endBlock
+     * @param abortSignal
+     */
+    getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock?: number, abortSignal?: AbortSignal): Promise<StarknetEvent[]>;
+    /**
+     * Runs a search backwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     */
+    findInEvents<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    /**
+     * Runs a search forwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param logFetchLimit
+     */
+    findInEventsForward<T>(contract: string, keys: string[][], processor: (signatures: StarknetEvent[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+}

package/dist/starknet/base/modules/StarknetEvents.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetEvents = void 0;
+const StarknetModule_1 = require("../StarknetModule");
+class StarknetEvents extends StarknetModule_1.StarknetModule {
+    constructor() {
+        super(...arguments);
+        this.EVENTS_LIMIT = 100;
+        this.FORWARD_BLOCK_RANGE = 2000;
+    }
+    /**
+     * Returns the all the events occuring in a block range as identified by the contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param startBlock
+     * @param endBlock
+     * @param abortSignal
+     */
+    async getBlockEvents(contract, keys, startBlock, endBlock = startBlock, abortSignal) {
+        const events = [];
+        let result = null;
+        while (result == null || result?.continuation_token != null) {
+            result = await this.root.provider.getEvents({
+                address: contract,
+                from_block: startBlock == null ? "pending" : { block_number: startBlock },
+                to_block: endBlock == null ? "pending" : { block_number: endBlock },
+                keys,
+                chunk_size: this.EVENTS_LIMIT,
+                continuation_token: result?.continuation_token
+            });
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            events.push(...result.events);
+        }
+        return events;
+    }
+    /**
+     * Runs a search backwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     */
+    async findInEvents(contract, keys, processor, abortSignal) {
+        const latestBlockNumber = await this.provider.getBlockNumber();
+        for (let blockNumber = latestBlockNumber; blockNumber >= 0; blockNumber -= this.FORWARD_BLOCK_RANGE) {
+            const eventsResult = await this.getBlockEvents(contract, keys, Math.max(blockNumber - this.FORWARD_BLOCK_RANGE, 0), blockNumber === latestBlockNumber ? null : blockNumber, abortSignal);
+            const result = await processor(eventsResult.reverse());
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+    /**
+     * Runs a search forwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param keys
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param logFetchLimit
+     */
+    async findInEventsForward(contract, keys, processor, abortSignal, logFetchLimit) {
+        if (logFetchLimit == null || logFetchLimit > this.EVENTS_LIMIT)
+            logFetchLimit = this.EVENTS_LIMIT;
+        let eventsResult = null;
+        while (eventsResult == null || eventsResult?.continuation_token != null) {
+            eventsResult = await this.root.provider.getEvents({
+                address: contract,
+                to_block: "latest",
+                keys,
+                chunk_size: logFetchLimit ?? this.EVENTS_LIMIT,
+                continuation_token: eventsResult?.continuation_token
+            });
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            const result = await processor(eventsResult.events);
+            if (result != null)
+                return result;
+        }
+        return null;
+    }
+}
+exports.StarknetEvents = StarknetEvents;

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

@@ -0,0 +1,55 @@
+import { Provider } from "starknet";
+export declare class StarknetFees {
+    private readonly logger;
+    private readonly feeDA;
+    private readonly nonceDA;
+    private readonly provider;
+    private readonly gasToken;
+    private readonly maxFeeRate;
+    private readonly feeMultiplierPPM;
+    private blockFeeCache;
+    constructor(provider: Provider, gasToken?: "ETH" | "STRK", maxFeeRate?: number, feeMultiplier?: number, da?: {
+        fee?: "L1" | "L2";
+        nonce?: "L1" | "L2";
+    });
+    /**
+     * Gets starknet fee rate
+     *
+     * @private
+     * @returns {Promise<BN>} 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 fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    static getGasFee(gas: number, feeRate: string): bigint;
+    static getGasToken(feeRate: string): string;
+    getFeeDetails(L1GasLimit: number, L2GasLimit: number, feeRate: string): {
+        maxFee: string;
+        version: "0x3" | "0x1";
+        resourceBounds: {
+            l1_gas: {
+                max_amount: string;
+                max_price_per_unit: string;
+            };
+            l2_gas: {
+                max_amount: string;
+                max_price_per_unit: string;
+            };
+        };
+        tip: string;
+        paymasterData: any[];
+        nonceDataAvailabilityMode: "L1" | "L2";
+        feeDataAvailabilityMode: "L1" | "L2";
+    };
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetFees = void 0;
+const Utils_1 = require("../../../utils/Utils");
+const StarknetTokens_1 = require("./StarknetTokens");
+const MAX_FEE_AGE = 5000;
+const ERC20_ADDRESS_ETH = "";
+const ERC20_ADDRESS_STRK = "";
+class StarknetFees {
+    constructor(provider, gasToken = "ETH", maxFeeRate = gasToken === "ETH" ? 100000000000 /*100 GWei*/ : 1000000000000000 /*100 * 10000 GWei*/, feeMultiplier = 1.25, da) {
+        this.logger = (0, Utils_1.getLogger)("StarknetFees: ");
+        this.blockFeeCache = null;
+        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
+     */
+    async _getFeeRate() {
+        const block = await this.provider.getBlockWithTxHashes("latest");
+        let l1GasCost = (0, Utils_1.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
+     */
+    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 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;
+    }
+    getDefaultGasToken() {
+        return this.gasToken === "ETH" ? StarknetTokens_1.StarknetTokens.ERC20_ETH : StarknetTokens_1.StarknetTokens.ERC20_STRK;
+    }
+    /**
+     * Calculates the total gas fee 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 gasPrice = BigInt(arr[0]);
+        return gasPrice * BigInt(gas);
+    }
+    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(L1GasLimit, L2GasLimit, feeRate) {
+        if (feeRate == null)
+            return null;
+        const arr = feeRate.split(";");
+        const gasPrice = BigInt(arr[0]);
+        const version = arr[1];
+        const maxFee = (0, Utils_1.toHex)(BigInt(L1GasLimit) * gasPrice, 16);
+        return {
+            maxFee: maxFee,
+            version: version === "v1" ? "0x1" : "0x3",
+            resourceBounds: {
+                l1_gas: { max_amount: (0, Utils_1.toHex)(L1GasLimit, 16), max_price_per_unit: (0, Utils_1.toHex)(gasPrice, 16) },
+                l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" }
+            },
+            tip: "0x0",
+            paymasterData: [],
+            nonceDataAvailabilityMode: this.nonceDA,
+            feeDataAvailabilityMode: this.feeDA
+        };
+    }
+}
+exports.StarknetFees = StarknetFees;

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

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { Buffer } from "buffer";
+import { StarknetModule } from "../StarknetModule";
+import { StarknetSigner } from "../../wallet/StarknetSigner";
+import { StarknetType, TypedData } from "starknet";
+import { StarknetBase } from "../StarknetBase";
+export declare class StarknetSignatures extends StarknetModule {
+    private readonly domain;
+    constructor(root: StarknetBase, 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/base/modules/StarknetSignatures.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSignatures = void 0;
+const createHash = require("create-hash");
+const StarknetModule_1 = require("../StarknetModule");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+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 new starknet_1.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
+     */
+    getDataSignature(signer, data) {
+        const buff = createHash("sha256").update(data).digest();
+        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 = createHash("sha256").update(data).digest();
+        return this.isValidSignature(signature, address, DataHash, 'DataHash', { "Data hash": starknet_1.cairo.uint256((0, Utils_1.toHex)(buff)) });
+    }
+}
+exports.StarknetSignatures = StarknetSignatures;

package/dist/starknet/base/modules/StarknetTokens.d.ts

@@ -0,0 +1,67 @@
+import { StarknetModule } from "../StarknetModule";
+import { StarknetAction } from "../StarknetAction";
+export declare class StarknetTokens extends StarknetModule {
+    static readonly ERC20_ETH = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
+    static readonly ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
+    static readonly GasCosts: {
+        TRANSFER: {
+            l1: number;
+            l2: number;
+        };
+        APPROVE: {
+            l1: number;
+            l2: number;
+        };
+    };
+    private getContract;
+    /**
+     * Action for transferring the erc20 token
+     *
+     * @param signer
+     * @param recipient
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Transfer;
+    /**
+     * Approves spend of tokens for a specific spender
+     *
+     * @param signer
+     * @param spender
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Approve(signer: string, spender: string, token: string, amount: bigint): StarknetAction;
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    isValidToken(token: string): boolean;
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    getTokenBalance(address: string, token: string): Promise<bigint>;
+    /**
+     * Returns the native currency address, return the default used by the fee module
+     */
+    getNativeCurrencyAddress(): string;
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    txsTransfer(signer: string, token: string, amount: bigint, recipient: string, feeRate?: string): Promise<import("./StarknetTransactions").StarknetTx[]>;
+}