Public
Edited
Oct 17, 2022
1 star
FVM Actor Code Playground - "Hello World"FVM Actor Code Playground - SimpleCoin EVM ContractFVM Actor Code Playground - ERC20 Sans EventsFVM Actor Code Playground - ERC20 Sans Events - Hyperspace TestnetFVM Actor Code Playground - ERC20 Sans Events - Wallaby TestnetFVM Actor Code Playground - "Simple Faucet"FVM Actor Code Playground - "Bounties for Deals"
FVM Actor Code Playground - "List Miners" Investigation
(new CID(stateCid)).bytes
callMethod10ResultDecoded = {
if (!callMethod10Result?.MsgRct?.Return) return
return cbor.decode(callMethod10Result.MsgRct.Return, 'base64')
}
miners = callMethod10ResultDecoded && callMethod10ResultDecoded.map(buf => filecoinAddress.newAddress(buf[0], buf.slice(1), 't').toString()).sort()
new FilecoinNumber('5', 'attofil')
cbor.encode([new FilecoinNumber('5', 'attofil')]).toString('base64')
function bigToBytes(num) {
// https://github.com/Zondax/filecoin-signing-tools/blob/5a126fa599695dac720c692cb286a8c572187f88/signer-npm/js/src/index.js#L54
// https://github.com/spacegap/spacegap.github.io/blob/ccfa30a3e5303c4538c59f3a23186882eddf810e/src/services/filecoin/index.js#L145
if (num === '0' || num === 0) {
return new Uint8Array(0)
}
const numBigInt = (typeof num === 'object') ? (new BN(num.toAttoFil(), 10)) : (new BN(num, 10))
const numArray = numBigInt.toArrayLike(Array, 'be', numBigInt.byteLength())
if (numBigInt.isNeg()) {
numArray.unshift(1)
} else {
numArray.unshift(0)
}
return new Uint8Array(numArray)
}
bigToBytes(-1234)
bigToBytes(1234)
bigToBytes(new FilecoinNumber(1234, 'attofil'))
({ x: 1 }).toString()
bigToBytes("1234")
bigToBytes("12345678901234567890")
bigToBytes(12345678901234567890n)
function bytesToBig (p) { // https://github.com/spacegap/spacegap.github.io/blob/ccfa30a3e5303c4538c59f3a23186882eddf810e/src/services/filecoin/index.js#L145
let sign = p[0]
let acc = new BN(0)
for (let i = 1; i < p.length; i++) {
acc = acc.mul(new BN(256))
acc = acc.add(new BN(p[i]))
}
if (sign === 1) {
return -acc
} else if (sign === 0) {
return acc
} else {
throw new Error('Unexpected value for first byte, expected 0 or 1 for sign')
}
}
bytesToBig(bigToBytes(12345678901234567890n)).toString()
bytesToBig(bigToBytes(-1234)).toString()
skypack = (library) => import(`https://cdn.skypack.dev/${library}?min`)
LotusRPC = (await import('@filecoin-shipyard/lotus-client-rpc')).LotusRPC
BrowserProvider = (await import('@filecoin-shipyard/lotus-client-provider-browser')).BrowserProvider
schema = (await import('@filecoin-shipyard/lotus-client-schema')).mainnet.fullNode
stripAnsi = (await import('https://unpkg.com/strip-ansi@7.0.1/index.js?module')).default
cbor = import('https://cdn.skypack.dev/borc')
ipldDagCbor = import('https://cdn.skypack.dev/@ipld/dag-cbor@7.0.1?min')
CID = (await import('https://jspm.dev/cids')).default
import {button} from '@jimpick/download-data-button-with-wasm-support'
filecoinJsSigner = import('https://jspm.dev/@blitslabs/filecoin-js-signer')
FilecoinClient = filecoinJsSigner.FilecoinClient
FilecoinSigner = filecoinJsSigner.FilecoinSigner
filecoinNumber = import('https://cdn.skypack.dev/@glif/filecoin-number')
FilecoinNumber = filecoinNumber.FilecoinNumber
BN = require('https://bundle.run/bn.js@5.2.0')
multiformats = import('https://cdn.skypack.dev/multiformats@9.6.5?min')
base64ArrayBuffer = import('https://cdn.skypack.dev/base64-arraybuffer@1.0.2?min')
utilHexEncoding = import('https://cdn.skypack.dev/@aws-sdk/util-hex-encoding@3.58.0?min')
filecoinAddress = import('https://cdn.skypack.dev/@glif/filecoin-address')
initialCode = (await fetch(initialCodeUrl)).text()
method2Code = `
/// Method num 2.
pub fn say_hello() -> Option<RawBytes> {
let mut state = State::load();
state.count += 1;
let state_cid = state.save();
let ret = to_vec(format!("Hello world #{}! CID: {}", &state.count, &state_cid).as_str());
match ret {
Ok(ret) => Some(RawBytes::new(ret)),
Err(err) => {
abort!(
USR_ILLEGAL_STATE,
"failed to serialize return value: {:?}",
err
);
}
}
}
/// Method num 3.
pub fn get_state_cid() -> Option<RawBytes> {
let state_cid = sdk::sself::root().unwrap();
Some(RawBytes::new(state_cid.to_bytes()))
}
/// Method num 4.
pub fn echo_raw_bytes(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let ret = to_vec(format!("Params {:?}",
params).as_str());
match ret {
Ok(ret) => Some(RawBytes::new(ret)),
Err(err) => {
abort!(
USR_ILLEGAL_STATE,
"failed to serialize return value: {:?}",
err
);
}
}
}
#[derive(Debug, Serialize_tuple, Deserialize_tuple)]
pub struct CidParams {
pub cid: Cid,
}
/// Method num 5.
pub fn get_state_cid_cbor() -> Option<RawBytes> {
let state_cid = sdk::sself::root().unwrap();
let cid_for_cbor = CidParams {
cid: state_cid
};
Some(RawBytes::serialize(cid_for_cbor).unwrap())
}
/// Method num 6.
pub fn echo_cid_params(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let params: CidParams = params.deserialize().unwrap();
let ret = to_vec(format!("Params {:?}",
params).as_str());
match ret {
Ok(ret) => Some(RawBytes::new(ret)),
Err(err) => {
abort!(
USR_ILLEGAL_STATE,
"failed to serialize return value: {:?}",
err
);
}
}
}
/// Method num 7.
pub fn get_old_state(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let params: CidParams = params.deserialize().unwrap();
let old_state_cid = params.cid;
let old_state = Blockstore.get_cbor::<State>(&old_state_cid).unwrap();
Some(RawBytes::serialize(&old_state).unwrap())
}
/// Method num 8.
pub fn get_state_as_bytes(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let params: CidParams = params.deserialize().unwrap();
let old_state_cid = params.cid;
let old_state_vec = sdk::ipld::get(&old_state_cid).unwrap();
Some(RawBytes::new(old_state_vec))
}
/// Storage power actor state
#[derive(Default, Serialize_tuple, Deserialize_tuple)]
pub struct PowerActorState {
#[serde(with = "bigint_ser")]
pub total_raw_byte_power: StoragePower,
#[serde(with = "bigint_ser")]
pub total_bytes_committed: StoragePower,
#[serde(with = "bigint_ser")]
pub total_quality_adj_power: StoragePower,
#[serde(with = "bigint_ser")]
pub total_qa_bytes_committed: StoragePower,
#[serde(with = "bigint_ser")]
pub total_pledge_collateral: TokenAmount,
#[serde(with = "bigint_ser")]
pub this_epoch_raw_byte_power: StoragePower,
#[serde(with = "bigint_ser")]
pub this_epoch_quality_adj_power: StoragePower,
#[serde(with = "bigint_ser")]
pub this_epoch_pledge_collateral: TokenAmount,
pub this_epoch_qa_power_smoothed: FilterEstimate,
pub miner_count: i64,
/// Number of miners having proven the minimum consensus power.
pub miner_above_min_power_count: i64,
/// A queue of events to be triggered by cron, indexed by epoch.
pub cron_event_queue: Cid, // Multimap, (HAMT[ChainEpoch]AMT[CronEvent]
/// First epoch in which a cron task may be stored. Cron will iterate every epoch between this
/// and the current epoch inclusively to find tasks to execute.
pub first_cron_epoch: ChainEpoch,
/// Claimed power for each miner.
pub claims: Cid, // Map, HAMT[address]Claim
pub proof_validation_batch: Option<Cid>,
}
/// Method num 9.
pub fn get_power_actor_state(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let params: CidParams = params.deserialize().unwrap();
let state_cid = params.cid;
let state = Blockstore.get_cbor::<PowerActorState>(&state_cid).unwrap();
Some(RawBytes::serialize(&state).unwrap())
}
#[derive(Debug, Serialize_tuple, Deserialize_tuple, Clone, PartialEq)]
pub struct Claim {
/// Miner's proof type used to determine minimum miner size
pub window_post_proof_type: RegisteredPoStProof,
/// Sum of raw byte power for a miner's sectors.
#[serde(with = "bigint_ser")]
pub raw_byte_power: StoragePower,
/// Sum of quality adjusted power for a miner's sectors.
#[serde(with = "bigint_ser")]
pub quality_adj_power: StoragePower,
}
/// Method num 10.
pub fn get_power_actor_miners(params: u32) -> Option<RawBytes> {
let params = sdk::message::params_raw(params).unwrap().1;
let params = RawBytes::new(params);
let params: CidParams = params.deserialize().unwrap();
let state_cid = params.cid;
let state = Blockstore.get_cbor::<PowerActorState>(&state_cid).unwrap().unwrap();
let claims = Hamt::<Blockstore, _>::load_with_bit_width(&state.claims, Blockstore, HAMT_BIT_WIDTH).unwrap();
let mut miners = Vec::new();
claims.for_each(|k, _: &Claim| {
miners.push(Address::from_bytes(&k.0)?);
Ok(())
}).ok()?;
Some(RawBytes::serialize(&miners).unwrap())
}
`.trim()
templateStart = {
const code = initialCode
.replace('pub fn invoke(_: u32)', 'pub fn invoke(params: u32)')
.replace(/\/\/\/ Method num 2.*/s, '')
.split('\n')
const insertAt = code.findIndex(line => line.match(/say_hello\(\)/)) + 1
code.splice(
insertAt, 0,
' 3 => get_state_cid(),',
' 4 => echo_raw_bytes(params),',
' 5 => get_state_cid_cbor(),',
' 6 => echo_cid_params(params),',
' 7 => get_old_state(params),',
' 8 => get_state_as_bytes(params),',
' 9 => get_power_actor_state(params),',
' 10 => get_power_actor_miners(params),',
)
code.splice(
10, 0,
'use fvm_shared::bigint::bigint_ser;',
'use fvm_shared::econ::TokenAmount;',
'use fvm_shared::sector::{RegisteredPoStProof, StoragePower};',
'use fvm_shared::clock::ChainEpoch;',
'use fvm_shared::smooth::FilterEstimate;',
'use fvm_ipld_hamt::Hamt;',
'use fvm_shared::HAMT_BIT_WIDTH;',
'use fvm_shared::address::Address;',
)
return code.join('\n')
}
initialCargoToml = (await fetch(initialCargoTomlUrl)).text()
patchedCargoToml = {
function gitVersion (version) {
const rev = '297a7694'
return `{ version = "${version}", git = "https://github.com/filecoin-project/ref-fvm", rev = "${rev}" }`
}
const replaced = initialCargoToml
.replace(/fvm_sdk = .*/, `fvm_sdk = ${gitVersion('0.6.1')}`)
.replace(/fvm_shared = .*/, `fvm_shared = ${gitVersion('0.6.1')}`)
.replace(/fvm_ipld_blockstore = .*/, `fvm_ipld_blockstore = ${gitVersion('0.1.0')}`)
.replace(/fvm_ipld_encoding = .*/, `fvm_ipld_encoding = ${gitVersion('0.2.0')}`)
const lines = replaced.split('\n')
const insertAt = lines.findIndex(line => line.match(/dev-dependencies/)) - 1
lines.splice(
insertAt, 0,
`fvm_ipld_hamt = ${gitVersion('0.5.1')}`,
)
return lines.join('\n')
}
client = {
const provider = new BrowserProvider(`${baseUrl}/rpc/v0`, { token })
return new LotusRPC(provider, { schema })
}
filecoin_client = new FilecoinClient(`${baseUrl}/rpc/v0`, token)
async function *heightStream () {
let last
while (true) {
try {
const newHeight = (await client.chainHead()).Height
if (newHeight !== last) {
yield newHeight
last = newHeight
}
} catch (e) {
yield 0
}
await Promises.delay(4000)
}
}
mutable ready = false
async function *heightReadyTapStream () {
let lastReady = false
for await (const height of heightStream()) {
const newReady = height > 7
if (newReady !== lastReady) {
mutable ready = newReady
lastReady = newReady
}
yield height
}
}
currentHeight = heightReadyTapStream()
walletDefaultAddress = ready && client.walletDefaultAddress()
One platform to build and deploy the best data apps
Experiment and prototype by building visualizations in live JavaScript notebooks. Collaborate with your team and decide which concepts to build out.
Use Observable Framework to build data apps locally. Use data loaders to build in any language or library, including Python, SQL, and R.
Seamlessly deploy to Observable. Test before you ship, use automatic deploy-on-commit, and ensure your projects are always up-to-date.