initiate is ok

Author: open-junius

evm-tests/bittensor/lib.rs

@@ -239,29 +239,22 @@ mod bittensor {
             Self::new()
         }
 
-        /// A message that can be called on instantiated contracts.
-        /// This one flips the value of the stored `bool` from `true`
-        /// to `false` and vice versa.
         #[ink(message)]
-        pub fn a(&self) -> bool {
-            true
+        pub fn get_stake_info_for_hotkey_coldkey_netuid(
+            &mut self,
+            hotkey: [u8; 32],
+            coldkey: [u8; 32],
+            netuid: u16,
+        ) -> Result<Option<StakeInfo<ink::primitives::AccountId>>, ReadWriteErrorCode> {
+            self.env()
+                .extension()
+                .get_stake_info_for_hotkey_coldkey_netuid(
+                    hotkey.into(),
+                    coldkey.into(),
+                    netuid.into(),
+                )
+                .map_err(|_e| ReadWriteErrorCode::ReadFailed)
         }
-
-        // pub fn get_stake_info_for_hotkey_coldkey_netuid(
-        //     &mut self,
-        //     hotkey: [u8; 32],
-        //     coldkey: [u8; 32],
-        //     netuid: u16,
-        // ) -> Result<Option<StakeInfo<ink::primitives::AccountId>>, ReadWriteErrorCode> {
-        //     self.env()
-        //         .extension()
-        //         .get_stake_info_for_hotkey_coldkey_netuid(
-        //             hotkey.into(),
-        //             coldkey.into(),
-        //             netuid.into(),
-        //         )
-        //         .map_err(|_e| ReadWriteErrorCode::ReadFailed)
-        // }
     }
 
     /// Unit tests in Rust are normally defined within such a `#[cfg(test)]`

evm-tests/package.json

@@ -1,6 +1,6 @@
 {
   "scripts": {
-    "test": "mocha --timeout 999999 --retries 3 --file src/setup.ts --require ts-node/register test/wasm*test.ts"
+    "test": "mocha --timeout 999999 --file src/setup.ts --require ts-node/register test/wasm*test.ts"
   },
   "keywords": [],
   "author": "",

evm-tests/src/config.ts

@@ -2,7 +2,7 @@ export const ETH_LOCAL_URL = 'http://localhost:9944'
 export const SUB_LOCAL_URL = 'ws://localhost:9944'
 export const SS58_PREFIX = 42;
 // set the tx timeout as 2 second when eable the fast-runtime feature.
-export const TX_TIMEOUT = 3000;
+export const TX_TIMEOUT = 2000;
 
 export const IED25519VERIFY_ADDRESS = "0x0000000000000000000000000000000000000402";
 export const IEd25519VerifyABI = [

evm-tests/src/setup.ts

@@ -2,6 +2,7 @@
 import { createClient, TypedApi, PolkadotClient, Binary } from 'polkadot-api';
 import { SUB_LOCAL_URL } from "./config"
 import { getWsProvider } from 'polkadot-api/ws-provider/web';
+import { withPolkadotSdkCompat } from "polkadot-api/polkadot-sdk-compat"
 
 let client: PolkadotClient | undefined = undefined
 
@@ -13,6 +14,15 @@ export async function getClient() {
     return client;
 }
 
+export async function getSdkClient() {
+    const client = createClient(
+        withPolkadotSdkCompat(
+            getWsProvider(SUB_LOCAL_URL),
+        ),
+    )
+    return client
+}
+
 after(() => {
     client?.destroy()
 });

evm-tests/src/substrate.ts

@@ -1,4 +1,4 @@
-import { devnet, MultiAddress, contracts } from '@polkadot-api/descriptors';
+import { devnet, MultiAddress } from '@polkadot-api/descriptors';
 import { TypedApi, Transaction, PolkadotSigner, Binary } from 'polkadot-api';
 import { sr25519CreateDerive } from "@polkadot-labs/hdkd"
 import { DEV_PHRASE, entropyToMiniSecret, mnemonicToEntropy, KeyPair } from "@polkadot-labs/hdkd-helpers"
@@ -7,10 +7,8 @@ import { randomBytes } from 'crypto';
 import { Keyring } from '@polkadot/keyring';
 import { SS58_PREFIX, TX_TIMEOUT } from "./config";
 import { getClient } from "./setup"
-import { getInkClient, InkClient } from "@polkadot-api/ink-contracts"
 
 let api: TypedApi<typeof devnet> | undefined = undefined
-let inkClient: InkClient<contracts> | undefined = undefined
 
 // define url string as type to extend in the future
 // export type ClientUrlType = 'ws://localhost:9944' | 'wss://test.finney.opentensor.ai:443' | 'wss://dev.chain.opentensor.ai:443' | 'wss://archive.chain.opentensor.ai';
@@ -19,18 +17,12 @@ export type ClientUrlType = 'ws://localhost:9944'
 export async function getDevnetApi() {
     if (api === undefined) {
         let client = await getClient()
+
         api = client.getTypedApi(devnet)
     }
     return api
 }
 
-export async function gettInkClient() {
-    if (inkClient === undefined) {
-        inkClient = getInkClient(contracts.bittensor)
-    }
-    return inkClient
-}
-
 export function getKeypairFromPath(path: string) {
     const entropy = mnemonicToEntropy(DEV_PHRASE)
     const miniSecret = entropyToMiniSecret(entropy)
@@ -152,7 +144,7 @@ export async function waitForTransactionWithRetry(
             .catch((error) => {
                 console.log(`transaction error ${error}`);
             });
-        await new Promise((resolve) => setTimeout(resolve, 1000));
+        await new Promise((resolve) => setTimeout(resolve, 2000));
         retries += 1;
     }
 

evm-tests/src/subtensor.ts

@@ -1,6 +1,6 @@
 import * as assert from "assert";
 import { devnet, MultiAddress } from '@polkadot-api/descriptors';
-import { TypedApi, TxCallData } from 'polkadot-api';
+import { TypedApi, TxCallData, Binary, Enum } from 'polkadot-api';
 import { KeyPair } from "@polkadot-labs/hdkd-helpers"
 import { getAliceSigner, waitForTransactionCompletion, getSignerFromKeypair, waitForTransactionWithRetry } from './substrate'
 import { convertH160ToSS58, convertPublicKeyToSs58, ethAddressToH160 } from './address-utils'

evm-tests/test/wasm.contract.test.ts

@@ -1,72 +1,69 @@
 import * as assert from "assert";
-import { getDevnetApi, getRandomSubstrateKeypair, gettInkClient } from "../src/substrate"
-import { devnet } from "@polkadot-api/descriptors"
-import { Binary, Enum, PolkadotSigner, TypedApi } from "polkadot-api";
-import { convertPublicKeyToSs58, convertH160ToSS58 } from "../src/address-utils"
-import { raoToEth, tao } from "../src/balance-math"
-import { ethers } from "ethers"
-import { generateRandomEthersWallet, getPublicClient } from "../src/utils"
-import { convertH160ToPublicKey } from "../src/address-utils"
-import {
-    forceSetBalanceToEthAddress, forceSetBalanceToSs58Address, addNewSubnetwork, burnedRegister,
-    sendProxyCall,
-    startCall,
-} from "../src/subtensor"
+import { getDevnetApi, getAliceSigner, getRandomSubstrateKeypair } from "../src/substrate"
+import { devnet, contracts, MultiAddress } from "@polkadot-api/descriptors"
+import { Binary, PolkadotSigner, TypedApi } from "polkadot-api";
+
 import { ETH_LOCAL_URL } from "../src/config";
 import { ISTAKING_ADDRESS, ISTAKING_V2_ADDRESS, IStakingABI, IStakingV2ABI } from "../src/contracts/staking"
-import { PublicClient } from "viem";
 import { getInkClient, InkClient } from "@polkadot-api/ink-contracts"
-import { contracts } from "@polkadot-api/descriptors"
 import fs from "fs"
+import { convertPublicKeyToSs58 } from "../src/address-utils";
+import { forceSetBalanceToSs58Address } from "../src/subtensor";
 
-const Determinism = {
-    Enforced: Enum('Enforced'),
-    Relaxed: Enum('Relaxed')
-} as const;
+const bittensorWasmPath = "./bittensor/target/ink/bittensor.wasm"
+const bittensorBytecode = fs.readFileSync(bittensorWasmPath)
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-describe("Test neuron precompile add remove stake", () => {
+describe("Test wasm contract", () => {
 
+    let api: TypedApi<typeof devnet>
     const hotkey = getRandomSubstrateKeypair();
     const coldkey = getRandomSubstrateKeypair();
-    const proxy = getRandomSubstrateKeypair();
-
-    let api: TypedApi<typeof devnet>
 
-    let inkClient: InkClient<contracts>;
+    let inkClient: InkClient<typeof contracts.bittensor>;
+    let contractAddress: string;
 
     // sudo account alice as signer
     let alice: PolkadotSigner;
     before(async () => {
         // init variables got from await and async  
         api = await getDevnetApi()
-        inkClient = await gettInkClient()
-
-        // await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(alice.publicKey))
+        alice = await getAliceSigner();
         await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(hotkey.publicKey))
         await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(coldkey.publicKey))
-        await forceSetBalanceToSs58Address(api, convertPublicKeyToSs58(proxy.publicKey))
-        let netuid = await addNewSubnetwork(api, hotkey, coldkey)
-        await startCall(api, netuid, coldkey)
-
-        console.log("test the case on subnet ", netuid)
     })
 
-    it("Can upload contract", async () => {
-        let netuid = (await api.query.SubtensorModule.TotalNetworks.getValue()) - 1
-        if (api === undefined) {
-            throw new Error("api is undefined")
+    it("Can instantiate contract", async () => {
+        const signer = await getAliceSigner();
+        inkClient = getInkClient(contracts.bittensor)
+        const constructor = inkClient.constructor('new')
+        const data = constructor.encode()
+        const instantiate_with_code = await api.tx.Contracts.instantiate_with_code({
+            code: Binary.fromBytes(bittensorBytecode),
+            storage_deposit_limit: BigInt(10000000),
+            value: BigInt(0),
+            gas_limit: {
+                ref_time: BigInt(1000000000),
+                proof_size: BigInt(1000000),
+            },
+            data: Binary.fromBytes(data.asBytes()),
+            salt: Binary.fromHex("0x"),
+        }).signAndSubmit(signer)
+
+
+        let codeStoredEvents = await api.event.Contracts.Instantiated.filter(instantiate_with_code.events)
+        if (codeStoredEvents.length === 0) {
+            throw new Error("No events found")
         }
-        const bytecode = fs.readFileSync("bittensor.wasm")
-        const upload = await api.tx.Contracts.upload_code({
-            code: Binary.fromBytes(bytecode),
-            storage_deposit_limit: BigInt(0),
-            determinism: Determinism.Enforced
-        })
-        // const contract = await inkClient.upload(netuid, "bittensor", "bittensor.json")
-        // assert.ok(contract !== undefined)
+        contractAddress = codeStoredEvents[0].contract
+
+        console.log("===== contractAddress", contractAddress)
     })
 
 
+    it("Can query stake info from contract", async () => {
+
+    })
 
 
 });