@atomiqlabs/chain-starknet 1.0.0-beta.0

package/src/starknet/base/modules/StarknetAccounts.ts

@@ -0,0 +1,26 @@
+import {StarknetModule} from "../StarknetModule";
+import {StarknetTx} from "./StarknetTransactions";
+import {DeployAccountContractPayload} from "starknet";
+
+
+export class StarknetAccounts extends StarknetModule {
+
+    public async getAccountDeployTransaction(deploymentData: DeployAccountContractPayload): Promise<StarknetTx> {
+        const feeDetails = this.root.Fees.getFeeDetails(5000, 0, await this.root.Fees.getFeeRate());
+        const details = {
+            ...feeDetails,
+            walletAddress: deploymentData.contractAddress,
+            cairoVersion: "1" as const,
+            chainId: this.root.starknetChainId,
+            nonce: 0,
+            accountDeploymentData: [],
+            skipValidate: false
+        };
+        return {
+            type: "DEPLOY_ACCOUNT",
+            tx: deploymentData,
+            details
+        };
+    }
+
+}

package/src/starknet/base/modules/StarknetAddresses.ts

@@ -0,0 +1,23 @@
+import {StarknetModule} from "../StarknetModule";
+import {validateAndParseAddress} from "starknet";
+
+export class StarknetAddresses extends StarknetModule {
+
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid starknet address
+     *
+     * @param value
+     */
+    isValidAddress(value: string): boolean {
+        if(value.length!==66) return false;
+        try {
+            validateAndParseAddress(value);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+}

package/src/starknet/base/modules/StarknetBlocks.ts

@@ -0,0 +1,59 @@
+import {StarknetModule} from "../StarknetModule";
+
+export type StarknetBlockTag = "pending" | "latest";
+
+export class StarknetBlocks extends StarknetModule {
+
+    private BLOCK_CACHE_TIME = 5*1000;
+
+    private blockCache: {
+        [key in StarknetBlockTag]?: {
+            blockTime: Promise<number>,
+            timestamp: number
+        }
+    } = {};
+
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime(blockTag: StarknetBlockTag): {
+        blockTime: Promise<number>,
+        timestamp: number
+    } {
+        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
+     */
+    public getBlockTime(blockTag: StarknetBlockTag): Promise<number> {
+        let cachedBlockData = this.blockCache[blockTag];
+
+        if(cachedBlockData==null || Date.now()-cachedBlockData.timestamp>this.BLOCK_CACHE_TIME) {
+            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
+        }
+
+        return cachedBlockData.blockTime;
+    }
+
+}

package/src/starknet/base/modules/StarknetEvents.ts

@@ -0,0 +1,105 @@
+import {StarknetModule} from "../StarknetModule";
+
+export type StarknetEvent = {
+    block_hash: string;
+    block_number: number;
+    transaction_hash: string;
+    from_address: string;
+    keys: string[];
+    data: string[];
+}
+
+export class StarknetEvents extends StarknetModule {
+
+    public readonly EVENTS_LIMIT = 100;
+    public 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
+     */
+    public async getBlockEvents(contract: string, keys: string[][], startBlock?: number, endBlock: number = startBlock, abortSignal?: AbortSignal): Promise<StarknetEvent[]> {
+        const events: StarknetEvent[] = [];
+        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
+     */
+    public async findInEvents<T>(
+        contract: string, keys: string[][],
+        processor: (signatures: StarknetEvent[]) => Promise<T>,
+        abortSignal?: AbortSignal
+    ): Promise<T> {
+        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: T = 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
+     */
+    public async findInEventsForward<T>(
+        contract: string, keys: string[][],
+        processor: (signatures: StarknetEvent[]) => Promise<T>,
+        abortSignal?: AbortSignal,
+        logFetchLimit?: number
+    ): Promise<T> {
+        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: T = await processor(eventsResult.events);
+            if(result!=null) return result;
+        }
+        return null;
+    }
+
+}

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

@@ -0,0 +1,136 @@
+import {getLogger, toBigInt, toHex} from "../../../utils/Utils";
+import {Provider} from "starknet";
+import {StarknetTokens} from "./StarknetTokens";
+
+const MAX_FEE_AGE = 5000;
+
+const ERC20_ADDRESS_ETH = "";
+const ERC20_ADDRESS_STRK = "";
+
+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" = "ETH",
+        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
+        }
+    }
+
+}

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

@@ -0,0 +1,91 @@
+import * as createHash from "create-hash";
+import {Buffer} from "buffer";
+import {StarknetModule} from "../StarknetModule";
+import {StarknetSigner} from "../../wallet/StarknetSigner";
+import {
+    Account, cairo,
+    shortString,
+    stark,
+    StarknetDomain, StarknetType,
+    TypedData
+} from "starknet";
+import {StarknetBase} from "../StarknetBase";
+import {toHex} from "../../../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' }
+];
+
+export class StarknetSignatures extends StarknetModule {
+
+    private readonly domain: StarknetDomain;
+
+    constructor(root: StarknetBase, 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 = createHash("sha256").update(data).digest();
+        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 = createHash("sha256").update(data).digest();
+        return this.isValidSignature(signature, address, DataHash, 'DataHash', {"Data hash": cairo.uint256(toHex(buff))});
+    }
+
+}

package/src/starknet/base/modules/StarknetTokens.ts

@@ -0,0 +1,116 @@
+import {StarknetModule} from "../StarknetModule";
+import {StarknetAction} from "../StarknetAction";
+import {ERC20Abi} from "./ERC20Abi";
+import { Contract } from "starknet";
+import {toBigInt} from "../../../utils/Utils";
+
+
+export class StarknetTokens extends StarknetModule {
+
+    public static readonly ERC20_ETH = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
+    public static readonly ERC20_STRK = "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d";
+
+    public static readonly GasCosts = {
+        TRANSFER: {l1: 400, l2: 0},
+        APPROVE: {l1: 400, l2: 0}
+    };
+
+    private getContract(address: string) {
+        return new Contract(ERC20Abi, address, this.root.provider).typedv2(ERC20Abi);
+    }
+
+    /**
+     * Action for transferring the erc20 token
+     *
+     * @param signer
+     * @param recipient
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Transfer(signer: string, recipient: string, token: string, amount: bigint): StarknetAction {
+        const erc20 = this.getContract(token);
+        return new StarknetAction(signer, this.root,
+            erc20.populateTransaction.transfer(recipient, amount),
+            StarknetTokens.GasCosts.TRANSFER
+        );
+    }
+
+    /**
+     * Approves spend of tokens for a specific spender
+     *
+     * @param signer
+     * @param spender
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    public Approve(signer: string, spender: string, token: string, amount: bigint): StarknetAction {
+        const erc20 = this.getContract(token);
+        return new StarknetAction(signer, this.root,
+            erc20.populateTransaction.approve(spender, amount),
+            StarknetTokens.GasCosts.APPROVE
+        );
+    }
+
+    ///////////////////
+    //// Tokens
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    public isValidToken(token: string) {
+        return this.root.Addresses.isValidAddress(token);
+    }
+
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    public async getTokenBalance(address: string, token: string): Promise<bigint> {
+        const erc20 = this.getContract(token);
+        const balance = await erc20.balance_of(address);
+        const balanceBN = toBigInt(balance);
+
+        this.logger.debug("getTokenBalance(): token balance fetched, token: "+token+
+            " address: "+address+" amount: "+balanceBN.toString());
+
+        return balanceBN;
+    }
+
+    /**
+     * Returns the native currency address, return the default used by the fee module
+     */
+    public getNativeCurrencyAddress(): string {
+        return this.root.Fees.getDefaultGasToken();
+    }
+
+    ///////////////////
+    //// Transfers
+    /**
+     * 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
+     */
+    public async txsTransfer(signer: string, token: string, amount: bigint, recipient: string, feeRate?: string) {
+        const action = this.Transfer(signer, recipient, token, amount);
+
+        feeRate = feeRate ?? await this.root.Fees.getFeeRate();
+
+        this.logger.debug("txsTransfer(): transfer TX created, recipient: "+recipient.toString()+
+            " token: "+token.toString()+ " amount: "+amount.toString(10));
+
+        return [await action.tx(feeRate)];
+    }
+
+}