@kynesyslabs/demosdk 1.0.21 → 1.0.22

package/src/multichain/core/evm.ts

@@ -1,275 +0,0 @@
-import {
-    Contract,
-    JsonRpcProvider,
-    TransactionReceipt,
-    TransactionRequest,
-    Wallet,
-    formatEther,
-    parseEther,
-} from 'ethers'
-import { DefaultChain, IEVMDefaultChain } from './types/defaultChain'
-import { IPayOptions } from './types/interfaces'
-import { required } from './utils'
-
-export class EVM extends DefaultChain implements IEVMDefaultChain {
-    declare provider: JsonRpcProvider
-    declare wallet: Wallet
-
-    contracts: Map<string, Contract> = new Map()
-    isEIP1559: boolean
-    chainId: number
-
-    constructor(
-        rpc_url: string = '',
-        eip1559: boolean = true,
-        chainId: number = 11155111
-    ) {
-        super(rpc_url)
-        this.name = 'evm'
-
-        this.chainId = chainId
-        this.isEIP1559 = eip1559
-
-        if (rpc_url) {
-            this.setRPC(rpc_url)
-        }
-    }
-
-    // INFO Set of methods for connecting to an RPC while
-    // retaining a granular control over the instance status
-    async setRPC(rpc_url: string) {
-        this.provider = new JsonRpcProvider(rpc_url)
-    }
-
-    async connect() {
-        required(this.provider, 'Provider not connected')
-
-        try {
-            const network = await this.provider.getNetwork()
-            this.connected = Boolean(network.name)
-        } catch (error) {
-            this.connected = false
-        }
-
-        return this.connected
-    }
-
-    // static override async create(
-    //     rpc_url: string = '',
-    //     eip1559: boolean = true,
-    //     chainId: number = 11155111
-    // ): Promise<EVM> {
-    //     const instance = new EVM(rpc_url, eip1559, chainId)
-    //     if (rpc_url) {
-    //         await instance.connect()
-    //     }
-    //     return instance
-    // }
-
-    // INFO Connecting a wallet through a private key (string)
-    // REVIEW should private key be a string or a Buffer?
-    async connectWallet(privateKey: string) {
-        required(this.provider, 'Provider not connected')
-        this.wallet = new Wallet(privateKey, this.provider)
-    }
-
-    // INFO Signing a transaction
-    // with a private key or by using our stored wallet
-    // REVIEW should private key be a string or a Buffer?
-    async signTransaction(
-        transaction: TransactionRequest,
-        options?: {
-            privateKey?: string
-        }
-    ) {
-        const txs = await this.signTransactions([transaction], options)
-
-        return txs[0]
-    }
-
-    async signTransactions(
-        transactions: TransactionRequest[],
-        options?: {
-            privateKey?: string
-        }
-    ) {
-        required(this.wallet || options?.privateKey, 'Wallet not connected')
-
-        if (options?.privateKey) {
-            this.wallet = new Wallet(options.privateKey, this.provider)
-        }
-
-        // INFO: Get the current nonce
-        const this_address = this.getAddress()
-        let currentNonce = await this.provider.getTransactionCount(this_address)
-
-        // INFO: Return a list of signed transactions
-        return Promise.all(
-            transactions.map(async (tx) => {
-                tx.nonce = currentNonce
-
-                // INFO: Increment the nonce for the next transaction
-                currentNonce++
-                return this.wallet.signTransaction(tx)
-            })
-        )
-    }
-
-    // SECTION Specific methods
-
-    // REVIEW Should prepare methods be like:
-    // prepare = { pay(), send(), ...}
-
-    async preparePay(address: string, amount: string) {
-        const tx = await this.preparePays([{ address, amount }])
-        return tx[0]
-    }
-
-    async preparePays(payments: IPayOptions[]) {
-        required(this.wallet, 'Wallet not connected')
-
-        const baseTx = await this.prepareBaseTxWithType()
-
-        const txs = payments.map((payment) => {
-            const tx = {
-                ...baseTx,
-                to: payment.address,
-                value: parseEther(payment.amount as string),
-            }
-
-            // INFO: wallet.checkTransaction was removed in ethers v6
-            // const checkedTx = this.wallet.checkTransaction(tx);
-            // console.log('checked', checkedTx);
-
-            return tx
-        })
-
-        return this.signTransactions(txs)
-    }
-
-    async prepareTransfer(address: string, amount: string) {
-        return this.preparePay(address, amount)
-    }
-
-    async prepareTransfers(payments: IPayOptions[]) {
-        return this.preparePays(payments)
-    }
-
-    // SECTION EVM Specific methods
-    // INFO Generic transaction skeleton for both EIP-1559 and legacy chains
-    async prepareBaseTxWithType() {
-        const feeData = await this.provider.getFeeData()
-        // console.log({ baseFeePerGas: parseInt(feeData.lastBaseFeePerGas._hex, 16) });
-
-        const baseTx = {
-            // REVIEW: is there a way to get the gas limit from the provider?
-            gasLimit: 21000,
-            chainId: this.chainId,
-        }
-
-        if (this.isEIP1559) {
-            return {
-                ...baseTx,
-                type: 2,
-                maxFeePerGas: feeData.maxFeePerGas,
-                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-            }
-        }
-
-        return {
-            ...baseTx,
-            // INFO: ethers v5 used this line 👇
-            // gasPrice: feeData.lastBaseFeePerGas
-            gasPrice: feeData.gasPrice,
-        }
-    }
-
-    // INFO Generic empty tx skeleton for this chain
-    async getEmptyTransaction() {
-        // NOTE This is a redirection to the prepareBaseTxWithType method as in a evm chain is like that
-        return await this.prepareBaseTxWithType()
-    }
-
-    // megabudino was here – return the address of the wallet
-    getAddress() {
-        return this.wallet.address
-    }
-
-    async getBalance(address: string): Promise<string> {
-        let balance_raw = await this.provider.getBalance(address)
-        return formatEther(balance_raw)
-    }
-
-    // SECTION EVM Exclusive methods
-    async createRawTransaction(tx_data: any): Promise<any> {
-        throw new Error('Not implemented')
-    }
-
-    async waitForReceipt(tx_hash: string): Promise<any> {
-        return await this.provider.getTransactionReceipt(tx_hash)
-    }
-    // SECTION Not implemented methods
-
-    async getContractInstance(address: string, abi: string): Promise<Contract> {
-        console.log(this)
-        if (!this.provider) {
-            throw new Error('Provider not connected')
-        }
-        let contract = new Contract(address, abi, this.provider)
-        return contract
-    }
-
-    // REVIEW Reader for contracts
-    // ANCHOR MVP
-    async readFromContract(
-        contract_instance: Contract,
-        function_name: string,
-        args: any
-    ): Promise<any> {
-        return await contract_instance[function_name](...args)
-    }
-
-    // REVIEW Writer for contracts
-    async writeToContract(
-        contract_instance: Contract,
-        function_name: string,
-        args: any
-    ): Promise<any> {
-        required(this.wallet)
-        return await contract_instance[function_name](...args) // NOTE Ensure it is writeable i guess
-    }
-
-    // SECTION Event listener
-    async listenForEvent(
-        event: string,
-        contract: string,
-        abi: any[]
-    ): Promise<any> {
-        if (!this.provider) {
-            throw new Error('Provider not connected')
-        }
-        let contractInstance = new Contract(contract, abi, this.provider)
-        // REVIEW THis could work
-        return contractInstance.on(event, (data: any) => {
-            ////console.log(data)
-            // TODO Do something with the data
-        })
-    }
-
-    async listenForAllEvents(contract: string, abi: any[]): Promise<any> {
-        if (!this.provider) {
-            throw new Error('Provider not connected')
-        }
-        let contractInstance = new Contract(contract, abi, this.provider)
-        // REVIEW 99% Won't work
-        return contractInstance.on('*', (data: any) => {
-            ////console.log(data)
-            // TODO Do something with the data
-        })
-    }
-
-    async disconnect() {
-        this.resetInstance()
-        return !this.connected
-    }
-}

package/src/multichain/core/ibc.ts

@@ -1,318 +0,0 @@
-import {
-    DirectSecp256k1HdWallet,
-    DirectSecp256k1Wallet,
-} from '@cosmjs/proto-signing'
-import {
-    SigningStargateClient,
-    StargateClient,
-    calculateFee,
-} from '@cosmjs/stargate'
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx'
-
-import { DefaultChain, IBCDefaultChain } from './types/defaultChain'
-import {
-    IBCConnectWalletOptions,
-    IBCGetBalanceOptions,
-    IBCPreparePayOptions,
-    IBCSignTxOptions,
-    IBCTransaction,
-    IPayOptions,
-} from './types/interfaces'
-import { required } from './utils'
-
-export class IBC extends DefaultChain implements IBCDefaultChain {
-    address: string = ''
-    chainID: string = ''
-    declare provider: StargateClient
-    declare wallet: SigningStargateClient
-    declare signer: DirectSecp256k1Wallet | DirectSecp256k1HdWallet
-
-    // IBC options
-    gasPrice: string = ''
-    multiplier: number = 2.0
-
-    constructor(rpc_url: string) {
-        super(rpc_url)
-        this.name = 'ibc'
-
-        // INFO: We can't await here, so we call .setRPC in .create()
-        // if (rpc_url) {
-        // 	this.setRPC(rpc_url);
-        // }
-    }
-
-    // override async setRpc(rpc_url: string) {
-    //     this.provider = await StargateClient.connect(rpc_url)
-    // }
-
-    // static override async create(rpc_url: string): Promise<IBC> {
-    //     const instance = new IBC(rpc_url)
-
-    //     if (rpc_url) {
-    //         // INFO: Set rpc url and ping it.
-    //         await instance.setRPC(rpc_url)
-    //         await instance.connect()
-    //     }
-
-    //     return instance
-    // }
-
-    // INFO: rpc_url used to avoid overwriting this.provider for test mocking
-    async connect(rpc_url?: string) {
-        if (rpc_url !== this.rpc_url) {
-            this.provider = await StargateClient.connect(this.rpc_url)
-        }
-
-        try {
-            const chain_id = await this.provider.getChainId()
-            this.chainID = chain_id
-
-            this.connected = Boolean(chain_id)
-        } catch (error) {
-            this.connected = false
-        }
-
-        return this.connected
-    }
-
-    async connectWallet(privateKey: string, options: IBCConnectWalletOptions) {
-        required(options.prefix, 'Address prefix not provided')
-        required(options.gasPrice, 'Gas price not provided')
-
-        // INFO: Store the gasPrice for preparePays and other methods
-        this.gasPrice = options.gasPrice
-
-        // INFO: Check if privateKey is a mnemonic or a private key
-        const isPrivateKey = privateKey.split(' ').length === 1
-
-        // INFO: Create a signer using the appropriate wallet
-        if (isPrivateKey) {
-            // TODO: Test this block!
-            const buffer = Buffer.from(privateKey, 'hex')
-            this.signer = await DirectSecp256k1Wallet.fromKey(
-                buffer,
-                options.prefix
-            )
-        } else {
-            this.signer = await DirectSecp256k1HdWallet.fromMnemonic(
-                privateKey,
-                {
-                    prefix: options.prefix,
-                }
-            )
-        }
-
-        // INFO: Store the address as .getAddress can't be async
-        const wallet_accounts = await this.signer.getAccounts()
-        const this_account = wallet_accounts.find((account) =>
-            account.address.startsWith(options.prefix)
-        )
-
-        if (this_account) {
-            this.address = this_account.address
-        } else {
-            throw new Error(`No account found for prefix: ${options.prefix}`)
-        }
-
-        this.wallet = await SigningStargateClient.connectWithSigner(
-            this.rpc_url,
-            this.signer
-        )
-        return this.wallet
-    }
-
-    getAddress() {
-        return this.address
-    }
-
-    /**
-     * Get the balance of the address
-     * @param address The address
-     * @returns The balance of the address in the specified denomination
-     */
-    async getBalance(address: string, options: IBCGetBalanceOptions) {
-        required(this.provider, 'Provider not connected')
-
-        const coins = await this.provider.getBalance(address, options.denom)
-        return coins.amount
-    }
-
-    getEmptyTransaction(): IBCTransaction {
-        return {
-            signerAddress: this.getAddress(),
-            messages: [
-                {
-                    typeUrl: '/cosmos.bank.v1beta1.MsgSend',
-                    value: {
-                        fromAddress: this.getAddress(),
-                        toAddress: '',
-                        amount: [{ denom: '', amount: '' }],
-                    },
-                },
-            ],
-            // INFO: Fees are to be estimated when filling the tx
-            fee: null,
-            memo: '',
-        }
-    }
-
-    async preparePay(
-        receiver: string,
-        amount: string,
-        options: IBCPreparePayOptions
-    ) {
-        // INFO: Call preparePays with a single payment
-        const tx = await this.preparePays(
-            [{ address: receiver, amount }],
-            options
-        )
-        return tx[0]
-    }
-
-    prepareTransfer(
-        receiver: string,
-        amount: string,
-        options: IBCPreparePayOptions
-    ) {
-        return this.preparePay(receiver, amount, options)
-    }
-
-    /**
-     * Prepare multiple payments
-     * @param payments An array of payments
-     * @param options Specifies the denomination of the token
-     * @returns An array of signed transactions
-     */
-    prepareTransfers(payments: IPayOptions[], options: IBCPreparePayOptions) {
-        return this.preparePays(payments, options)
-    }
-
-    /**
-     * Prepare multiple payments
-     * @param payments An array of payments
-     * @param options Specifies the denomination of the token
-     * @returns An array of signed transactions
-     */
-    async preparePays(payments: IPayOptions[], options: IBCPreparePayOptions) {
-        // INFO: Create an array of transactions
-        const txs = payments.map((payment) => {
-            const tx = this.getEmptyTransaction()
-
-            // INFO: Fill the tx
-            tx.messages[0].value.toAddress = payment.address
-
-            tx.messages[0].value.amount = [
-                {
-                    denom: options.denom,
-                    amount: payment.amount as string,
-                },
-            ]
-            return tx
-        })
-
-        // INFO: Estimate the fee for the first tx
-        const fees = await this.estimateTxFee(txs[0])
-
-        // INFO: Since all txs here are similar, set same fee for all
-        txs.forEach((tx) => {
-            tx.fee = fees
-        })
-
-        // INFO: Sign and return the txs
-        return await this.signTransactions(txs)
-    }
-
-    async signTransaction(tx: IBCTransaction, options?: IBCSignTxOptions) {
-        // INFO: Call signTransactions with a single tx
-        const signed_txs = await this.signTransactions([tx], options)
-        return signed_txs[0]
-    }
-
-    /**
-     * Estimate the fee for a transaction
-     * @param tx The transaction
-     * @returns The estimate fee for the transaction
-     */
-    private async estimateTxFee(tx: IBCTransaction) {
-        const signerAddress = this.getAddress()
-        const gasEstimate = await this.wallet.simulate(
-            signerAddress,
-            tx.messages,
-            tx.memo
-        )
-
-        const gasLimit = Math.round(gasEstimate * this.multiplier)
-        return calculateFee(gasLimit, this.gasPrice)
-    }
-
-    async signTransactions(
-        transactions: IBCTransaction[],
-        options?: IBCSignTxOptions
-    ) {
-        required(this.wallet, 'Wallet not connected')
-
-        if (options?.privateKey) {
-            const { privateKey, ...connectOptions } = options
-            await this.connectWallet(privateKey, connectOptions)
-        }
-
-        // NOTE: Sequence management happens here
-        // INFO: Get account on network
-        const address = this.getAddress()
-        const account = await this.wallet.getAccount(address)
-
-        if (!account) {
-            throw new Error(`Account ${address} not found`)
-        }
-
-        // INFO: Store the current sequence
-        let current_sequence = account.sequence
-
-        const signed_txs = transactions.map(async (tx) => {
-            const signerInfo = {
-                sequence: current_sequence,
-                accountNumber: account.accountNumber,
-                chainId: this.chainID,
-            }
-
-            if (tx.fee === null) {
-                // INFO: Throw an error if fee is not set
-                console.error('Fee not set for tx: ', tx)
-                throw new Error('Fee not set for tx')
-            }
-
-            // INFO: Increment the sequence for next round
-            current_sequence++
-
-            // INFO: Sign the tx
-            const signed_tx = await this.wallet.sign(
-                tx.signerAddress,
-                tx.messages,
-                tx.fee,
-                tx.memo,
-                signerInfo
-            )
-
-            // INFO: Convert raw tx to bytes array (Ready for broadcast)
-            const tx_bytes = TxRaw.encode(signed_tx).finish()
-            return tx_bytes
-        })
-
-        // INFO: Return the signed transactions
-        return await Promise.all(signed_txs)
-    }
-
-    async disconnect() {
-        this.resetInstance()
-        this.address = ''
-        this.gasPrice = ''
-        return !this.connected
-    }
-
-    // SECTION: Unimplemented methods
-    async ibcSend() {
-        // TODO: Implement IBC send
-        // REFERENCE: https://github.com/cosmos/cosmjs/blob/33271bc51c/packages/stargate/src/signingstargateclient.ts#L246
-        throw new Error('Method not implemented')
-    }
-}

package/src/multichain/core/index.ts

@@ -1,29 +0,0 @@
-export {
-    DefaultChain,
-    IBCDefaultChain,
-    IDefaultChainLocal,
-    IDefaultChainWeb,
-    IEVMDefaultChain,
-} from './types/defaultChain'
-
-export {
-    EGLDSignTxOptions,
-    IBCConnectWalletOptions,
-    IBCGetBalanceOptions,
-    IBCPreparePayOptions,
-    IBCSignTxOptions,
-    IBCTransaction,
-    IPayOptions,
-    XmTransactionResponse as TransactionResponse,
-} from './types/interfaces'
-
-export { required } from './utils'
-
-// SECTION: Chain SDKs
-export { EVM } from './evm'
-export { IBC } from './ibc'
-export { SOLANA } from './solana'
-export { MULTIVERSX } from './multiversx'
-
-// The official XRPL Library is called "xrpl" which conflicts with the name of our XRPL SDK
-export { XRPL, xrplGetLastSequence } from './xrp'