• changes to use SCALE codec compatible with Tinygo
• fix wrong field type from the spec
• refactor and use better abstractions for the Host provided functionality

Create interfaces, which allow easier configuration of given types. For example, block number to be easily changed from u64 and u128 in only one place in the codebase.

type Number: Member
		+ MaybeSerializeDeserialize
		+ MaybeFromStr
		+ Debug
		+ sp_std::hash::Hash
		+ Copy
		+ MaybeDisplay
		+ AtLeast32BitUnsigned
		+ Default
		+ TypeInfo
		+ MaxEncodedLen
		+ FullCodec;

• Block Number
• Nonce

There is a TODO in the codebase:

let m = sp_io::hashing::blake2_256(msg.get());
match sp_io::crypto::secp256k1_ecdsa_recover_compressed(sig.as_ref(), &m) {
 	Ok(pubkey) =>
 		&sp_io::hashing::blake2_256(pubkey.as_ref()) ==
 			<dyn AsRef<[u8; 32]>>::as_ref(who),
 	_ => false,
}

Add step-by-step guides on how to run a local network and how to do a transfer

https://spec.polkadot.network/chap-runtime-api#sect-runtime-offchainapi-module

Remove the hard-coded metadata used from node-template and add the missing metadata types. Keep in mind that metadata type path has to be used if you want to successfully connect to polkadotjs, as it is uses path field to rebuilt most types and those paths have to be consistent with Substrate.

Example:

  /**
   * Lookup8: frame_support::dispatch::PerDispatchClass<sp_weights::weight_v2::Weight>
   **/
  FrameSupportDispatchPerDispatchClassWeight: {
    normal: 'SpWeightsWeightV2Weight',
    operational: 'SpWeightsWeightV2Weight',
    mandatory: 'SpWeightsWeightV2Weight'
  },
  /**
   * Lookup9: sp_weights::weight_v2::Weight
   **/
  SpWeightsWeightV2Weight: {
    refTime: 'Compact<u64>',
    proofSize: 'Compact<u64>'
  },

Polkadot v0.9.37

Remove the representation of dispatch-able functions (FnRemark, ... etc.), the Call itself might be used instead.

paritytech/substrate#12564

The input passed to validate_transaction with gosemble types to Substrate runtimes fails. Go through the input arguments and check whether their encoding is correct.

https://docs.substrate.io/build/tx-weights-fees/

Currently in the codebase, whenever ext_storage_get is called the length of the result is checked whether it is > 1 and then the value is decoded. Refactor storage.get to treat the result value as option type.

• system Events
• balances Events
• setBalance
• transfer
• force_transfer
• transfer_keep_alive
• transfer_all
• force_unreserve

• why Gosemble runtime integrated in Substrate requires to grow the memory when its given 2048 pages?
• heap_start for Gosemble runtime in Substrate Host - here

Currently, whenever the runtime panics with an actual written error (e.g. parent hash should be valid), there is only error returned, without actual critical logging:

running runtime function: Failed to call the runtime function exported function

The following log must appear:

CRITICAL target=runtime message=panicked at 'parent hash should be valid', -build error line- ext_logging_log_version_1 pkg=runtime module=go-wasmer

and afterwards

running runtime function: Failed to call the runtime function exported function.

All of the global constant weights do not match Polkadot's.

Upon decoding an extrinsic, assert that the compact extrinsic length matches the actual decoded bytes length

There is no need to export and call "_start" (it is also not expected from the host to support that), since it is the host allocator's responsibility to initialize and grow the heap as needed.

Refactor existing modules to be easier to configure. Each module must have:

• configuration
• storage
• events
• constants
• errors

https://spec.polkadot.network/#id-module-accountnonceapi

https://spec.polkadot.network/#sect-runtime-metadata-module

Consider TinyGo's PR regarding refactoring of reflect package. It might make things easier to use directly encoding/json.

Need to test the compatibility of our runtime with Substrate based host.

https://spec.polkadot.network/#id-module-transactionpaymentapi

It can be implemented either with mocked weights, or after #47

https://docs.substrate.io/build/tx-weights-fees/

Currently, when you pass large data between host & runtime (e.g. 1 MB), the parsed byte slice in the runtime is consisting only of 0.

Create a generic storage type, which takes prefix, name and decode function. Type should implement exists, get and put.

https://spec.polkadot.network/#sect-rte-core-execute-block

• As currently only timestamp is implemented, call onFinalize

https://spec.polkadot.network/#id-blockbuilder_check_inherents

Currently, there is no commit or rollback of extrinsics whenever they are executed.
Each extrinsic must start with start_transaction and depending on the execution call either rollback_transaction, or commit_transaction.

Check:

• Transaction Lifecycle
• Transaction wrapper

With the newer release of our toolchain, based on tinygo 0.28.1, most of the tests fail. This scale pr resolves some of the issues, but there are tests still failing, depending on the GC used:

conservative GC
Test_ApplyExtrinsic_ExhaustsResourcesError
Test_ValidateTransaction_ExhaustsResourcesError

custom extalloc GC
Test_BlockExecution
Test_Metadata_Encoding_Success
Test_ApplyExtrinsic_ExhaustsResourcesError
Test_Balances_Transfer_Invalid_ExistentialDeposit
Test_Balances_SetBalance_BadOrigin
Test_Balances_ForceTransfer_BadOrigin
Test_Balances_ForceFree_BadOrigin

LimeChain/tinygo#14

https://spec.polkadot.network/#defn-rt-builder-inherent-extrinsics

Implement Runtime API function using an initial implementation of Timestamp.

• Gossamer (https://github.com/ChainSafe/gossamer/pull/3012/files is useful)
• TinyGo

We are currently testing everything with the Tinygo's default GC (conservative_gc), but we need to switch to a GC that uses the host's allocator.

Note: sharing data buffers between the host and the runtime is done by allocating chunks of the linear memory and only passing pointers with size between the host and the runtime

GC that doesn't utilize host's allocator

Is not problematic (there are workarounds) when:

• Host shares input data to a runtime function.
• Runtime function returns a result.

Is problematic:

• Host imported function could be invoked in the middle of the execution of a runtime function. If the host function needs to return a buffer, the result is shared by writing it to a memory location that might be occupied by a valid GC allocation.

As a temporary workaround (until we fix the extalloc gc), we use different heap base offsets for the GC and the allocator (there could be memory collisions).

GC that utilizes host's allocator

There is an implementation of extalloc GC that uses external allocator, but there are bugs:

• calling an exported runtime function twice, freezes the second time.

Issues

• in Test_ApplyExtrinsic_ExhaustsResourcesError, Test_ValidateTransaction_ExhaustsResourcesError, we are trying to allocate pointer with size that is bigger than the max possible allocation supported by the host allocator

One of the simplest static site generators focused on creating documentation websites is MkDocs.

Host on Github Pages: https://limechain.github.io/gosemble/

https://spec.polkadot.network/#sect-rte-validate-transaction