Hi we are talking about a few months back, so it may have changed but yeah it was the script tag. An example of the conflict can be seen here with mono-wasm and the Nethereum playground:
also not Nethereum related using as well mono-wasm (they need to change their namespace too!, I have already told them)

@ekpyron I had this problems in the past where other web assembly components have been registered and use Module as the main namespace, when loaded they will "compete" with each other overwriting their space. This has made it impossible to integrate with both. In my context I have seen this (although it might been resolved now as they might have also changed their namespace) with: mono-wasm (.net runtime), unity3d (unity engine) and other projects..

@ekpyron great points, I load normally different compiler versions dynamically, (node) users might have already stored them locally (cache or downloaded), but the crwap method is already part of the compiler when you call setupmethods in the wrapper, so i don't think that it will be an issue in general. Now.. my guess is that loading remotely in the browser may require all previous compilers to have the "Solidity" namespace.

Sure i can add an extra check for the LowS but whilst this is very specific to txn malleability, and Nethereum forces it, I can see how it could be the some form of attack in scenarios like GSN that you are using for MITM.

Yes,

This is the recovery mechanism: https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Signer.UnitTests/Eip712TypedDataSignerTest.cs#L74-L78

I will simplify it by adding it to the API :)

hi, just pop over for a chat at Gitter: https://gitter.im/Nethereum/Nethereum

The best thing is to code generate your smart contract interface, far much easier, check this https://docs.nethereum.com/en/latest/nethereum-codegen-vscodesolidity/, or simply just right click in vscode in your solidity contract and click compile and code generate to C#.

This creates your contract definition and deployment.

You can do it for both your proxy and implementation.

Then you can follow this example for deployment for both http://playground.nethereum.com/csharp/id/1006

Thanks @fvictorio

Hi, this is great but it will be easier to set it in the common file. https://github.com/Nethereum/Nethereum/blob/master/buildConf/Frameworks.props

What

The npm postinstall script runs both on local npm install as well as after being installed as a dependency of someone else’s project. The prepare script only runs on local npm install (and before publishing). [npm-scripts]

Why

vscode is a devDependency, not a dependency, so if someone tries to install this package as a dependency of their own, the installation fails because ./node_modules/vscode does not exist.

Wait, what?

I’m the maintainer of gatsby-remark-vscode, a plugin for the Gatsby static site system that lets blog authors harness VS Code’s syntax highlighting engine to style their code blocks. Folks who are blogging about languages that aren’t included in VS Code’s default set of supported languages, like Solidity, can use GitHub repos like this to get syntax highlighting. Since the Visual Studio Marketplace is licensed for use only by Visual Studio products, I’m encouraging users to npm install any language and theme packages they need directly from GitHub (e.g. npm install juanfranblanco/vscode-solidity), provided the source is licensed appropriately. Unfortunately, that currently fails due to the postinstall script:

See also

https://github.com/styled-components/vscode-styled-components/pull/203

If you right click you can select a different compiler version as part of your global settings (or workspace). You can also install as per @jchittoda a local version of solc in the same folder that will take preference.

ha ha well I am sure going to need help :) The truth is that the process has not changed much (and Uport was a separate project so they did all heavy lifting and learning process, together with other people working on DID), now as usual there is nothing in .Net. so it won't be finished tomorrow..

So mainly it is a proper re-write.. the whole thing needs mostly everything here: https://github.com/decentralized-identity From DID Url, DID Jwt, DID Resolver a DID Agent (all could be part of Blazor) and of course if you are creating a mobile app to verify and sign requests like Uport..

https://github.com/Nethereum/Nethereum/tree/master/src/Nethereum.Uport.. btw this is also old :)..

Well this project moved to the main Nethereum project and I am working on DIDs stuff at the moment. What happened these years is the creation of DIDs, the recreation of UPort and Uport donating much of their work to be part of the DID standard.

And link to new extension

using System; using System.Text; using Nethereum.Hex.HexConvertors.Extensions; using System.Threading.Tasks; using Nethereum.Web3;

public class Program {

static async Task Main(string[] args)
{

            var web3 = new Web3("https://mainnet.infura.io/v3/7238211010344719ad14a89db874158c");

            var pendingFilter = await web3.Eth.Filters.NewPendingTransactionFilter.SendRequestAsync();

            var filterChanges = await web3.Eth.Filters.GetFilterChangesForBlockOrTransaction.SendRequestAsync(pendingFilter);
            foreach(var value in filterChanges) {
                Console.WriteLine(value);
            }

}

}

using System; using System.Text; using Nethereum.Hex.HexConvertors.Extensions; using System.Threading.Tasks; using Nethereum.Web3; using Nethereum.RPC.Eth.DTOs;

public class Program {

static async Task Main(string[] args)
{

			var web3 = new Web3("https://mainnet.infura.io/v3/7238211010344719ad14a89db874158c");

		  var block = await web3.Eth.Blocks.GetBlockWithTransactionsByNumber.SendRequestAsync(BlockParameter.CreatePending());
				foreach(var txn in block.Transactions) {
						Console.WriteLine(
							$@"Hash:{txn.TransactionHash}, From: {txn.From}, To: {txn.To}, Value: {txn.Value}, Nonce: {txn.Nonce}, Data: {txn.Input}");
						
				}
			
}

}

The only issue I see here is that domains have been already purchased for certain companies, but we could have a generic subdomain ie (xxx.baseline.eth) for all companies may don't want to or cannot purchase their own domain. The great thing about ENS, is that Baseline as the root owner, can give full control to those companies of their own domain and capability to create any subdomains.

Hi @mudgen , apologies I forgot to answer. I have read through the standard and yes it will be very interesting to have it implemented here, do you have some time to have a chat? As I want to pick your brain.

@chriseth I see your point and I guess to start with might be the best approach, but looking at the issues that prettier solidity and solhint have been having with specific rules (override, etc) with new / old releases, or just simple autocomplete (key words), refactoring etc. It might be good to have different grammars in the future, which ideally can be loaded on the fly depending of the compiler version and features supported.

My guess is that in the future more keywords and syntax changes will be added, this way remain backwards compatible, rather than removed (extra features), so being a devil advocate of that thought, it might be just a question to understand what subset is added in each version release, to enable disable those elements.

The latest version of the HD Wallet has the latest of NBitcoin. Although not released yet, this is also the same package that you need for your "PublicWallet"

That was rather fast btw...

Can you change the text to something like: "Mythx analysis tool, has been moved to its own stand alone extension, please download it here:..". Sounds nicer.

Yes the sample needs updating to the latest version, but nothing major, you just need supply your chainId (if wanted) like mainnet = 1 or a null value https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.Unity/EthTransferUnityRequest.cs#L11

@yorkerhodes3 what data will be integrated here?

Are you using the latest with the sample? Remove the UnityEngine.dll it is output as part of the build.

Question, will it be possible to have a grammar published in solc-bin (or is it the plan?) for each version of solidity released? This way tooling can load specific grammar associated with the current solidity version. @axic

oh and a sidetree for ethereum, which just pushes txn events https://github.com/decentralized-identity/sidetree-ethereum for immutability but keeps the data internally.

Ethereum specific, most build on the standards set by Uport, https://w3c-ccg.github.io/did-method-registry/ although there is a java driver for https://github.com/decentralized-identity/uni-resolver-driver-did-erc725 which is another standard of identity in ethereum.

This is all new, so it will be in the next release, or you can get latest and compile. The CI build is not ready yet.

Hi check the latest. See the usage here for your needs, just use the hex string of your ExtendedPublicKey. https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.HdWallet.UnitTests/WalletTests.cs#L124-L134

Update NBitcoin package to resolve IRandom latest NBitcoin's interface.

And I share your goals :) Anybody should be able to use it, develop an app with it, and chose if they want to host their DID Documents themselves or delegate them to a third party. Ideally the former first and the second will be a plugin to existing or new providers.

@pvanroos Well we have now a full release of Blazor web assembly and the DID standard although rather abstracted, seems to be there, now is a question of implementation although there is plenty to work there as there is nothing in .Net. The simplest starting point is to create the Ethereum registry and resolver (my plan) and the move up to the Universal ones.

What is your expectation for authentication / authorization using a dapp?

This epic will provide:

A common UI framework to handle integration with different host providers (like Metamask in the browser), or Nethereum for a Desktop / Mobile / Out of browser scenario.

The chosen web framework is Blazor as it can run client and server side, other web frameworks like Uno will follow.

Simple authentication and authorization in the browser.

Blazor components.

Thanks to you !! :)

Hi @pvanroos well the idea is to start working on a DID implementation that will integrate with uports registry and provide a register. What is your use case for authentication? What is your device? A simple authentication is to integrate with the browser signer using blazor either server side or client side which i am also working on

@joaosantos15 this is due to referencing libraries, these need to be replaced later on with the library contract address

Thanks is the plugins section in solhint that is causing the crash, I will be releasing a new version today which checks for this.

@PaulRBerg are you using solhint?

Thanks for that I was banging my head. That reduces the area :)

Thanks @PaulRBerg checking it now

Hi, you can find this is in the ClientBase as a generic setting. Web3 exposes the interface. This can be set using RPCClient. https://github.com/Nethereum/Nethereum/blob/master/src/Nethereum.JsonRpc.Client/ClientBase.cs#L11

@N1028YuKi that is strange, what are your settings?

using System; using System.Text; using Nethereum.Hex.HexConvertors.Extensions; using System.Threading.Tasks; using Nethereum.Web3; using Nethereum.Web3.Accounts; using Nethereum.Hex.HexConvertors.Extensions; using Nethereum.RPC.TransactionManagers; using Nethereum.Signer; using Nethereum.RPC.Eth.DTOs; using Nethereum.Util; using Nethereum.Hex.HexTypes;

public class Program { private static async Task Main(string[] args) { //First let's create an account with our private key for the account address var privateKey = "0x7580e7fb49df1c861f0050fae31c2224c6aba908e116b8da44ee8cd927b990b0"; var account = new Account(privateKey);

    Console.WriteLine("Our account: " + account.Address);
    //Now let's create an instance of Web3 using our account pointing to our nethereum testchain
    var web3 = new Web3(account, "http://testchain.nethereum.com:8545");

    var toAddress = "0x1bb31d596c34bd81e1f0be1edf3840a7b43dd9cd";
    var transactionManager = web3.TransactionManager;
			
			//Gas price and nonce is calculated by the transaction manager so no need to set it
			var txnInput = new TransactionInput() {
				From = account.Address,
				To = toAddress,
				Data = "0x7b227465737444617465223a2232372f30352f323032302031333a32353a35322e38373120504d227d"
		};

			Console.WriteLine(transactionManager.DefaultGas);
			//lets estimate and set the gas as we have some data
			var gasEstimate = await  transactionManager.EstimateGasAsync(txnInput);
			Console.WriteLine(gasEstimate.Value);
			txnInput.Gas = gasEstimate;

			var txnHash1 = await transactionManager.SendTransactionAsync(txnInput);

			Console.WriteLine(txnHash1);

			var txnInput2 = new TransactionInput() {
				From = account.Address,
				To = toAddress,
				Data = "0x7b227465737444617465223a2232372f30352f323032302031333a32353a35322e38373120504d227d",
				Gas = gasEstimate,
				//Lets use the same nonce to replace the transaction
				Nonce = txnInput.Nonce
		};

			//Lets increment the gas price to replace the transaction
			var gasPrice = await web3.Eth.GasPrice.SendRequestAsync();
			//incrementing the gas price
			txnInput2.GasPrice = new HexBigInteger(gasPrice.Value + Web3.Convert.ToWei(1, UnitConversion.EthUnit.Gwei));
		
			var txnHash2 = await transactionManager.SendTransactionAsync(txnInput2);

			Console.WriteLine(txnHash2);

	}

}

Ah what you meant by custom rules was your plugins, not your specific rules. Yes that needs to be fixed by the solhint guys... the same as before..

Thanks, I have upgraded to solhint 3.0 on the latest release, I did not experienced any issues on my side even using a JSON file... obviously not enough :(

@wadepickett I guess as an entry point MAUI can and will bring lots of benefits, specially anyone starting with .Net and for extended scenarios or different use cases Uno and / or Avalonia will be necessary the same as now. If MVU becomes the new way that people chose to start working with MAUI, the Xaml discussion might shift into specific capabilities and how to achieve those in those other platforms.