@atomiqlabs/chain-evm 1.0.0-dev.100

package/src/evm/btcrelay/headers/EVMBtcStoredHeader.ts

@@ -0,0 +1,153 @@
+import {BigIntBufferUtils, BtcStoredHeader, StatePredictorUtils} from "@atomiqlabs/base";
+import {EVMBtcHeader, EVMBtcHeaderType} from "./EVMBtcHeader";
+import {Buffer} from "buffer";
+import {keccak256} from "ethers";
+
+export type StarknetBtcStoredHeaderType = {
+    blockheader: EVMBtcHeader | EVMBtcHeaderType,
+    blockHash: Buffer,
+    chainWork: bigint,
+    blockHeight: number,
+    lastDiffAdjustment: number,
+    prevBlockTimestamps: number[]
+}
+
+export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
+
+    blockheader: EVMBtcHeader;
+    blockHash: Buffer;
+    chainWork: bigint;
+    blockHeight: number;
+    lastDiffAdjustment: number;
+    prevBlockTimestamps: number[];
+
+    constructor(obj: StarknetBtcStoredHeaderType) {
+        this.blockheader = obj.blockheader instanceof EVMBtcHeader ? obj.blockheader : new EVMBtcHeader(obj.blockheader);
+        this.blockHash = obj.blockHash;
+        this.chainWork = obj.chainWork;
+        this.blockHeight = obj.blockHeight;
+        this.lastDiffAdjustment = obj.lastDiffAdjustment;
+        this.prevBlockTimestamps = obj.prevBlockTimestamps;
+    }
+
+    getBlockheight(): number {
+        return this.blockHeight;
+    }
+
+    getChainWork(): Buffer {
+        return Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
+    }
+
+    getHeader(): EVMBtcHeader {
+        return this.blockheader;
+    }
+
+    getLastDiffAdjustment(): number {
+        return this.lastDiffAdjustment;
+    }
+
+    getPrevBlockTimestamps(): number[] {
+        return this.prevBlockTimestamps;
+    }
+
+    getBlockHash(): Buffer {
+        return Buffer.from([...this.blockHash]).reverse();
+    }
+
+    /**
+     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
+     *  this block's timestamp to the end
+     *
+     * @private
+     */
+    private computeNextBlockTimestamps(): number[] {
+        const prevBlockTimestamps = [...this.prevBlockTimestamps];
+        for(let i=1;i<10;i++) {
+            prevBlockTimestamps[i-1] = prevBlockTimestamps[i];
+        }
+        prevBlockTimestamps[9] = this.blockheader.getTimestamp();
+        return prevBlockTimestamps;
+    }
+
+    /**
+     * Computes total chain work after a new header with "nbits" is added to the chain
+     *
+     * @param nbits
+     * @private
+     */
+    private computeNextChainWork(nbits: number): bigint {
+        return this.chainWork + BigIntBufferUtils.fromBuffer(StatePredictorUtils.getChainwork(nbits));
+    }
+
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    private computeNextLastDiffAdjustment(headerTimestamp: number) {
+        const blockheight = this.blockHeight+1;
+
+        let lastDiffAdjustment = this.lastDiffAdjustment;
+        if(blockheight % StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
+            lastDiffAdjustment = headerTimestamp;
+        }
+
+        return lastDiffAdjustment;
+    }
+
+    computeNext(header: EVMBtcHeader): EVMBtcStoredHeader {
+        header.previousBlockhash = this.blockHash;
+        return new EVMBtcStoredHeader({
+            chainWork: this.computeNextChainWork(header.getNbits()),
+            prevBlockTimestamps: this.computeNextBlockTimestamps(),
+            blockHeight: this.blockHeight+1,
+            lastDiffAdjustment: this.computeNextLastDiffAdjustment(header.getTimestamp()),
+            blockHash: header.getHash(),
+            blockheader: header
+        });
+    }
+
+    getCommitHash(): string {
+        return keccak256(this.serialize());
+    }
+
+    serialize(): Buffer {
+        const buffer = Buffer.alloc(160);
+        this.blockheader.serialize().copy(buffer, 0, 0, 80);
+        BigIntBufferUtils.toBuffer(this.chainWork, "be", 32).copy(buffer, 80, 0, 32);
+        buffer.writeUint32BE(this.blockHeight, 112);
+        buffer.writeUint32BE(this.lastDiffAdjustment, 116);
+        for(let i=0;i<10;i++) {
+            buffer.writeUint32BE(this.prevBlockTimestamps[i], 120 + (i*4));
+        }
+        return buffer;
+    }
+
+    serializeToStruct(): {data: [string, string, string, string, string]} {
+        const buffer = this.serialize();
+        const result: string[] = [];
+        for(let i=0;i<5;i++) {
+            result[i] = "0x"+buffer.subarray(i*32, (i+1)*32).toString("hex");
+        }
+        return {data: result as any};
+    }
+
+    static deserialize(data: Buffer): EVMBtcStoredHeader {
+        if(data.length!==160) throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
+        const blockheader = EVMBtcHeader.deserialize(data.subarray(0, 80));
+        const prevBlockTimestamps: number[] = [];
+        for(let i=0;i<10;i++) {
+            prevBlockTimestamps[i] = data.readUint32BE(120 + (i*4));
+        }
+        return new EVMBtcStoredHeader({
+            blockheader,
+            blockHash: blockheader.getHash(),
+            chainWork: BigIntBufferUtils.fromBuffer(data.subarray(80, 112)),
+            blockHeight: data.readUint32BE(112),
+            lastDiffAdjustment: data.readUint32BE(116),
+            prevBlockTimestamps
+        });
+    }
+
+}

package/src/evm/chain/EVMChainInterface.ts

@@ -0,0 +1,189 @@
+import {ChainInterface, TransactionConfirmationOptions} from "@atomiqlabs/base";
+import {getLogger, LoggerType} from "../../utils/Utils";
+import {
+    BrowserProvider,
+    JsonRpcApiProvider,
+    JsonRpcSigner,
+    Signer,
+    Transaction,
+    TransactionRequest,
+    Wallet,
+    getAddress
+} from "ethers";
+import {EVMBlocks, EVMBlockTag} from "./modules/EVMBlocks";
+import {EVMEvents} from "./modules/EVMEvents";
+import {EVMFees} from "./modules/EVMFees";
+import {EVMTokens} from "./modules/EVMTokens";
+import {EVMTransactions, EVMTx} from "./modules/EVMTransactions";
+import { EVMSignatures } from "./modules/EVMSignatures";
+import {EVMAddresses} from "./modules/EVMAddresses";
+import {EVMSigner} from "../wallet/EVMSigner";
+import {EVMBrowserSigner} from "../wallet/EVMBrowserSigner";
+
+export type EVMRetryPolicy = {
+    maxRetries?: number,
+    delay?: number,
+    exponential?: boolean
+}
+
+export type EVMConfiguration = {
+    safeBlockTag: EVMBlockTag,
+    maxLogsBlockRange: number,
+    maxParallelLogRequests: number,
+    maxParallelCalls: number,
+    maxLogTopics: number
+};
+
+export class EVMChainInterface<ChainId extends string = string> implements ChainInterface<EVMTx, EVMSigner, ChainId, Signer> {
+
+    readonly chainId: ChainId;
+
+    readonly provider: JsonRpcApiProvider;
+    readonly retryPolicy: EVMRetryPolicy;
+
+    public readonly evmChainId: number;
+
+    public readonly config: EVMConfiguration;
+
+    public Fees: EVMFees;
+    public Tokens: EVMTokens;
+    public Transactions: EVMTransactions;
+    public Signatures: EVMSignatures;
+    public Events: EVMEvents;
+    public Blocks: EVMBlocks;
+
+    protected logger: LoggerType;
+
+    constructor(
+        chainId: ChainId,
+        evmChainId: number,
+        provider: JsonRpcApiProvider,
+        config: EVMConfiguration,
+        retryPolicy?: EVMRetryPolicy,
+        evmFeeEstimator: EVMFees = new EVMFees(provider)
+    ) {
+        this.chainId = chainId;
+        this.evmChainId = evmChainId;
+        this.provider = provider;
+        this.retryPolicy = retryPolicy;
+        this.config = config;
+        this.config.safeBlockTag ??= "safe";
+
+        this.logger = getLogger("EVMChainInterface("+this.evmChainId+"): ");
+
+        this.Fees = evmFeeEstimator;
+        this.Tokens = new EVMTokens(this);
+        this.Transactions = new EVMTransactions(this);
+        this.Signatures = new EVMSignatures(this);
+        this.Events = new EVMEvents(this);
+        this.Blocks = new EVMBlocks(this);
+    }
+
+
+    async getBalance(signer: string, tokenAddress: string): Promise<bigint> {
+        //TODO: For native token we should discount the cost of transactions
+        return await this.Tokens.getTokenBalance(signer, tokenAddress);
+    }
+
+    getNativeCurrencyAddress(): string {
+        return this.Tokens.getNativeCurrencyAddress();
+    }
+
+    isValidToken(tokenIdentifier: string): boolean {
+        return this.Tokens.isValidToken(tokenIdentifier);
+    }
+
+    isValidAddress(address: string): boolean {
+        return EVMAddresses.isValidAddress(address);
+    }
+
+    normalizeAddress(address: string): string {
+        return getAddress(address);
+    }
+
+    ///////////////////////////////////
+    //// Callbacks & handlers
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
+        return true;
+    }
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {}
+
+    onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void {
+        this.Transactions.onBeforeTxSigned(callback);
+    }
+
+    offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean {
+        return this.Transactions.offBeforeTxSigned(callback);
+    }
+
+    randomAddress(): string {
+        return EVMAddresses.randomAddress();
+    }
+
+    randomSigner(): EVMSigner {
+        const wallet = Wallet.createRandom();
+        return new EVMSigner(wallet, wallet.address);
+    }
+
+    ////////////////////////////////////////////
+    //// Transactions
+    sendAndConfirm(
+        signer: EVMSigner,
+        txs: TransactionRequest[],
+        waitForConfirmation?: boolean,
+        abortSignal?: AbortSignal,
+        parallel?: boolean,
+        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>
+    ): Promise<string[]> {
+        return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
+    }
+
+    serializeTx(tx: Transaction): Promise<string> {
+        return this.Transactions.serializeTx(tx);
+    }
+
+    deserializeTx(txData: string): Promise<Transaction> {
+        return this.Transactions.deserializeTx(txData);
+    }
+
+    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxIdStatus(txId);
+    }
+
+    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted"> {
+        return this.Transactions.getTxStatus(tx);
+    }
+
+    async getFinalizedBlock(): Promise<{ height: number; blockHash: string }> {
+        const block = await this.Blocks.getBlock("finalized");
+        return {
+            height: block.number,
+            blockHash: block.hash
+        };
+    }
+
+    async txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TransactionRequest[]> {
+        return [await this.Tokens.Transfer(signer, token, amount, dstAddress, feeRate)];
+    }
+
+    async transfer(
+        signer: EVMSigner,
+        token: string,
+        amount: bigint,
+        dstAddress: string,
+        txOptions?: TransactionConfirmationOptions
+    ): Promise<string> {
+        const tx = await this.Tokens.Transfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
+        const [txId] = await this.Transactions.sendAndConfirm(signer, [tx], txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
+        return txId;
+    }
+
+    async wrapSigner(signer: Signer): Promise<EVMSigner> {
+        const address = await signer.getAddress();
+        if(signer instanceof JsonRpcSigner || signer.provider instanceof BrowserProvider) {
+            return new EVMBrowserSigner(signer, address);
+        }
+        return new EVMSigner(signer, address);
+    }
+
+}

package/src/evm/chain/EVMModule.ts

@@ -0,0 +1,21 @@
+import {getLogger} from "../../utils/Utils";
+import {JsonRpcApiProvider} from "ethers";
+import {EVMChainInterface, EVMRetryPolicy} from "./EVMChainInterface";
+
+export class EVMModule<ChainId extends string = string> {
+
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly retryPolicy: EVMRetryPolicy;
+    protected readonly root: EVMChainInterface<ChainId>;
+
+    protected readonly logger = getLogger(this.constructor.name+": ");
+
+    constructor(
+        root: EVMChainInterface<ChainId>
+    ) {
+        this.provider = root.provider;
+        this.retryPolicy = root.retryPolicy;
+        this.root = root;
+    }
+
+}

package/src/evm/chain/modules/ERC20Abi.ts

@@ -0,0 +1,222 @@
+export const ERC20Abi = [
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_spender",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_from",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            },
+            {
+                "name": "_spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "payable": true,
+        "stateMutability": "payable",
+        "type": "fallback"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    }
+] as const;

package/src/evm/chain/modules/EVMAddresses.ts

@@ -0,0 +1,29 @@
+import {EVMModule} from "../EVMModule";
+import {Wallet, isAddress} from "ethers";
+
+
+export class EVMAddresses extends EVMModule<any> {
+
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid EVM address
+     *
+     * @param value
+     */
+    static isValidAddress(value: string): boolean {
+        if(value.length!==42) return false;
+        try {
+            isAddress(value);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    static randomAddress(): string {
+        const wallet = Wallet.createRandom();
+        return wallet.address;
+    }
+
+}

package/src/evm/chain/modules/EVMBlocks.ts

@@ -0,0 +1,86 @@
+import {EVMModule} from "../EVMModule";
+import {Block} from "ethers";
+
+export type EVMBlockTag = "safe" | "pending" | "latest" | "finalized";
+
+export class EVMBlocks extends EVMModule<any> {
+
+    private BLOCK_CACHE_TIME = 5*1000;
+
+    private blockCache: {
+        [key: string]: {
+            block: Promise<Block>,
+            timestamp: number
+        }
+    } = {};
+
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime(blockTag: EVMBlockTag | number): {
+        block: Promise<Block>,
+        timestamp: number
+    } {
+        const blockTagStr = blockTag.toString(10);
+
+        const blockPromise = this.provider.getBlock(blockTag, false);
+        const timestamp = Date.now();
+        this.blockCache[blockTagStr] = {
+            block: blockPromise,
+            timestamp
+        };
+        blockPromise.catch(e => {
+            if(this.blockCache[blockTagStr]!=null && this.blockCache[blockTagStr].block===blockPromise) delete this.blockCache[blockTagStr];
+            throw e;
+        })
+        return {
+            block: blockPromise,
+            timestamp
+        };
+    }
+
+    private cleanupBlocks() {
+        const currentTime = Date.now();
+        //Keys are in order that they were added, so we can stop at the first non-expired block
+        for(let key in this.blockCache) {
+            const block = this.blockCache[key];
+            if(currentTime - block.timestamp > this.BLOCK_CACHE_TIME) {
+                delete this.blockCache[key];
+            } else {
+                break;
+            }
+        }
+    }
+
+    ///////////////////
+    //// Blocks
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    public getBlock(blockTag: EVMBlockTag | number): Promise<Block> {
+        this.cleanupBlocks();
+        let cachedBlockData = this.blockCache[blockTag.toString(10)];
+
+        if(cachedBlockData==null || Date.now()-cachedBlockData.timestamp>this.BLOCK_CACHE_TIME) {
+            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
+        }
+
+        return cachedBlockData.block;
+    }
+
+    /**
+     * Gets the block time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    public async getBlockTime(blockTag: EVMBlockTag | number): Promise<number> {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
+    }
+
+}