@kynesyslabs/demosdk 1.0.21 → 1.0.22

package/src/multichain/localsdk/ibc.ts

@@ -1,25 +0,0 @@
-import { IBC as IBCCore, IDefaultChainLocal, TransactionResponse, required } from '@/multichain/core'
-
-export class IBC extends IBCCore implements IDefaultChainLocal {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    async sendTransaction(signed_tx: Uint8Array): Promise<TransactionResponse> {
-        required(this.wallet, 'Wallet not connected')
-
-        const hash = await this.wallet.broadcastTxSync(signed_tx)
-        return {
-            hash,
-            result: 'success',
-        }
-    }
-
-    async getInfo(): Promise<string> {
-        throw new Error('Method not implemented.')
-    }
-
-    async createWallet(password?: string) {
-        throw new Error('Method not implemented.')
-    }
-}

package/src/multichain/localsdk/index.ts

@@ -1,4 +0,0 @@
-export { XRPL } from './xrp'
-export { EVM } from './evm'
-export { IBC } from './ibc'
-export { MULTIVERSX } from './multiversx'

package/src/multichain/localsdk/multiversx.ts

@@ -1,66 +0,0 @@
-import {
-    MULTIVERSX as EGLDCore,
-    IDefaultChainLocal,
-    TransactionResponse,
-    required,
-} from '@/multichain/core'
-
-import { IPlainTransactionObject, Transaction } from '@multiversx/sdk-core'
-import { Mnemonic, UserWallet } from '@multiversx/sdk-wallet'
-
-export class MULTIVERSX extends EGLDCore implements IDefaultChainLocal {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    async getInfo() {
-        throw new Error('Method not implemented.')
-    }
-
-    async createWallet(password: string, addressIndex?: number) {
-        required(password, 'Password is required to encrypt the key file')
-
-        const mnemonics = Mnemonic.generate()
-
-        const words = mnemonics.getWords()
-        const words_with_index = words.map((word, index) => index + '. ' + word)
-
-        const secretKey = mnemonics.deriveKey(addressIndex, password)
-        const wallet = UserWallet.fromSecretKey({ secretKey, password })
-
-        const jsonWallet = wallet.toJSON()
-
-        // NOTE: .bech32 is the address property
-        const walletAddress: string = jsonWallet.bech32
-
-        // TODO Return downloadable mnemonics & json files
-        return {
-            mnemonics: words,
-            address: walletAddress,
-            mnemonics_txt: words_with_index.join(''),
-            wallet_keyfile: JSON.stringify(jsonWallet, null, 2),
-        }
-    }
-
-    async sendTransaction(raw_tx: Transaction | IPlainTransactionObject) :Promise<TransactionResponse> {
-        required(this.provider, 'Provider not connected')
-        let signed_tx: Transaction
-
-        // INFO: raw_tx is a plain object when it comes from the frontend
-        if (!(raw_tx instanceof Transaction)) {
-            signed_tx = Transaction.fromPlainObject(raw_tx)
-        } else {
-            signed_tx = raw_tx
-        }
-
-        // INFO: The provider can also send a list of transactions
-        const tx_hash = await this.provider.sendTransaction(
-            signed_tx as Transaction
-        )
-
-        return {
-            result: 'success',
-            hash: tx_hash,
-        }
-    }
-}

package/src/multichain/localsdk/solana.ts

@@ -1,37 +0,0 @@
-import { Keypair, Transaction } from "@solana/web3.js"
-import { IDefaultChainLocal, SOLANA as SolanaCore, TransactionResponse } from "../core"
-
-export class SOLANA extends SolanaCore implements IDefaultChainLocal {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    async sendTransaction(
-        signed_tx: Transaction,
-    ): Promise<TransactionResponse> {
-        const tx = signed_tx.serialize()
-
-        try {
-            const txhash = await this.provider.sendRawTransaction(tx)
-            return {
-                result: "success",
-                hash: txhash,
-            }
-        } catch (error) {
-            return {
-                result: "error",
-                error: error,
-            }
-        }
-    }
-
-    async getInfo(){
-        throw new Error("Method not implemented.")
-    }
-
-    async createWallet(){
-        const keypair = Keypair.generate()
-        // REVIEW: Should 
-        throw new Error("Method not implemented.")
-    }
-}

package/src/multichain/localsdk/xrp.ts

@@ -1,56 +0,0 @@
-import { IDefaultChainLocal, TransactionResponse, XRPL as XRPLSdkCore } from '@/multichain/core'
-import * as xrpl from 'xrpl'
-
-export class XRPL extends XRPLSdkCore implements IDefaultChainLocal {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    // INFO Creates a new wallet
-    async createWallet(password: string) {
-        // TODO: Review this implementation
-        this.wallet = xrpl.Wallet.generate()
-    }
-
-    async getInfo() {
-        throw new Error('Method not implemented.')
-    }
-
-    // INFO Generic account info
-    async accountInfo(address: string): Promise<xrpl.AccountInfoResponse> {
-        return await this.provider.request({
-            command: 'account_info',
-            account: address,
-            ledger_index: 'validated',
-        })
-    }
-
-    // INFO Generic sign, send and await (if not specified) a tx
-    async sendTransaction(signed: any, wait: boolean = false) :Promise<TransactionResponse> {
-        // Sending the tx
-        console.log('[xrpl] sendtransaction')
-
-        if (wait) {
-            const res = await this.provider.submitAndWait(signed.tx_blob)
-
-            // NOTE: The return type here might need to change
-            return {
-                result: 'success',
-                hash: res.result.hash,
-            }
-        } else {
-            const res = await this.provider.submit(signed.tx_blob)
-
-            return {
-                result: res.result.accepted ? 'success' : 'error',
-                hash: res.result.tx_json.hash,
-                extra: {
-                    accepted: res.result.accepted,
-                    result: res.result.engine_result,
-                    result_code: res.result.engine_result_code,
-                    result_message: res.result.engine_result_message,
-                },
-            }
-        }
-    }
-}

package/src/multichain/websdk/README.md

@@ -1 +0,0 @@
-# Multichain Web SDK

package/src/multichain/websdk/evm.ts

@@ -1,9 +0,0 @@
-import { EVM as EVMCoreSDK, IDefaultChainWeb } from '@/multichain/core'
-
-export class EVM extends EVMCoreSDK implements IDefaultChainWeb {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    // INFO: Add custom methods here
-}

package/src/multichain/websdk/ibc.ts

@@ -1,10 +0,0 @@
-import { IBC as IBCCoreSDK, IDefaultChainWeb } from '@/multichain/core'
-
-// INFO: Websdk is the same as the core sdk
-export class IBC extends IBCCoreSDK implements IDefaultChainWeb {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    // INFO: Add custom methods here
-}

package/src/multichain/websdk/index.ts

@@ -1,4 +0,0 @@
-export { XRPL } from './xrp'
-export { EVM } from './evm'
-export { IBC } from './ibc'
-export { MULTIVERSX } from './multiversx'

package/src/multichain/websdk/multiversx.ts

@@ -1,84 +0,0 @@
-import {
-    MULTIVERSX as EGLDCore,
-    EGLDSignTxOptions,
-    IDefaultChainWeb,
-    required,
-} from '@/multichain/core'
-import { IPlainTransactionObject, Transaction } from '@multiversx/sdk-core'
-import { ExtensionProvider } from '@multiversx/sdk-extension-provider'
-import { UserSigner } from '@multiversx/sdk-wallet'
-
-export class MULTIVERSX extends EGLDCore implements IDefaultChainWeb {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    /**
-     * Connect a Multiversx wallet. Pass the `keyFile` JSON string as the `privateKey` and its `password` to override the De-Fi wallet prompt.
-     */
-    // @ts-expect-error // INFO: Return type error
-    override async connectWallet(
-        privateKey?: string,
-        options?: {
-            password: string
-        }
-    ) {
-        if (privateKey && options?.password) {
-            await this.connectKeyFileWallet(privateKey, options.password)
-            return this.wallet as UserSigner
-        }
-
-        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
-    }
-
-    override 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,
-            })
-        }
-
-        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()
-        })
-    }
-}

package/src/multichain/websdk/xrp.ts

@@ -1,9 +0,0 @@
-import { IDefaultChainWeb, XRPL as XRPLCoreSDK } from '@/multichain/core'
-
-export class XRPL extends XRPLCoreSDK implements IDefaultChainWeb {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-    }
-
-    // INFO: Add custom methods here
-}

package/src/tests/multichain/chainProviders.ts

@@ -1,32 +0,0 @@
-import { clusterApiUrl } from "@solana/web3.js"
-
-export default {
-    eth: {
-        mainnet: "https://rpc.ankr.com/eth",
-        sepolia: "https://rpc.ankr.com/eth_sepolia",
-        goerli: "https://ethereum-goerli.publicnode.com",
-    },
-    xrpl: {
-        mainnet: "wss://s1.ripple.com:51234/",
-        testnet: "wss://s.altnet.rippletest.net:51233/",
-    },
-    egld: {
-        mainnet: "https://api.multiversx.com",
-        testnet: "https://testnet-api.multiversx.com",
-    },
-    filecoin: {
-        mainnet: "https://rpc.ankr.com/filecoin",
-        calibration: "https://rpc.ankr.com/filecoin_testnet",
-        testnet: "https://rpc.ankr.com/filecoin_testnet",
-    },
-    ibc: {
-        mainnet: "",
-        // Stargaze 👇
-        testnet: "https://rpc.elgafar-1.stargaze-apis.com",
-    },
-    solana: {
-        mainnet: clusterApiUrl("mainnet-beta"),
-        // using devnet as testnet faucet is broken 👇
-        devnet: clusterApiUrl("devnet"),
-    },
-}

package/src/tests/multichain/evm.test.ts

@@ -1,64 +0,0 @@
-import { Transaction } from 'ethers'
-
-import { EVM } from '@/multichain/core'
-import { getSampleTranfers, verifyNumberOrder } from '../utils'
-import { wallets } from '../utils/wallets'
-import chainProviders from './chainProviders'
-
-describe('EVM CHAIN TESTS', () => {
-    const instance = new EVM(chainProviders.eth.sepolia)
-
-    beforeAll(async () => {
-        const connected = await instance.connect()
-        await instance.connectWallet(wallets.evm.wallet)
-
-        expect(connected).toBe(true)
-    })
-
-    test('preparePay returns a signed transaction', async () => {
-        const address = instance.getAddress()
-        const signed_tx = await instance.preparePay(address, '1')
-
-        // INFO: Reconstruct the transaction from the signed transaction
-        const tx = Transaction.from(signed_tx)
-
-        // INFO: the r parameter is 32 bytes long
-        // INFO: We assert with 66 because it's a hex string
-        // (2 characters per byte + 2 for the 0x prefix)
-        expect(tx.signature?.r.length).toEqual(66)
-    })
-
-    test('A tx is signed with the ledger nonce', async () => {
-        const address = instance.getAddress()
-        const ledgerNonce = await instance.provider.getTransactionCount(address)
-
-        const signed_tx = await instance.preparePay(address, '1')
-
-        // INFO: Reconstruct the transaction from the signed payload
-        const tx = Transaction.from(signed_tx)
-
-        expect(tx.nonce).toEqual(ledgerNonce)
-    })
-
-    test('Transactions are signed with increasing nonces', async () => {
-        const address = instance.getAddress()
-        const transfers = getSampleTranfers(address)
-        const signed_txs = await instance.preparePays(transfers)
-
-        const txs = signed_txs.map((tx) => Transaction.from(tx))
-        const nonces_sorted = verifyNumberOrder(txs, 'nonce')
-
-        expect(nonces_sorted).toBe(true)
-    })
-
-    test('Transactions are signed in order of appearance', async () => {
-        const address = instance.getAddress()
-        const transfers = getSampleTranfers(address)
-        const signed_txs = await instance.preparePays(transfers)
-
-        const txs = signed_txs.map((tx) => Transaction.from(tx))
-        const values_sorted = verifyNumberOrder(txs, 'value')
-
-        expect(values_sorted).toBe(true)
-    })
-})

package/src/tests/multichain/ibc.test.ts

@@ -1,93 +0,0 @@
-import { decodeTxRaw, Registry } from '@cosmjs/proto-signing'
-import { defaultRegistryTypes } from '@cosmjs/stargate'
-
-import { IBC } from '@/multichain/core'
-import { getSampleTranfers, verifyNumberOrder } from '../utils'
-import { wallets } from '../utils/wallets'
-import chainProviders from './chainProviders'
-
-describe('IBC CHAIN TESTS', () => {
-    let instance: IBC
-    const chain_prefix = 'stars'
-    const token_denom = 'ustars'
-    const payment_options = { denom: token_denom }
-
-    beforeAll(async () => {
-        instance = await IBC.create(chainProviders.ibc.testnet)
-        await instance.connectWallet(wallets.ibc.wallet, {
-            prefix: chain_prefix,
-            gasPrice: '0.012ustars',
-        })
-
-        expect(instance.connected).toBe(true)
-    })
-
-    test('preparePay returns a signed tx', async () => {
-        const address = instance.getAddress()
-        const tx_bytes = await instance.preparePay(
-            address,
-            '1',
-            payment_options
-        )
-
-        // INFO: Decode the bytes to get the raw tx
-        // LINK: https://cosmos.github.io/cosmjs/latest/proto-signing/modules.html#decodeTxRaw
-        // Ctrl + click decodeTxRaw to see the decoded raw Tx interface
-        const raw_tx = decodeTxRaw(tx_bytes)
-        expect(raw_tx.signatures.length == 1).toBe(true)
-    })
-
-    test('A tx is signed with the ledger nonce', async () => {
-        const address = instance.getAddress()
-
-        // INFO: Get the current ledger sequence
-        const ledger_sequence = (await instance.provider.getAccount(address))
-            ?.sequence
-
-        // INFO: Sign and decode the tx
-        const tx_bytes = await instance.preparePay(
-            address,
-            '1',
-            payment_options
-        )
-        const raw_tx = decodeTxRaw(tx_bytes)
-
-        // INFO: Compare the sequences
-        const tx_sequence = Number(raw_tx.authInfo.signerInfos[0].sequence)
-        expect(tx_sequence).toEqual(ledger_sequence)
-    })
-
-    test('Transactions are signed with increasing nonces', async () => {
-        const address = instance.getAddress()
-        const payments = getSampleTranfers(address)
-        const signed_txs = await instance.preparePays(payments, payment_options)
-
-        // INFO: Get a list of objects containing the sequences
-        const signer_infos = signed_txs.map((tx_bytes) => {
-            const tx = decodeTxRaw(tx_bytes)
-            return tx.authInfo.signerInfos[0]
-        })
-
-        const is_sorted = verifyNumberOrder(signer_infos, 'sequence')
-        expect(is_sorted).toBe(true)
-    })
-
-    test('Transactions are signed in order of appearance', async () => {
-        const address = instance.getAddress()
-        const payments = getSampleTranfers(address)
-        const signed_txs = await instance.preparePays(payments, payment_options)
-
-        const amounts = signed_txs.map((tx_bytes) => {
-            const tx = decodeTxRaw(tx_bytes)
-
-            // INFO: Decode the message to get the amount
-            // LINK: https://cosmos.github.io/cosmjs/latest/proto-signing/classes/Registry.html
-            const registry = new Registry(defaultRegistryTypes)
-            const message = registry.decode(tx.body.messages[0])
-            return message['amount'][0]
-        })
-
-        const is_sorted = verifyNumberOrder(amounts, 'amount')
-        expect(is_sorted).toBe(true)
-    })
-})

package/src/tests/multichain/index.ts

@@ -1,105 +0,0 @@
-/* 
-  These are generic tests for each chain.
-  They make sure all the sdks behave the same way.
-*/
-
-import { JsonRpcProvider } from 'ethers'
-import { Client } from 'xrpl'
-
-import { StargateClient } from '@cosmjs/stargate'
-import { INetworkProvider } from '@multiversx/sdk-network-providers/out/interface'
-
-import { EVM, IBC, MULTIVERSX, XRPL } from '@/multichain/core'
-import chainProviders from './chainProviders'
-
-// INFO: Chains and their RPCs
-const chains = [
-    {
-        name: 'EGLD',
-        sdk: MULTIVERSX,
-        rpc: chainProviders.egld.testnet,
-    },
-    {
-        name: 'XRPL',
-        sdk: XRPL,
-        rpc: chainProviders.xrpl.testnet,
-    },
-    {
-        name: 'EVM',
-        sdk: EVM,
-        rpc: chainProviders.eth.sepolia,
-    },
-    {
-        name: 'IBC',
-        sdk: IBC,
-        rpc: chainProviders.ibc.testnet,
-    },
-]
-
-// INFO: For loop to test each chain sdk
-describe.each(chains)('GENERIC CHAIN TESTS › $name', ({ name, rpc, sdk }) => {
-    let instance: IBC | EVM | MULTIVERSX | XRPL
-
-    beforeAll(async () => {
-        // @ts-expect-error
-        // Caused by the use of generics to determine the output of sdk.create
-        instance = await sdk.create(rpc)
-    })
-
-    test('Chain has a valid name', () => {
-        expect(instance.name).toBeTruthy()
-    })
-
-    test('Testnet RPC is up', async () => {
-        const connected = await instance.connect()
-
-        expect(instance.connected).toBe(true)
-        expect(connected).toBe(true)
-
-        // INFO: Max timeout for this test
-    })
-
-    test('On connect failure, .connected is false', async () => {
-        const mock = jest.fn().mockRejectedValue(new Error('mock error'))
-
-        // INFO: Mock the provider method that connects to the RPC to throw an error
-        switch (name) {
-            case 'EVM':
-                ;(instance.provider as JsonRpcProvider).getNetwork = mock
-                break
-            case 'IBC':
-                ;(instance.provider as StargateClient).getChainId = mock
-                break
-            case 'XRPL':
-                ;(instance.provider as Client).connect = mock
-                break
-            case 'EGLD':
-                ;(instance.provider as INetworkProvider).getNetworkConfig = mock
-                break
-
-            default:
-                expect(true).toBe(false)
-        }
-
-        let isConnected: boolean
-
-        if (name === 'IBC') {
-            isConnected = await (instance as IBC).connect(instance.rpc_url)
-        } else {
-            // @ts-expect-error
-            isConnected = await instance.connect(false)
-        }
-
-        expect(isConnected).toBe(false)
-    })
-
-    test('On disconnect, provider is reset', async () => {
-        // INFO: Disconnecting allows us to exit tests without
-        // leaving open handles for web socket providers (eg. XRPL)
-        await instance.disconnect()
-
-        expect(instance.connected).toBe(false)
-        expect(instance.provider).toBe(null)
-        expect(instance.wallet).toBe(null)
-    })
-})

package/src/tests/multichain/multiversx.test.ts

@@ -1,57 +0,0 @@
-import { Address } from '@multiversx/sdk-core'
-
-import { MULTIVERSX } from '@/multichain/core'
-import { getSampleTranfers, verifyNumberOrder } from '../utils'
-import { wallets } from '../utils/wallets'
-import chainProviders from './chainProviders'
-
-describe('EGLD CHAIN TESTS', () => {
-    let instance: MULTIVERSX
-
-    beforeAll(async () => {
-        instance = await MULTIVERSX.create(chainProviders.egld.testnet)
-        const connected = await instance.connect()
-        expect(connected).toBe(true)
-    })
-
-    test('preparePay returns a signed transaction', async () => {
-        await instance.connectWallet(wallets.egld.wallet, {
-            password: wallets.egld.password,
-        })
-        const tx = await instance.preparePay(instance.getAddress(), '0.00001')
-
-        // INFO: Signature should be a 128 bit string
-        expect(tx.signature?.length).toEqual(128)
-    })
-
-    test('Transcation is signed with the ledger nonce', async () => {
-        const address = new Address(instance.getAddress())
-        // INFO: Get the user's account on the network
-        const accountOnNetwork = await instance.provider.getAccount(address)
-        const ledgerNonce = accountOnNetwork.nonce
-
-        const tx = await instance.preparePay(instance.getAddress(), '0.00001')
-
-        expect(tx.nonce).toEqual(ledgerNonce)
-    })
-
-    test('Transactions are signed with increasing nonces', async () => {
-        const address = instance.getAddress()
-        const txs = await instance.preparePays(getSampleTranfers(address))
-
-        const is_sorted = verifyNumberOrder(txs, 'nonce')
-
-        // INFO: Nonces should be sorted in ascending order
-        expect(is_sorted).toBe(true)
-    })
-
-    test('Transactions are signed in order of appearance', async () => {
-        const address = instance.getAddress()
-        const txs = await instance.preparePays(getSampleTranfers(address))
-
-        const is_sorted = verifyNumberOrder(txs, 'value')
-
-        // INFO: Amounts should be sorted in ascending order
-        expect(is_sorted).toEqual(true)
-    })
-})