0x | 🔥 single-command flamegraph profiling 🔥 | Monitoring library

I still don't know why this started failing all of a sudden but I have resolved the problem by updating node-sass to version 6.0.1.

That error is clear. you do not have sufficient funds. This is how you are getting the account information:

to test locally you need to make use of mocks which can simulate having an oracle network. Because you're working locally, a Chainlink node doesn't know about your local blockchain, so you can't actually do proper VRF requests. Note you can try deploy a local Chainlink node and a local blockchain and have them talk, but it isn't fully supported yet so you may get mixed results. Anyway, as per the hardhat starter kit that you linked, you can set the defaultNetwork to be 'hardhat' in the hardhat.config.js file, then when you deploy and run the integration tests (yarn test-integration), it will use mocks to mock up the VRF node, and to test the requesting of a random number. See the test here, and the mock contracts and linktoken get deployed here

Thanks, the error happens for having Node 16. With NodeJs 14.0 working orocommerce 4.1.1!

replace img.data[index] = shift | (b << 16) | (g << 8) | r;

with

I fixed this issue by doing 2 things:

1. By changing MoveWindow(_unityHWND, 0, 0, (int)UnityContent.Width, (int)UnityContent.Height, true);

to

MoveWindow(_unityHWND, 0, 0, (int)UnityContent.ActualWidth, (int)UnityContent.ActualHeight, true);

1. The unity window was not the same scale as the WPF window, so I had to add the following to mainwindow.xaml.cs

Not possible by design.

A contract address is determined from the deployment transaction params. Specifically, the ethers deploy() function is using the CREATE opcode by default, so the contract address is determined from the deployer address and the deploying transaction nonce param.

But the private key to the contract address is never generated during the deployment - so it can't be returned. Just the address.

Because otherwise I can't call the transfer method on the smart contract.

Correct. If you want to transfer funds out of the contract, you need to implement a function to be able to do that.

The issues you're seeing aren't related to how Python finds __new__ or chooses its arguments. __new__ receives every argument you're passing. The effects you observed come from specific code in object.__new__, combined with a bug in the logic for updating the C-level tp_new slot.

There's nothing special about how Python passes arguments to __new__. What's special is what object.__new__ does with those arguments.

object.__new__ and object.__init__ expect one argument, the class to instantiate for __new__ and the object to initialize for __init__. If they receive any extra arguments, they will either ignore the extra arguments or throw an exception, depending on what methods have been overridden:

1. If a class overrides exactly one of __new__ or __init__, the non-overridden object method should ignore extra arguments, so people aren't forced to override both.
2. If a subclass __new__ or __init__ explicitly passes extra arguments to object.__new__ or object.__init__, the object method should raise an exception.
3. If neither __new__ nor __init__ are overridden, both object methods should throw an exception for extra arguments.

There's a big comment in the source code talking about this.

At C level, __new__ and __init__ correspond to tp_new and tp_init function pointer slots in a class's memory layout. Under normal circumstances, if one of these methods is implemented in C, the slot will point directly to the C-level implementation, and a Python method object will be generated wrapping the C function. If the method is implemented in Python, the slot will point to the slot_tp_new function, which searches the MRO for a __new__ method object and calls it. When instantiating an object, Python will invoke __new__ and __init__ by calling the tp_new and tp_init function pointers.

object.__new__ is implemented by the object_new C-level function, and object.__init__ is implemented by object_init. object's tp_new and tp_init slots are set to point to these functions.

object_new and object_init check whether they're overridden by checking a class's tp_new and tp_init slots. If tp_new points to something other than object_new, then __new__ has been overridden, and similar for tp_init and __init__.

i gave up trying to understand promises (but i understand some of it) so i reverted to synchronous code while still implementing true multithreading via nodejs cluster and it now runs much, much faster than single threaded

run.js