CRYPTO NEWS

Using ed22519 signature as entropy

I am developing an application in which all application state is entirely public. Each user of the application is equipped with their own ed22519 keypair, and the application can only ask users for signatures of arbitrary data.

I would like to store some private data for each user in the public application state. The private data for any given user should only be able to be decrypted by that specific user.

I believe the typical approach would be for the users to encrypt their own private data using their keypair and then the application would store that in the public application state. However, the application can only ask the users to sign data with their keypairs, not encrypt it.

Because of this, I was thinking of having the application ask the users to sign some message like I am signing this message for <application> using <nonce>, where is a nonce that is stored publicly. This signature is then used as the random entropy to derive a new keypair, which can then be used to encrypt the private data.

Is this mechanism sound? Thank you in advance!

Gnosis safe transfer function `Approve Hash` but does not transfer erc20 token

I am using the gnosis-safe core SDK here to create transactions to transfer Eth out of a deployed safe proxy. Doc: https://github.com/safe-global/safe-core-sdk/tree/main/packages/safe-core-sdk#deploysafe I deployed the proxy on Rinkeby via: const { ethereum } = window; const provider = new ethers.providers.Web3Provider(ethereum) const safeOwner = provider.getSigner(0) const ethAdapter = new EthersAdapter({ ethers, signer: safeOwner }); const txServiceUrl::Listen

I am using the gnosis-safe core SDK here to create transactions to transfer Eth out of a deployed safe proxy. Doc: https://github.com/safe-global/safe-core-sdk/tree/main/packages/safe-core-sdk#deploysafe

I deployed the proxy on Rinkeby via:

        const { ethereum } = window;         const provider = new ethers.providers.Web3Provider(ethereum)         const safeOwner = provider.getSigner(0)         const ethAdapter = new EthersAdapter({ ethers, signer: safeOwner });          const txServiceUrl = 'https://safe-transaction.gnosis.io';         const safeService = new SafeServiceClient({ txServiceUrl, ethAdapter });         const is_dev = true;         let ethAdapter = this.ethAdapter;         const safeFactory = await SafeFactory.create({ ethAdapter, isL1SafeMasterCopy: !is_dev });          const safeAccountConfig = {           owners: ['0x...D9'],           threshold: 1,         }                  const safeSdk = await safeFactory.deploySafe({ safeAccountConfig });          

So it is a safe with just one authorizer. I then deposit some ETH into this safe proxy, and try to send it out of the safe with:

        let safeAddress = '0x...c';         const safeSdk = await Safe.create({ ethAdapter, safeAddress, isL1SafeMasterCopy: false })         const num_ethers = ethers.utils.parseUnits("0.1", 'ether').toHexString();         const transaction = {           to: '0x...1',            data: '0x',           value:num_ethers,         }         const safeTransaction = await safeSdk.createTransaction(transaction)                 console.log('safeTransaction: ', safeTransaction)         const hash = await safeSdk.getTransactionHash(safeTransaction);         const txResponse = await safeSdk.approveTransactionHash(hash);         const reshash = await txResponse.transactionResponse?.wait();         

What ends up happening is that the authorizer is charged for the ApproveHash transaction, but the Eth does not transfer. Is there something I’m missing here conceptually? The data field should be 0x for transferring eth on Rinkeby network as well right? Tx log here: https://rinkeby.etherscan.io/address/0x99Ae62C23728EAa970F5064DcD3F869ae80FC89c

Using ed22519 signature as entropy

Shopping cart
There are no products in the cart!
Continue shopping
0