@kynesyslabs/demosdk 1.0.21 → 1.0.23

package/src/multichain/core/multiversx.ts

@@ -1,310 +0,0 @@
-import {
-    Account,
-    Address,
-    GasEstimator,
-    IPlainTransactionObject,
-    TokenTransfer,
-    Transaction,
-    TransferTransactionsFactory,
-} from '@multiversx/sdk-core'
-import { ExtensionProvider } from '@multiversx/sdk-extension-provider'
-import { ApiNetworkProvider } from '@multiversx/sdk-network-providers'
-import { INetworkProvider } from '@multiversx/sdk-network-providers/out/interface'
-import { UserSigner } from '@multiversx/sdk-wallet'
-
-import {
-    DefaultChain,
-    EGLDSignTxOptions,
-    IPayOptions,
-    required,
-} from '@/multichain/core'
-
-export class MULTIVERSX extends DefaultChain {
-    declare provider: INetworkProvider
-    declare wallet: UserSigner | ExtensionProvider
-    chainId: string = ''
-
-    constructor(rpc_url: string) {
-        super(rpc_url)
-        this.name = 'egld'
-
-        if (rpc_url) {
-            this.setRPC(rpc_url)
-        }
-    }
-
-    setRPC(rpc_url: string) {
-        this.rpc_url = rpc_url
-        this.provider = new ApiNetworkProvider(this.rpc_url)
-    }
-
-    async connect() {
-        required(this.provider, 'Provider not connected')
-        try {
-            const networkConfig = await this.provider.getNetworkConfig()
-            this.chainId = networkConfig.ChainID
-
-            this.connected = Boolean(this.chainId)
-            return this.connected
-        } catch (error) {
-            this.connected = false
-        }
-
-        return false
-    }
-
-    // REVIEW: Where is this needed?
-    // Answer to that: src/routes/crosschain/xM_WalletConnectionCard.svelte
-    // static async create(rpc_url: any) {
-    //     const instance = new MULTIVERSX(rpc_url)
-
-    //     if (rpc_url) {
-    //         await instance.connect()
-    //     }
-
-    //     return instance
-    // }
-
-    async connectKeyFileWallet(keyFile: string, password: string) {
-        try {
-            // INFO: Parse the keyFile JSON string
-            keyFile = JSON.parse(keyFile)
-        } catch (error) {
-            throw new Error('Failed to load the wallet. Invalid KeyFile!')
-        }
-
-        return UserSigner.fromWallet(keyFile, password)
-    }
-
-    async connectWallet(privateKey: string, options: { password: string }) {
-        // INFO: This method is overriden in the web sdk
-        // to connect with the extension wallet
-        this.wallet = await this.connectKeyFileWallet(
-            privateKey,
-            options?.password as string
-        )
-        return this.wallet
-    }
-
-    getAddress() {
-        // INFO: method is overriden in the web sdk
-        required(this.wallet, 'Wallet not connected')
-
-        if (this.wallet instanceof ExtensionProvider) {
-            return this.wallet.account.address
-        } else if (this.wallet instanceof UserSigner) {
-            return this.wallet.getAddress().bech32()
-        }
-
-        throw new Error("Unknown wallet type. Can't get address.")
-    }
-
-    // SECTION: Reads
-
-    async getBalance(address: string): Promise<string> {
-        required(address, 'address is required to get the balance')
-
-        const Iaddress = new Address(address)
-        const account = await this.provider.getAccount(Iaddress)
-
-        return account.balance.toString()
-    }
-
-    async getTokenBalance(token_id: string) {
-        required(this.provider)
-        required(this.wallet)
-
-        const walletAddress = this.getAddress()
-        const address = new Address(walletAddress)
-        const token = await this.provider.getFungibleTokenOfAccount(
-            address,
-            token_id
-        )
-
-        return token.balance.toNumber()
-    }
-
-    async getNFTs() {
-        required(this.provider)
-        required(this.wallet)
-
-        const address = this.getAddress()
-        const account = new Address(address)
-        return this.provider.getNonFungibleTokensOfAccount(account)
-    }
-
-    // /**
-    //  * Connect a Multiversx wallet. Pass the `keyFile` JSON string as the `privateKey` and its `password` to override the De-Fi wallet prompt.
-    //  */
-    // async connectWallet(
-    // 	privateKey?: string,
-    // 	options?: {
-    // 		password: string;
-    // 	}
-    // ) {
-    // 	if (privateKey && options?.password) {
-    // 		return this.connectKeyFileWallet(privateKey, options.password);
-    // 	}
-
-    // 	this.wallet = ExtensionProvider.getInstance();
-
-    // 	await this.wallet.init();
-
-    // 	// INFO: wallet.isInitialized() checks if the wallet is installed.
-    // 	// It's equivalent to checking for `window.elrondWallet` object which is injected by the extension
-    // 	// LINK to src: https://github.com/multiversx/mx-sdk-js-extension-provider/blob/36518d0fe0b295de8d2b977727f0c30cdc014c78/src/extensionProvider.ts#L45
-
-    // 	if (!this.wallet.isInitialized()) {
-    // 		throw new Error('Wallet not detected. Is the MultiversX DeFi Wallet extension installed?');
-    // 	}
-
-    // 	await this.wallet.login();
-    // 	return this.wallet.isConnected();
-    // }
-
-    // SECTION: Writes
-    /**
-     * Signs a single transaction. Calls `signTransactions` with a single transaction and returns the first element of the result.
-     * @returns The signed transaction as a plain object
-     */
-    async signTransaction(
-        transaction: Transaction,
-        options: EGLDSignTxOptions
-    ) {
-        const txs = await this.signTransactions([transaction], options)
-        return txs[0]
-    }
-
-    protected async addTxNonces(transactions: Transaction[]) {
-        required(this.provider, 'Provider not connected')
-
-        // INFO: Override wallet connection
-        // if (options?.privateKey) {
-        //     await this.connectWallet(options.privateKey, {
-        //         password: options.password,
-        //     })
-        // }
-
-        // INFO: Retrieve account on network to get nonce
-        const senderBech32 = this.getAddress()
-        const senderAddress = new Address(senderBech32)
-
-        const account = new Account(senderAddress)
-        const senderOnNetwork = await this.provider.getAccount(senderAddress)
-        account.update(senderOnNetwork)
-
-        // INFO: Local nonce management
-        // LINK: https://docs.multiversx.com/integrators/creating-transactions/#nonce-management
-        let currentNonce = account.nonce.valueOf()
-
-        transactions.forEach((tx) => {
-            tx.setNonce(currentNonce)
-            // INFO: Increment the nonce for the next tx
-            currentNonce++
-        })
-
-        return transactions
-    }
-
-    /**
-     * Signs multiple transactions
-     * @returns The signed transactions as an array of plain objects
-     */
-    async signTransactions(
-        transactions: Transaction[],
-        options?: EGLDSignTxOptions
-    ): Promise<IPlainTransactionObject[]> {
-        required(this.wallet || options?.privateKey, 'Wallet not connected')
-
-        // INFO: Override wallet connection
-        if (options?.privateKey) {
-            await this.connectWallet(options.privateKey, {
-                password: options.password,
-            })
-        }
-
-        // INFO: Retrieve account on network to get nonce
-        // const senderBech32 = this.getAddress()
-        // const senderAddress = new Address(senderBech32)
-
-        // const account = new Account(senderAddress)
-        // const senderOnNetwork = await this.provider.getAccount(senderAddress)
-        // account.update(senderOnNetwork)
-
-        // // INFO: Local nonce management
-        // // LINK: https://docs.multiversx.com/integrators/creating-transactions/#nonce-management
-        // let currentNonce = account.nonce.valueOf()
-
-        // transactions.forEach((tx) => {
-        //     tx.setNonce(currentNonce)
-        //     // INFO: Increment the nonce for the next tx
-        //     currentNonce++
-        // })
-
-        transactions = await this.addTxNonces(transactions)
-
-        // try {
-        //     // INFO: When wallet is loaded from Extension
-        //     transactions = await (
-        //         this.wallet as ExtensionProvider
-        //     ).signTransactions(transactions)
-        // } catch (error) {
-        for (const tx of transactions) {
-            const serializedTx = tx.serializeForSigning()
-            const txSign = await (this.wallet as UserSigner).sign(serializedTx)
-
-            tx.applySignature(txSign)
-        }
-        // }
-
-        return transactions.map((tx) => {
-            // INFO: Return plain objects
-            return tx.toSendable()
-        })
-    }
-
-    async preparePay(address: string, amount: string) {
-        const txs = await this.preparePays([{ address, amount }])
-        return txs[0]
-    }
-
-    async preparePays(payments: IPayOptions[]) {
-        required(this.wallet)
-
-        const sender = this.getAddress()
-        const senderAddress = new Address(sender)
-
-        const transactions = payments.map((payment) => {
-            const transfer = TokenTransfer.egldFromAmount(payment.amount)
-            const receiverAddress = new Address(payment.address)
-            const factory = new TransferTransactionsFactory(new GasEstimator())
-
-            return factory.createEGLDTransfer({
-                value: transfer,
-                sender: senderAddress,
-                receiver: receiverAddress,
-                chainID: this.chainId,
-            })
-        })
-
-        return this.signTransactions(transactions)
-    }
-
-    prepareTransfer(receiver: string, amount: string) {
-        return this.preparePay(receiver, amount)
-    }
-
-    prepareTransfers(tranfers: IPayOptions[]) {
-        return this.preparePays(tranfers)
-    }
-
-    async disconnect() {
-        this.resetInstance()
-        return !this.connected
-    }
-
-    // SECTION Unimplemented methods
-    getEmptyTransaction() {
-        throw new Error('Method not implemented.')
-    }
-}

package/src/multichain/core/solana.ts

@@ -1,336 +0,0 @@
-import bs58 from "bs58"
-import {
-    Keypair,
-    PublicKey,
-    Connection,
-    Transaction,
-    NonceAccount,
-    SystemProgram,
-    LAMPORTS_PER_SOL,
-    TransactionNonceCtor,
-    NONCE_ACCOUNT_LENGTH,
-    TransactionInstruction,
-} from "@solana/web3.js"
-
-import { required } from "./utils"
-import { IPayOptions } from "./types/interfaces"
-import { DefaultChain, SolanaDefaultChain } from "./types/defaultChain"
-
-/* LICENSE
-
-© 2023 by KyneSys Labs, licensed under CC BY-NC-ND 4.0
-
-Full license text: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode
-Human readable license: https://creativecommons.org/licenses/by-nc-nd/4.0/
-
-KyneSys Labs: https://www.kynesys.xyz/
-
-*/
-
-// LINK https://docs.solana.com/developing/clients/javascript-api
-
-// INTERFACES (TO BE MOVED)
-interface SignTxOptions {
-    /**
-     * The private key to sign the transaction with, instead of the connected wallet.
-     */
-    privateKey?: string
-    /**
-     * The address of your nonce account for signing with durable nonces.
-     */
-    nonceAccountAddress?: string
-
-    /**
-     * The secret key of the nonce account authority, for signing the tx.
-     *
-     * Defaults to the connected wallet's secret key.
-     */
-    nonceAccountAuthority?: string
-}
-
-export class SOLANA extends DefaultChain implements SolanaDefaultChain {
-    private static instance: SOLANA
-
-    declare wallet: Keypair
-    declare provider: Connection
-
-    constructor(rpc_url: string) {
-        super(rpc_url)
-        this.name = "solana"
-    }
-
-    async connect() {
-        this.provider = new Connection(this.rpc_url)
-
-        const version = await this.provider.getVersion()
-        this.connected = Number.isInteger(version["feature-set"])
-
-        return this.connected
-    }
-
-    async disconnect() {
-        this.resetInstance()
-        return true
-    }
-
-    // async createWallet() {}
-
-    // ANCHOR Public methods
-    async connectWallet(
-        privateKey: string,
-        options?: {
-            /**
-             * If the private key is in base58 format
-             */
-            base58: boolean
-        },
-    ) {
-        let privateKeyBuffer: Uint8Array
-
-        if (options && options.base58) {
-            privateKeyBuffer = bs58.decode(privateKey)
-        } else {
-            const pk = privateKey.split(",").map(x => parseInt(x))
-            privateKeyBuffer = Buffer.from(pk)
-        }
-
-        this.wallet = Keypair.fromSecretKey(privateKeyBuffer)
-        return this.wallet
-    }
-
-    async getBalance(address: string) {
-        const publicKey = new PublicKey(address)
-        const balance = await this.provider.getBalance(publicKey)
-        return balance.toString()
-    }
-
-    // async pay(to: string, amount: string): Promise<any> {
-    //     required(this.wallet, 'Wallet not connected')
-    //     // TODO
-    //     return null
-    // }
-
-    async info(): Promise<string> {
-        let info = ""
-        // TODO
-        return info
-    }
-
-    // INFO Returning an empty raw transaction skeleton
-    // async createRawTransaction(): Promise<Transaction> {
-
-    // }
-
-    // INFO Placeholder compatibility function that is here only for the interface
-    override async signTransaction(tx: Transaction, options?: SignTxOptions) {
-        required(this.wallet, "Wallet not connected")
-        // LINK https://docs.shyft.to/tutorials/how-to-sign-transactions-on-solana
-        // NOTE Due to the above, the transaction is signed and sent at the same time.
-        // tx.addSignature()
-        const txs = await this.signTransactions([tx], options)
-        return txs[0]
-    }
-
-    async readNonce(address: string) {
-        console.log("reading nonce account: ", address)
-        const pubkey = new PublicKey(address)
-        const accountInfo = await this.provider.getAccountInfo(pubkey)
-        console.log("accountInfo: ", accountInfo)
-
-        if (accountInfo) {
-            return NonceAccount.fromAccountData(accountInfo?.data)
-        }
-
-        return null
-    }
-
-    async createNonceAccount() {
-        required(this.wallet, "Wallet not connected")
-
-        let tx = new Transaction()
-        const nonceAccount = Keypair.generate()
-
-        const create_acc_ix = SystemProgram.createAccount({
-            fromPubkey: this.wallet.publicKey,
-            newAccountPubkey: nonceAccount.publicKey,
-            lamports: await this.provider.getMinimumBalanceForRentExemption(
-                NONCE_ACCOUNT_LENGTH,
-            ),
-            space: NONCE_ACCOUNT_LENGTH,
-            programId: SystemProgram.programId,
-        })
-
-        const init_nonce_ix = SystemProgram.nonceInitialize({
-            noncePubkey: nonceAccount.publicKey,
-            authorizedPubkey: this.wallet.publicKey,
-        })
-
-        tx.add(create_acc_ix, init_nonce_ix)
-
-        const txhash = this.provider.sendTransaction(tx, [
-            this.wallet,
-            nonceAccount,
-        ])
-        console.log("txhash: ", txhash)
-
-        return nonceAccount.publicKey.toBase58()
-    }
-
-    async signTransactions(
-        transactions: Transaction[],
-        options?: SignTxOptions,
-    ) {
-        required(this.wallet, "Wallet not connected")
-
-        let nonceAccount: NonceAccount | null = null
-        let advanceNonceIx: TransactionInstruction | null = null
-        let nonceAuthority: Keypair = this.wallet
-
-        const nonceAccAvailable =
-            options && options.nonceAccountAddress ? true : false
-
-        // if we have the nonce authority, overwrite.
-        if (nonceAccAvailable && options!.nonceAccountAuthority) {
-            nonceAuthority = Keypair.fromSecretKey(
-                bs58.decode(options!.nonceAccountAuthority),
-            )
-        }
-
-        // if we have the nonce address, create a nonce advance instruction
-        if (nonceAccAvailable) {
-            advanceNonceIx = SystemProgram.nonceAdvance({
-                authorizedPubkey: nonceAuthority.publicKey,
-                noncePubkey: new PublicKey(options!.nonceAccountAddress!),
-            })
-
-            nonceAccount = await this.readNonce(options!.nonceAccountAddress!)
-        }
-
-        // if advance instruction is not null
-        // ie. we have the nonce address,
-        // insert the advance nonce ix at instructions index 0
-        // on each transaction
-        if (advanceNonceIx && nonceAccount) {
-            transactions.forEach(tx => {
-                tx.instructions.splice(0, 0, advanceNonceIx!)
-
-                // update recent block hash to use the current nonce
-                tx.recentBlockhash = nonceAccount!.nonce
-                nonceAccount?.nonce
-                // TODO: FIND OUT WHAT HAPPENS WHEN MULTIPLE TX HAVE THE SAME DURABLE NONCE
-            })
-        }
-
-        const signers = new Set([this.wallet, nonceAuthority])
-        console.log("signers length: ", signers.size)
-        console.log("signers: ", signers)
-
-        transactions.forEach(async tx => {
-            tx.sign(...signers)
-        })
-
-        return transactions
-    }
-
-    override getAddress() {
-        required(this.wallet, "Wallet not connected")
-
-        return this.wallet.publicKey.toBase58()
-    }
-
-    getEmptyTransaction() {
-        // const recentBlockhash = await this.provider.getLatestBlockhash()
-        const options = <TransactionNonceCtor>{
-            feePayer: this.wallet.publicKey,
-        }
-
-        let empty_tx = new Transaction(options)
-        // empty_tx.recentBlockhash = recentBlockhash.blockhash
-        // empty_tx.lastValidBlockHeight = recentBlockhash.lastValidBlockHeight
-
-        return empty_tx
-    }
-
-    override async preparePay(
-        receiver: string,
-        amount: string,
-        options?: SignTxOptions,
-    ) {
-        const tx = await this.preparePays(
-            [{ address: receiver, amount }],
-            options,
-        )
-        return tx[0]
-    }
-
-    override async preparePays(
-        payments: IPayOptions[],
-        options?: SignTxOptions,
-    ) {
-        const recentBlockhash = await this.provider.getLatestBlockhash()
-
-        const transactions = payments.map(payment => {
-            const tx = this.getEmptyTransaction()
-            tx.recentBlockhash = recentBlockhash.blockhash
-            tx.lastValidBlockHeight = recentBlockhash.lastValidBlockHeight
-
-            const transferIx = SystemProgram.transfer({
-                fromPubkey: this.wallet.publicKey,
-                toPubkey: new PublicKey(payment.address),
-                lamports:
-                    parseFloat(payment.amount as string) * LAMPORTS_PER_SOL,
-            })
-
-            tx.add(transferIx)
-            return tx
-        })
-
-        return this.signTransactions(transactions, options)
-    }
-
-    override async prepareTransfer(
-        receiver: string,
-        amount: string,
-        options: {},
-    ) {
-        return await this.preparePay(receiver, amount, options)
-    }
-
-    override async prepareTransfers(transfers: IPayOptions[], options: {}) {
-        return await this.preparePays(transfers, options)
-    }
-
-    // TODO: move sendTransaction to localsdk
-    // INFO Sending a transfer transaction on Solana network
-    // sendTransaction({ to, amount }) {
-    //     required(this.wallet, 'Wallet not connected')
-    //     let tx = new Transaction()
-    //     tx.add(
-    //         SystemProgram.transfer({
-    //             fromPubkey: this.wallet.publicKey,
-    //             toPubkey: to,
-    //             lamports: amount * LAMPORTS_PER_SOL,
-    //         })
-    //     )
-    //     let result = sendAndConfirmTransaction(this.provider, tx, [
-    //         this.wallet,
-    //     ])
-    //     return result
-    // }
-
-    // ANCHOR Static singleton methods
-
-    static getInstance(): SOLANA | boolean {
-        if (!SOLANA.instance) {
-            return false
-        }
-        return SOLANA.instance
-    }
-
-    static createInstance(rpc_url: string): SOLANA {
-        if (!SOLANA.instance) {
-            SOLANA.instance = new SOLANA(rpc_url)
-        }
-        return SOLANA.instance
-    }
-}