Replicating a Universal Profile Across EVM Chains
How to deploy your existing LUKSO Universal Profile at the identical address on another EVM chain — and why it works.
What this is. Your Universal Profile (UP) was created on LUKSO through a deterministic factory contract. Because the factory is deployed at the same address on every EVM chain, replaying your exact original creation transaction on another chain produces a contract at the same address there too. This page explains the mechanism and walks through doing it safely, using the companion tools linked at the bottom.
This is a technical procedure. It assumes you're comfortable with MetaMask, smart contracts, and reading a block explorer. It is not a "one click" consumer flow, and it shouldn't be treated as one.
How the address is actually generated
It is not a simple function of "controller + salt". Your UP was created via LUKSO's LSP23LinkedContractsFactory, deployed at the same address (0x2300000A84D25dF63081feAa37ba6b62C4c89a30) on every chain where LUKSO has published it. The factory call includes:
- an initial salt,
- the implementation and initialization data of the Key Manager (the second linked contract),
- the address of a post-deployment module and its calldata — this is where it is actually specified which address receives
ALL_PERMISSIONS on the new profile.
All of this is hashed together (keccak256) to form the real salt used in CREATE2, combined with the hash of the minimal-proxy bytecode pointing at the Universal Profile implementation. The resulting address depends on the entire original transaction — not on any single field in isolation.
This is why only the exact original calldata reproduces the same address: the controller with full control isn't special on its own — it's simply the address that particular calldata already names. Change the calldata (even to name a different controller) and you get a different address entirely.
Step by step
1
Extract your private key
You'll need this key later, in step 6, to operate your profile on the new chain — it's simplest to get it out of the way first. Unlock the Universal Profile browser extension, click the gear icon (Settings) top-right, scroll all the way down to the Developer section, and click Reveal private key. Enter your extension password when asked, and the key is shown as plain text.
Settings → scroll to "Developer" → "Reveal private key".
This key is your profile. Whoever has it owns your Universal Profile — on LUKSO and on every chain where you redeploy it — and can move every asset it holds, change its controllers and lock you out. There is no recovery and no one can reverse it.
- Never type or paste it into a website — including this one and the tools linked here: none of them will ever ask for it. The only place it goes is the "import account" screen of your own wallet, in step 6.
- Never send it to anyone: not in chat, email, Telegram, Discord or support tickets. Real support (ours included) will never ask for a private key, seed phrase or backup password — anyone who does is trying to steal your funds.
- Don't store it in plain text: no screenshots, photos, notes apps, documents, cloud drives or messages to yourself. Keep it only in a password manager or offline (on paper, in a safe place).
- Handle it on a trusted device only: not on a shared or work computer, and not with screen sharing or remote-desktop sessions open. After copying it, clear the clipboard (copy something else) and close the extension panel.
- If you think it has been exposed, act immediately: move your assets to a safe account and replace the compromised controller (add a new one, then remove the old one) on LUKSO and on every chain where the profile exists — each chain has its own permissions, a fix on one does not protect the others. If the exposed key is the genesis key, this is not enough: on the networks where the profile does not exist yet, whoever holds the key can deploy it first (the creation data is public) and it is born controlled by them. Those addresses cannot be protected any more: do not send anything to the profile on a network where you have not deployed it yourself.
2
Connect your UP to the Deploy tool
Open the Deploy tool and click Connect your Universal Profile in panel 2. Approve the connection in the extension popup: this only reads your address, it never asks for a private key.
The tool then does the rest by itself: it fills in your address as the "expected address", fetches your UP's deployment calldata (the original creation transaction, public on-chain data) from the LUKSO explorer, and checks that it produces exactly your address. Nothing to copy or paste.
Once connected, your UP's address appears here and the calldata is fetched and checked against it ("Calldata fetched from the LUKSO explorer and verified"). The screenshots use an example profile: yours shows your own address.
If the automatic fetch fails: find the calldata by hand
Find your UP's original creation transaction
Open your UP's address on the LUKSO mainnet explorer, on its Details tab. Find the Creator row — it shows the creator's address "at txn" followed by a transaction hash. Click that transaction hash link: it takes you straight to the creation transaction.
On the Details tab, the "at txn" link next to Creator is the shortcut straight to the creation transaction — no need to scroll through the transaction list.
Once you're on that transaction's page, switch to its Raw trace tab.
The creation transaction: method deployERC1167Proxies, sent to the factory address. Open "Raw trace" from here.
This is public on-chain data. You don't need your wallet's backup file or any decryption to get it — anyone can look up any UP's creation transaction.
Copy the transaction's input data
In the raw trace, find the call field (the raw hex, starting with 0x6a66a753...). Copy the whole string. This is your deployment calldata.
Tip: double-click anywhere on the hex string to select it entirely, then copy — much faster than dragging to select such a long string.
The raw trace: the call field is the deployment calldata.
3
Check the controller
The calldata is filled in automatically after you connect (otherwise, paste the one you found by hand in step 2). It will show you the address this calldata predicts for your UP on any chain, and — critically — it will decode and display every controller named in the calldata, including which one gets ALL_PERMISSIONS.
The tool separates known system infrastructure (green) from the actual controller with ALL_PERMISSIONS (red) — that second one is what you need to hold the key for.
Compare the predicted address to your actual UP address on LUKSO. They must match exactly before you go any further. The tool already checks this and blocks a deploy that does not match: if they don't match, stop and re-check step 2.
4
Confirm it's the controller shown by your extension
The tool shows the address that receives ALL_PERMISSIONS — this is called the controller address, because it's the account that will control the profile after the deploy. The check to make here isn't generically "does this match the key I extracted" — it's whether this is the same account that your Universal Profile browser extension itself labels as the controller for this profile, and that this is the very account you extracted the private key from in step 1 (not a different one also sitting in the extension). If your Universal Profile has ever had more than one controller connected to it over time (for example, from reinstalling a wallet extension, or connecting a new device), make sure it's this specific controller — the one the extension shows for this profile — not just "a" controller that currently has access. They can look functionally identical (same permissions) while only one of them reproduces the same address on another chain.
Cross-check: the ALL_PERMISSIONS address the tool found matches the address your own wallet extension shows as the controller of this specific profile — same string, character for character.
If the address doesn't match the controller shown by your extension, stop here. Proceeding without the right key means deploying a profile you won't be able to operate.
5
Deploy on the destination chain
Still on the Deploy tool: choose the destination network in panel 1, connect any wallet to pay gas in panel 3 (it does not need to be the controller — it only pays the transaction fee), then press Verify and Deploy in panel 4. The tool verifies the predicted address again, checks nothing already exists there, estimates gas, and — after the transaction confirms — verifies the deployed bytecode matches exactly before calling it a success.
Panel 1: pick the destination network. Other networks, or your own RPC, are in the list below the buttons.
6
Operate your profile on the new chain
Import the private key you extracted in step 1 into MetaMask (or your wallet of choice) — this is standard "import account" functionality in any wallet. From there, use the Test tool to confirm the controller actually operates the profile — it writes a timestamp on-chain through the Key Manager and reads it back. Once that works, you can also use Send (panel 6) in UP Wallet to send native currency, tokens and NFTs from the profile to another address, signed by that same controller. The Identity tool shows the profile on that network next to LUKSO's and can align it (name, images, links) with one transaction.
Importing the key puts your whole profile inside that wallet. The same key also controls your profile on LUKSO, so a compromise of this wallet is a compromise of the profile everywhere.
- Import it into a dedicated wallet or browser profile, protected by a strong password, with no untrusted extensions installed — ideally not the wallet you use every day to connect to dApps.
- Before signing anything, check the network, the recipient and the amount shown in the wallet popup, not only on the page. While MetaMask is open, the page shows a box with what MetaMask must show (network, account, recipient, value, data): if anything differs, reject in MetaMask.
- Never sign requests you didn't start yourself, and disconnect sites you no longer use.
- When you no longer need to operate the profile from this wallet, remove the imported account from it.
7
Add a backup controller — in case you lose the key
The key you extracted in step 1 is your profile's genesis key: on every network where you redeploy, the profile is born controlled by that key alone. This step is about losing it, not about having it stolen: a broken computer, a key string you never saved, a forgotten password. If you lose the genesis key and no other controller has the same permissions, you are locked out of the profile on that network for good, with everything it holds. No one can fix it — not LUKSO, not us.
- What a backup is: a second account, for example another MetaMask account, with exactly the same permissions as the genesis key, added to the profile on the network. The Backup controller page adds it, signed by the genesis key, and copies its permissions. If you made the deploy with the genesis key, the same MetaMask account is already the right one.
- Yes, it is one more secret to keep: the backup's seed phrase (MetaMask creates one). Keep it apart from the genesis key: not in the same place, not in the same wallet.
- If you lose the backup: with the genesis key you add a new one, and remove the lost one (same page).
- If you lose the genesis key: with the backup you keep signing, add a new backup and remove the lost key. The only thing you lose for good is deploying on new networks: there the profile is born with the genesis key only.
- On every network, after every new deploy: each network has its own controller list, and a new network starts without the backup. On LUKSO, add it with LUKSO's own tools.
- The Test and UP Wallet pages show a warning when the profile has no backup on the selected network; the Identity page lists the controllers and says whether the backup is there.
- If you use gas paid by the site: each controller that should sign those operations needs the 4337 permission. A backup added after the setup gets it automatically (the backup page copies the signer's permissions); one added before needs the setup repeated with it active, on the Gas paid by the site page.
Never accept an unrequested "upgrade to a smart account" (EIP-7702) on the account that controls the profile. An admin controller such as MetaMask is an ordinary account: delegated through EIP-7702 to a malicious contract, it would give that contract full control of the profile, with everything it holds. MetaMask's own upgrade, made knowingly, is your choice; one proposed by a site or a message is a scam. The profile itself is a contract: EIP-7702 does not apply to it.
Theft is a different problem with a different answer: if you think a key has been stolen, move the funds to a safe account right away and replace that key on every network where the profile exists (see step 1). A stolen genesis key cannot be replaced on networks where the profile does not exist yet: there, the thief can deploy it first.
💡 Funds: two addresses, both yours — don't forget the controller.
- Your UP address (the same on every chain) is your account. Send funds to it only after the deploy (step 5) and the test with the Test tool (step 6) have both succeeded, and preferably after adding the backup (step 7). If something goes wrong — the wrong controller key, a failed deploy — funds sent earlier would stay stuck at that address.
- The controller address (the account you imported into MetaMask in step 6) is the key that signs. Every operation — test, transfer, anything — costs a small fee (gas), and the controller pays it, not the UP. The exception: transfers whose gas is paid by the site, for profiles with an active subscription or on the operator's list (see "Operating without gas on the controller" below). Changes to the profile's data or controllers are always paid by the controller.
- 👉 So on the new chain send some funds to the controller too (e.g. POL on Polygon, ETH on Base or Arbitrum): at least enough for a few transactions. Without them the controller cannot sign anything, even if the UP is full.
One is a smart contract account (the UP), the other a normal wallet (the controller, an EOA): different addresses, but both under your control.
Two different connections, two different jobs — this trips people up. On the Test tool, "Connect your Universal Profile" only reads your UP's address, on LUKSO, so you don't have to copy-paste it — no signature happens there. The wallet that actually operates the profile is the second connection, the "signing wallet" (MetaMask with the imported controller key), and it must be connected to the destination chain — the network where you redeployed the profile in step 5 — not to LUKSO. It's completely normal to have both the UP extension and MetaMask active in the same browser at once: each one does a different job, on a different network. The Test tool and UP Wallet show you which network the signing wallet is currently on, right next to its address, and refuse to send anything if the wallet, the RPC and the network you selected are not the same chain — still, check it yourself before doing anything.
Your profile as a wallet, on every network: UP Wallet. On LUKSO you use your profile with the UP extension or app; on the other networks they do not reach. UP Wallet does the same job everywhere the profile exists, LUKSO included, with the same address:
- see what the profile holds and send currency, tokens and NFTs, also to a profile found by name;
- use dApps that connect with WalletConnect (marketplaces, exchanges, social apps such as hup.social): the dApp sees your profile as the account, and what you buy or receive goes to the profile. Almost all work; a few do not accept a smart contract account;
- gas is paid by your controller, or by the site where gas paid by the site is active for your profile.
What changes compared with the UP extension: you sign in MetaMask with the controller you imported in step 6, one network at a time, and before every signature the page shows in plain words what you are doing, checks it and simulates it. On the phone the same wallet is an Android app, on the computer a browser extension, both signing with a key of their own instead of MetaMask (see "Tools" below). It is experimental: start in simulation mode, with small amounts.
Sending currency, tokens and NFTs with UP Wallet (Send, panel 6). No dApp is needed: in
Settings choose the network, enter the profile and connect MetaMask with the controller (panels 1–3); once the check is green,
Send sends from the profile.
- Finding what the profile holds. Panel 6 lists it by itself: the currency, the tokens and NFTs registered in the profile, and the others from an external index (Alchemy; Blockscout where Alchemy does not cover the network). Tap a row to choose it; for an NFT the IDs the profile holds appear as buttons. If something is missing, paste the contract address yourself: you find it on the network's explorer, on your profile's page (tokens or NFTs tab), or on the marketplace, together with the token ID. All fills in the whole balance.
- The list is only a shortcut. Before the confirmation window, the page reads everything again from the chain: what the contract is (ERC-20, ERC-721, ERC-1155, LSP7, LSP8), your balance or the NFT's owner, and a simulation of the transfer. After the send it reads the result again. An index can be incomplete or late; the chain is what counts.
- "Flagged as spam" comes from the index, not from these tools. Anyone can send tokens and NFTs to any address, often with a link or a website in their name to lure you. The index marks what it considers spam, but it can be wrong both ways: popular legitimate collections with millions of holders (Basenames, for example) can be flagged. Flagged tokens are hidden behind a button and can still be sent away. Judge for yourself: never visit links or sites advertised in a token's name, and ignore tokens you did not ask for.
- The recipient must be able to receive what you send. ERC-721 and ERC-1155 NFTs use the "safe" transfer: if the recipient is a contract that cannot accept them, the simulation fails and nothing is sent. A profile redeployed on another chain needs NFT reception first. For an exchange deposit address, check that the exchange supports that token on that network. The recipient can also be found by Universal Profile name.
- Permissions. Native currency needs TRANSFERVALUE on the controller; tokens and NFTs need CALL. The page tells you if one is missing.
Operating without gas on the controller (experimental). The site can pay the gas of your profile's transfers: the controller only signs a message, the site's relayer sends, and the site's paymaster pays. It is available on Base, Arbitrum, Polygon, Avalanche and Arc, for profiles with an active subscription (or on the operator's list). The subscription is in
beta: it may change or be suspended, and its final terms are not published yet, so pay only small amounts.
- 1 · Set up the profile, once per network: on the Gas paid by the site page, the controller signs one setup transaction (it pays a little gas this one time). The setup lets the ERC-4337 EntryPoint call contracts and send value for the profile, never change its data or controllers. A button turns it off again with one transaction. Its section 2 checks everything by itself, read-only and without a wallet, and its last line says whether the site already pays this profile's gas.
- 2 · Subscribe: on the Subscription page the profile pays 5 USDC (Circle's native USDC, on Base, Arbitrum, Polygon, Avalanche or Arc), and the site pays the gas of that payment too. The 5 USDC become one balance, valid on every network of the service. Each operation the site pays takes that network's price: 0.01 USDC on Base and Arc, 0.02 on Polygon and Avalanche, 0.03 on Arbitrum. The balance is activated after the payment is checked, and you get an e-mail.
- Balance and top-ups: enter the profile on the Subscription page to see its balance, with no wallet. Top up on the same page, with another 5 USDC. You get an e-mail when the balance goes down to 2.5, 1 and 0.5 USDC. Nothing is ever charged automatically.
- Every operation: in UP Wallet (dApp requests and sends from panel 6) the option "Pay the gas with the site relayer" appears by itself when the profile is ready on the chosen network, with the balance and the price. The controller signs a message in MetaMask (no gas). It works for transfers and dApp transactions; writing data or changing controllers always needs gas on the controller.
Your funds depend on the controller key, on every network.
- Whoever holds the controller key controls the profile, with or without gas paid by the site: the key in MetaMask and in the UP extension is a hot key, exposed like any wallet connected to the internet. Keep on the profile only what you are prepared to lose if that key were stolen, or move the controller to a hardware wallet (see below).
- One key controls the profile at the same address on every network: if it is stolen, all of them are exposed at once.
- The genesis key can never be retired for new networks. Every redeploy replays your profile's original creation, so on every new network the profile is born controlled by that key alone, whatever you changed elsewhere. Losing it means no more deploys on new networks, and, without a backup, losing the profile on every network (step 7). If it is stolen, the thief can deploy the profile first on any network where it does not exist yet.
- Two setups, your choice. (A) The genesis key is your everyday controller, for example your main MetaMask account, and the backup stays aside. (B) The genesis key stays offline and a second controller, for example a hardware wallet, is used every day. Offline means really offline: the key also stays in the UP extension (it is the profile's controller there), so in setup (B) remove it from MetaMask and keep the extension only on a computer you trust. Either way, a backup exists only when a second controller has the same permissions: a daily controller with fewer permissions is not a backup.
- Every extra controller is one more key that could be stolen: keep the backup offline and use it only to recover.
- Gas paid by the site adds one specific risk: none of its contracts has had a professional audit, neither LUKSO's extension (
Extension4337, which LUKSO describes as experimental) nor the site's paymasters. AI-assisted reviews found no serious issue; the details are in the project's AUDIT.md, sections 8 and 10. Keep small balances, on the profile and in the subscription.
What these tools do — and don't do
- They never ask for a private key. The only thing you paste in is calldata — public on-chain data.
- Signing always happens in your own wallet (MetaMask or similar). These pages only prepare the transaction and hand it to your wallet for approval.
- They perform address and bytecode verification automatically, so a mistake in the calldata is caught before you sign, not after.
- They check that the signing wallet, the RPC and the selected network are the same chain before every transaction, and invalidate a previous check as soon as you change any input.
- They don't manage your keys, your backups, or your security — that responsibility stays entirely with you. If you're not confident distinguishing your own controllers or reading a block explorer, get help from someone who is before proceeding.
This is irreversible, self-directed on-chain activity. No one — including the tools linked here — can undo a deployment or a transfer once confirmed. Use a small amount of funds to test first, on a network where mistakes are cheap.
Tools
- Deploy — decode calldata, verify, and deploy a Universal Profile at its predicted address on another chain. At the end it links to the backup page.
- Backup controller — add a backup controller, or remove a lost one, on any network where the profile exists, LUKSO included. It also authorizes a device key, the UP Wallet app's phone key or the browser extension's computer key, with no admin permissions, and revokes it. Every controller can have a name ("Office PC · extension", "MetaMask backup"), kept on the profile on each network, so you recognize it from every device.
- Authorize a device on LUKSO (experimental) — for a profile used only on LUKSO: authorizes the UP Wallet app's or extension's key, signing with LUKSO's own wallet (the Universal Profile extension, or the Universal Profiles app), with no MetaMask and no key to extract. The full path, from the new profile to the first signature, is in the ChainIntegrate onboarding.
- Verify only — check whether a deploy already exists on another chain. It only reads public data from an RPC: no wallet is required, but you can optionally connect your Universal Profile to auto-fill the address it checks for, instead of typing it by hand.
- Test — confirm your controller can operate the deployed profile.
- Identity — the profile on another network, compared with LUKSO: name, images and links, what it holds (native currency, tokens and NFTs, with their images), who controls it and whether there is a backup, and what it can do there (receive NFTs, gas relay). Reading needs no wallet. Section 6 aligns the profile with LUKSO's, with one transaction signed by your controller.
- Publish implementation — if the Verify or Deploy tool reports that your profile's LSP0 or Key Manager implementation is missing on the target chain, publish it there at the same address, by replaying LUKSO's original deterministic deploy. Anyone can do it; it only costs gas.
- UP Wallet (experimental) — your profile's wallet on LUKSO and on every network where you redeployed it, with the same address: see what it holds, send currency, tokens and NFTs, and use dApps through WalletConnect with the profile as your account. The page checks that profile and controller are compatible, shows and simulates every request, and signs only after your confirmation. The profile's card says whether requests are only simulated and who pays the gas (the site or your controller): tap either to change it. "Every network" shows what the profile holds on each network where it exists, with an estimated total in dollars. Start in simulation mode, with small amounts.
- UP Wallet for Android (prototype, in testing) — the same UP Wallet as an Android app, for using the profile on dApps from the phone and sending from it. From version 0.9.0 the app signs by itself, with a key it creates on the phone and never lets out (encrypted with the Android Keystore, unlocked with your fingerprint or PIN for every signature): no MetaMask and no other wallet. Authorize that key once on each network from the Backup controller page, "Authorize a device" (no admin permissions: it cannot change controllers or permissions, but it can use all the UP's funds); a lost phone is revoked from the same page, and the panel "This phone" sends the key's own balance (what it pays gas with) to the profile before that. It is the maintainer's experimental wallet, with a higher risk than an external wallet: small amounts. dApps connect with a WalletConnect link pasted in the app or shared to it, or with its QR code scanned from another screen; a notification tells you when a dApp sends a request, and a button takes you back to the dApp once it has its answer. What the app keeps and which services it talks to: privacy policy; the code is on GitHub.
- Download: on the phone, open the releases page: the newest version is at the top; under "Assets" tap the file
up-wallet-v….apk.
- Install: open the downloaded file. The app is not on the Play Store, so the first time Android says it can't install apps from this source (for example Chrome) and offers Settings: tap it, turn on "Allow from this source" for that app, then go back and the install goes on. You can turn it off again afterwards; you'll need it again at the next update. If Play Protect says the app is unknown or not verified, tap "More details" and then "Install anyway". At an update Play Protect may first offer to scan the app: let it, it says the app looks safe and the update goes on (Google checks this way the apps of developers it has not verified yet).
- Update: install the newer APK over the old one, the same way: settings and sessions are kept. Every version is signed with the same key, so Android refuses an APK from anyone else as an update.
- What deletes the phone key (it has no copy, and app data are not backed up): uninstalling the app, even to install it again (never uninstall to update: install over it); clearing the app's data in Android's settings; removing the screen lock (Android then makes the key unusable for good, and the app says so; on some phones changing its type does too); a factory reset of the phone. Before any of these, send the key's balance to the profile ("This phone") and revoke the key from the Backup page; afterwards, create a new key and authorize it again. A changed fingerprint does not delete it.
- UP Wallet for the browser (prototype, in testing) — the same UP Wallet as a desktop browser extension, for Chrome, Edge and Brave: the profile on dApps from the computer without MetaMask. The extension creates a key of its own, kept only encrypted and opened with a passkey (Windows Hello, Google Password Manager, a phone or a security key) or a password, for every signature, in a small signing window that shows what is signed. Authorize it once on each network from the Backup controller page, "Authorize a device", as the phone's (no admin permissions, but access to all the UP's funds); the extension's panel "This computer" opens that page with its address filled in. dApps connect with WalletConnect and stay connected with the wallet closed, while the browser runs: a request opens the wallet by itself. The panel "This computer" also shows the key's own balance (what it pays gas with when the site does not), which "Send the key's balance to the UP" moves to the profile: do it before revoking or deleting a key, since a lost key has no copy. It is the maintainer's experimental wallet: small amounts. The code is on GitHub.
- Install: from the releases page download
up-wallet-extension-v….zip (not "Source code") and unzip it into a folder you keep for good, for example Documents\UP-Wallet-Extension, not in Downloads (a clean-up of Downloads would take it away and the extension would stop working); in chrome://extensions turn on "Developer mode", press "Load unpacked" and choose that folder. To update, unzip the new version over the same folder (in Windows' "Extract all", the destination is that folder itself, not a new one inside it), then in chrome://extensions press "Load unpacked" again and choose the same folder: the extension keeps its id, so the key stays. The reload button alone may keep the old version. Check the version on the extension's card, then close and reopen the wallet. Never remove the extension to update it: removing it deletes its key, which has no copy (you would need a new key, authorized again on every network, and the old one revoked). If the folder was deleted by mistake, the key is still in the browser (it is kept with the extension, not in the folder): do not press "Remove" on the error; unzip the same version again into the same folder and press "Load unpacked" on it.
- One key per device, by choice: every computer and every phone has its own key, never exported or copied. A new device means a new key and one "Authorize a device" (MetaMask, once per network): a lost device is revoked alone, and the others keep working.
- NFT reception (experimental) — lets the redeployed profile receive ERC-721 / ERC-1155 NFTs (for example purchases on marketplaces), with one transaction that leaves the controller's permissions unchanged.
- Gas paid by the site (experimental) — set up the profile, once per network, so that the site can pay its gas: one controller transaction, which a button undoes. Includes a read-only configuration check that also says whether the site pays this profile's gas.
- Subscription (experimental) — subscribe to gas paid by the site, or top up: 5 USDC paid from the profile, one balance for every network, a price per operation by network. Shows the balance as soon as you enter the profile.
Recap, step by step
- Check whether the profile already exists on the target network: Verify only.
- Only if Verify or Deploy says an implementation is missing on the network: Publish implementation.
- Deploy the profile at the same address (the page fetches and checks the creation calldata): Deploy.
- Check the result: Verify only again.
- Add a backup controller: Backup controller.
- Try an operation with your controller (the key from step 1 above): Test.
- Align the profile (name, images, links) with LUKSO: Identity, section 6.
- Let the profile receive ERC-721 / ERC-1155 NFTs: NFT receiving.
- Gas paid by the site, if you want it: set up the profile with Gas paid by the site, then subscribe on Subscription.
- Use the profile: UP Wallet (or the Android app).
Replicare una Universal Profile su altre chain EVM
Come deployare la tua Universal Profile LUKSO esistente allo stesso identico indirizzo su un'altra rete EVM — e perché funziona.
Di cosa si tratta. La tua Universal Profile (UP) è stata creata su LUKSO tramite un contratto factory deterministico. Poiché la factory è deployata allo stesso indirizzo su ogni rete EVM, ripetere esattamente la transazione di creazione originale su un'altra rete produce un contratto allo stesso indirizzo anche lì. Questa pagina spiega il meccanismo e guida attraverso il procedimento in sicurezza, usando gli strumenti collegati in fondo.
È una procedura tecnica. Presuppone dimestichezza con MetaMask, gli smart contract e la lettura di un block explorer. Non è un flusso consumer "a un click" e non va trattata come tale.
Come viene generato davvero l'indirizzo
Non è una semplice funzione di "controller + salt". La tua UP è stata creata tramite LSP23LinkedContractsFactory di LUKSO, deployata allo stesso indirizzo (0x2300000A84D25dF63081feAa37ba6b62C4c89a30) su ogni rete dove LUKSO l'ha pubblicata. La chiamata alla factory include:
- un salt iniziale,
- l'implementazione e i dati di inizializzazione del Key Manager (il secondo contratto collegato),
- l'indirizzo di un post-deployment module e la sua calldata — è qui che viene effettivamente specificato quale indirizzo riceve
ALL_PERMISSIONS sul nuovo profilo.
Tutto questo viene hashato insieme (keccak256) per formare il salt reale usato in CREATE2, combinato con l'hash del bytecode minimal-proxy che punta all'implementazione della Universal Profile. L'indirizzo risultante dipende dall'intera transazione originale — non da un singolo campo isolato.
Per questo solo la calldata originale esatta riproduce lo stesso indirizzo: il controller con il controllo totale non ha nulla di speciale in sé — è semplicemente l'indirizzo che quella specifica calldata già nomina. Cambiare la calldata (anche solo per nominare un controller diverso) produce un indirizzo completamente diverso.
Passo per passo
1
Estrai la tua chiave privata
Ti servirà più avanti, al passo 6, per operare il profilo sulla nuova rete — conviene toglierla di mezzo subito. Sblocca l'estensione Universal Profile, clicca sull'icona a rotella (Settings) in alto a destra, scorri fino in fondo alla sezione Developer e clicca Reveal private key. Inserisci la password dell'estensione quando richiesto: la chiave viene mostrata in chiaro.
Settings → scorri fino a "Developer" → "Reveal private key".
Questa chiave è il tuo profilo. Chi la possiede controlla la tua Universal Profile — su LUKSO e su ogni rete dove la rideployi — e può spostare tutti gli asset, cambiarne i controller e chiuderti fuori. Non esiste recupero e nessuno può annullare l'operazione.
- Non digitarla né incollarla mai in un sito web — compreso questo e gli strumenti collegati: nessuno di essi te la chiederà mai. L'unico posto dove va inserita è la schermata "importa account" del tuo wallet, al passo 6.
- Non inviarla mai a nessuno: né in chat, email, Telegram, Discord o ticket di assistenza. La vera assistenza (compresa la nostra) non chiederà mai una chiave privata, una seed phrase o una password di backup — chi lo fa sta cercando di rubarti i fondi.
- Non conservarla in chiaro: niente screenshot, foto, app di note, documenti, cloud o messaggi a te stesso. Tienila solo in un password manager oppure offline (su carta, in un luogo sicuro).
- Maneggiala solo su un dispositivo fidato: non su un computer condiviso o di lavoro, e senza condivisione schermo o sessioni di desktop remoto aperte. Dopo averla copiata, svuota gli appunti (copia qualcos'altro) e chiudi il pannello dell'estensione.
- Se pensi che sia stata esposta, agisci subito: sposta gli asset su un account sicuro e sostituisci il controller compromesso (aggiungine uno nuovo, poi rimuovi quello vecchio) su LUKSO e su ogni rete dove esiste il profilo — ogni rete ha i propri permessi, sistemarne una non protegge le altre. Se la chiave esposta è la chiave di genesi, non basta: sulle reti dove il profilo non esiste ancora, chi ha la chiave può deployarlo per primo (i dati di creazione sono pubblici) e lì nasce controllato da lui. Quegli indirizzi non si possono più proteggere: non inviare niente al profilo su una rete dove non l'hai deployato tu.
2
Connetti la tua UP allo strumento di Deploy
Apri la pagina di Deploy e clicca Connetti la tua Universal Profile nel pannello 2. Approva la connessione nel popup dell'estensione: legge solo il tuo indirizzo, non chiede mai una chiave privata.
Poi la pagina fa il resto da sola: compila il tuo indirizzo come "indirizzo atteso", recupera dall'explorer di LUKSO la calldata di deploy della tua UP (la transazione di creazione originale, dato pubblico on-chain) e controlla che produca esattamente il tuo indirizzo. Niente da copiare o incollare.
Una volta connesso, l'indirizzo della tua UP compare qui e la calldata viene recuperata e confrontata con esso ("Calldata recuperata dall'explorer di LUKSO e verificata"). Le immagini usano un profilo di esempio: nella tua vedi il tuo indirizzo.
Se il recupero automatico non riesce: trova la calldata a mano
Trova la transazione di creazione originale della tua UP
Apri l'indirizzo della tua UP sull'explorer di LUKSO mainnet, nella scheda Details. Trova la riga Creator — mostra l'indirizzo del creatore "at txn" seguito da un hash di transazione. Clicca su quel link dell'hash: ti porta direttamente alla transazione di creazione.
Nella scheda Details, il link "at txn" accanto a Creator è la scorciatoia diretta alla transazione di creazione — non serve scorrere l'elenco delle transazioni.
Una volta sulla pagina di quella transazione, passa alla scheda Raw trace.
La transazione di creazione: metodo deployERC1167Proxies, inviata all'indirizzo della factory. Da qui apri "Raw trace".
È dato pubblico on-chain. Non serve il file di backup del wallet né alcuna decrittazione per ottenerlo — chiunque può consultare la transazione di creazione di qualunque UP.
Copia l'input data della transazione
Nel raw trace, trova il campo call (l'esadecimale grezzo, che inizia con 0x6a66a753...). Copia l'intera stringa. Questa è la tua calldata di deploy.
Consiglio: fai doppio click in un punto qualsiasi della stringa esadecimale per selezionarla tutta, poi copia — molto più rapido che trascinare per selezionare una stringa così lunga.
Il raw trace: il campo call è la calldata di deploy.
3
Controlla il controller
La calldata viene compilata in automatico dopo la connessione (altrimenti incolla quella trovata a mano al passo 2). Ti mostrerà l'indirizzo che questa calldata predice per la tua UP su qualsiasi rete e — punto cruciale — decodificherà e mostrerà ogni controller nominato nella calldata, incluso chi riceve ALL_PERMISSIONS.
Lo strumento separa l'infrastruttura di sistema nota (verde) dal vero controller con ALL_PERMISSIONS (rosso) — di quest'ultimo devi possedere la chiave.
Confronta l'indirizzo predetto con l'indirizzo reale della tua UP su LUKSO. Devono coincidere esattamente prima di andare oltre. La pagina lo controlla già e blocca un deploy che non coincide: se non coincidono, fermati e ricontrolla il passo 2.
4
Conferma che sia il controller indicato dalla tua estensione
Lo strumento mostra l'indirizzo che riceve ALL_PERMISSIONS — si chiama indirizzo del controller, perché è l'account che controllerà il profilo dopo il deploy. Il confronto da fare non è genericamente "corrisponde alla chiave che ho estratto" — è se questo è lo stesso account che la tua estensione del browser Universal Profile indica esplicitamente come controller di questo profilo, e che sia proprio quell'account (non un altro presente nell'estensione) da cui hai estratto la chiave privata al passo 1. Se la tua Universal Profile ha mai avuto più di un controller collegato nel tempo (ad esempio dopo aver reinstallato un'estensione wallet, o collegato un nuovo dispositivo), assicurati che sia proprio questo controller — quello che l'estensione mostra per questo profilo — non semplicemente "un" controller che al momento ha accesso. Possono sembrare funzionalmente identici (stessi permessi) mentre solo uno dei due riproduce lo stesso indirizzo su un'altra rete.
Riscontro incrociato: l'indirizzo con ALL_PERMISSIONS trovato dallo strumento corrisponde all'indirizzo che la tua estensione wallet mostra come controller di questo specifico profilo — stessa stringa, carattere per carattere.
Se l'indirizzo non corrisponde al controller indicato dalla tua estensione, fermati qui. Andare avanti senza la chiave giusta equivale a deployare un profilo che non potrai gestire.
5
Deploya sulla rete di destinazione
Sempre sulla pagina di Deploy: scegli la rete di destinazione nel pannello 1, collega un wallet qualsiasi per pagare il gas nel pannello 3 (non deve essere il controller — paga solo la commissione della transazione), poi premi Verifica e Deploy nel pannello 4. Lo strumento riverifica l'indirizzo predetto, controlla che non esista già nulla lì, stima il gas e — dopo la conferma della transazione — verifica che il bytecode deployato corrisponda esattamente prima di dichiarare il successo.
Pannello 1: scegli la rete di destinazione. Altre reti, o un tuo RPC, sono nell'elenco sotto i pulsanti.
6
Opera il tuo profilo sulla nuova rete
Importa in MetaMask (o nel wallet che preferisci) la chiave privata estratta al passo 1 — è la normale funzione "importa account" di qualsiasi wallet. Da lì usa la pagina di Test per confermare che il controller operi davvero il profilo — scrive un timestamp on-chain tramite il Key Manager e lo rilegge. Una volta verificato, puoi anche usare Invia (pannello 6) in UP Wallet per inviare valuta nativa, token e NFT dal profilo a un altro indirizzo, firmato dallo stesso controller. La pagina Identità mostra il profilo su quella rete accanto a quello di LUKSO e può allinearlo (nome, immagini, link) con una transazione.
Importare la chiave significa mettere l'intero profilo dentro quel wallet. La stessa chiave controlla il tuo profilo anche su LUKSO: se quel wallet viene compromesso, il profilo è compromesso ovunque.
- Importala in un wallet o profilo del browser dedicato, protetto da una password robusta e senza estensioni non affidabili — possibilmente non il wallet che usi ogni giorno per collegarti alle dApp.
- Prima di firmare qualsiasi cosa, controlla rete, destinatario e importo mostrati nel popup del wallet, non solo sulla pagina. Mentre MetaMask è aperto, la pagina mostra un riquadro con quello che MetaMask deve mostrare (rete, account, destinatario, valore, dati): se qualcosa è diverso, rifiuta in MetaMask.
- Non firmare mai richieste che non hai avviato tu, e scollega i siti che non usi più.
- Quando non ti serve più operare il profilo da quel wallet, rimuovi l'account importato.
7
Aggiungi un controller di backup — nel caso perdi la chiave
La chiave che hai estratto al passo 1 è la chiave di genesi del tuo profilo: su ogni rete dove rifai il deploy, il profilo nasce controllato solo da quella chiave. Questo passo riguarda la perdita, non il furto: un computer rotto, una stringa mai salvata, una password dimenticata. Se perdi la chiave di genesi e nessun altro controller ha gli stessi permessi, resti fuori dal profilo su quella rete per sempre, con tutto quello che contiene. Nessuno può rimediare — né LUKSO né noi.
- Cos'è un backup: un secondo account, per esempio un altro account MetaMask, con esattamente gli stessi permessi della chiave di genesi, aggiunto al profilo sulla rete. Lo aggiunge la pagina del controller di backup, con la firma della chiave di genesi, copiandone i permessi. Se hai fatto il deploy con la chiave di genesi, lo stesso account MetaMask è già quello giusto.
- Sì, è un segreto in più da custodire: la seed del backup (MetaMask ne crea una). Tienila separata dalla chiave di genesi: non nello stesso posto, non nello stesso wallet.
- Se perdi il backup: con la chiave di genesi ne aggiungi un altro e rimuovi quello perso (stessa pagina).
- Se perdi la chiave di genesi: con il backup continui a firmare, aggiungi un nuovo backup e rimuovi la chiave persa. L'unica cosa che perdi per sempre è il deploy su reti nuove: lì il profilo nasce solo con la chiave di genesi.
- Su ogni rete, dopo ogni nuovo deploy: ogni rete ha la sua lista di controller, e una rete nuova parte senza backup. Su LUKSO aggiungilo con gli strumenti di LUKSO.
- Le pagine Test e UP Wallet mostrano un avviso quando il profilo non ha un backup sulla rete scelta; la pagina Identità elenca i controller e dice se il backup c'è.
- Se usi il gas pagato dal sito: ogni controller che deve firmare quelle operazioni ha bisogno del permesso 4337. Un backup aggiunto dopo la configurazione lo riceve da solo (la pagina del backup copia i permessi di chi firma); uno aggiunto prima ha bisogno di ripetere la configurazione con lui attivo, nella pagina Gas pagato dal sito.
Non accettare mai un "upgrade a smart account" (EIP-7702) non richiesto sull'account che controlla il profilo. Un controller amministratore come MetaMask è un account normale: delegato con EIP-7702 a un contratto malevolo, darebbe a quel contratto il pieno controllo del profilo, con tutto quello che contiene. L'upgrade di MetaMask, fatto consapevolmente, è una tua scelta; uno proposto da un sito o da un messaggio è una truffa. Il profilo invece è un contratto: EIP-7702 non lo riguarda.
Il furto è un altro problema, con un'altra risposta: se pensi che una chiave ti sia stata rubata, sposta subito i fondi su un account sicuro e sostituisci quella chiave su ogni rete dove esiste il profilo (vedi il passo 1). Una chiave di genesi rubata non si può sostituire sulle reti dove il profilo non esiste ancora: lì il ladro può deployarlo per primo.
💡 I fondi: due indirizzi, tutti e due tuoi — non dimenticare il controller.
- L'indirizzo della tua UP (uguale su tutte le reti) è il tuo conto. Mandaci fondi solo dopo che il deploy (passo 5) e il test con la pagina di Test (passo 6) sono andati entrambi a buon fine, e meglio ancora dopo aver aggiunto il backup (passo 7). Se qualcosa va storto — chiave del controller sbagliata, deploy fallito — i fondi mandati prima resterebbero bloccati a quell'indirizzo.
- L'indirizzo del controller (l'account che hai importato in MetaMask al passo 6) è la chiave che firma. Ogni operazione — test, invio, qualsiasi cosa — costa una piccola commissione (gas), e la paga il controller, non la UP. L'eccezione: i trasferimenti il cui gas lo paga il sito, per i profili con un'iscrizione attiva o nella lista del gestore (vedi "Operare senza gas sul controller" più sotto). Le modifiche ai dati o ai controller del profilo le paga sempre il controller.
- 👉 Quindi sulla nuova rete manda un po' di fondi anche al controller (es. POL su Polygon, ETH su Base o Arbitrum): almeno quanto basta per qualche transazione. Senza, il controller non può firmare nulla, anche se la UP è piena.
Uno è un account smart contract (la UP), l'altro un normale wallet (il controller, un EOA): indirizzi diversi, ma tutti e due sotto il tuo controllo.
Due collegamenti diversi, due compiti diversi — qui è facile confondersi. Nella pagina di Test, "Connetti la tua Universal Profile" serve solo a leggere l'indirizzo della tua UP, su LUKSO, così non devi copiarlo a mano — nessuna firma avviene in quel passaggio. Il wallet che opera davvero il profilo è il secondo collegamento, il "wallet firmatario" (MetaMask con la chiave del controller importata), e deve essere connesso alla rete di destinazione — quella dove hai rideployato il profilo al passo 5 — non a LUKSO. È del tutto normale avere sia l'estensione UP che MetaMask attivi insieme nello stesso browser: ognuno fa un lavoro diverso, su una rete diversa. La pagina di Test e UP Wallet mostrano su quale rete è connesso in questo momento il wallet firmatario, accanto al suo indirizzo, e si rifiutano di inviare qualsiasi cosa se wallet, RPC e rete selezionata non sono la stessa chain — controlla comunque tu stesso prima di fare qualsiasi cosa.
Il tuo profilo come wallet, su ogni rete: UP Wallet. Su LUKSO usi il profilo con l'estensione o l'app UP; sulle altre reti quelle non arrivano. UP Wallet fa lo stesso lavoro ovunque il profilo esista, LUKSO compresa, con lo stesso indirizzo:
- vedi cosa possiede il profilo e invii valuta, token e NFT, anche a un profilo cercato per nome;
- usi le dApp che si collegano con WalletConnect (marketplace, exchange, social come hup.social): la dApp vede il tuo profilo come account, e quello che compri o ricevi arriva al profilo. Quasi tutte funzionano; qualcuna non accetta un account smart contract;
- il gas lo paga il tuo controller, oppure il sito dove il gas pagato dal sito è attivo per il tuo profilo.
Cosa cambia rispetto all'estensione UP: firmi in MetaMask con il controller che hai importato al passo 6, una rete alla volta, e prima di ogni firma la pagina ti mostra in chiaro cosa stai facendo, lo controlla e lo simula. Sul telefono lo stesso wallet è un'app Android, sul computer un'estensione del browser, che firmano entrambe con una propria chiave invece che con MetaMask (vedi "Strumenti" più sotto). È sperimentale: parti in modalità simulazione, con importi piccoli.
Inviare valuta, token e NFT con UP Wallet (Invia, pannello 6). Non serve una dApp: in
Impostazioni scegli la rete, inserisci il profilo e collega MetaMask con il controller (pannelli 1–3); quando la verifica è verde,
Invia invia dal profilo.
- Trovare cosa possiede il profilo. Il pannello 6 lo elenca da solo: la valuta, i token e gli NFT registrati nel profilo, e gli altri da un indice esterno (Alchemy; Blockscout dove Alchemy non copre la rete). Tocca una riga per sceglierla; per un NFT gli ID che il profilo possiede compaiono come pulsanti. Se manca qualcosa, incolla tu l'indirizzo del contratto: lo trovi sull'explorer della rete, nella pagina del tuo profilo (scheda token o NFT), oppure sul marketplace, insieme all'ID del token. Tutto compila l'intero saldo.
- L'elenco è solo una scorciatoia. Prima della finestra di conferma, la pagina rilegge tutto dalla blockchain: che contratto è (ERC-20, ERC-721, ERC-1155, LSP7, LSP8), il tuo saldo o il proprietario dell'NFT, e una simulazione del trasferimento. Dopo l'invio rilegge il risultato. Un indice può essere incompleto o in ritardo; conta la blockchain.
- "Segnalato come spam" lo dice l'indice, non questi strumenti. Chiunque può mandare token e NFT a qualsiasi indirizzo, spesso con un link o un sito nel nome per attirarti. L'indice segna quello che ritiene spam, ma può sbagliare in entrambi i sensi: collezioni legittime e popolari con milioni di proprietari (Basenames, per esempio) possono essere segnalate. I token segnalati sono nascosti dietro un pulsante e si possono comunque inviare via. Valuta tu: non visitare mai link o siti pubblicizzati nel nome di un token, e ignora i token che non hai chiesto.
- Il destinatario deve poter ricevere quello che invii. Gli NFT ERC-721 ed ERC-1155 usano il trasferimento "safe": se il destinatario è un contratto che non li accetta, la simulazione fallisce e non parte nulla. Un profilo rideployato su un'altra rete ha prima bisogno della ricezione NFT. Per un indirizzo di deposito di un exchange, controlla che l'exchange supporti quel token su quella rete. Il destinatario si può cercare anche per nome della Universal Profile.
- Permessi. La valuta nativa richiede TRANSFERVALUE sul controller; token e NFT richiedono CALL. La pagina ti avvisa se ne manca uno.
Operare senza gas sul controller (sperimentale). Il sito può pagare il gas dei trasferimenti del tuo profilo: il controller firma soltanto un messaggio, il relayer del sito invia e il paymaster del sito paga. È disponibile su Base, Arbitrum, Polygon, Avalanche e Arc, per i profili con un'iscrizione attiva (o nella lista del gestore). L'iscrizione è in
beta: può cambiare o essere sospesa, e le sue condizioni definitive non sono ancora pubblicate, quindi paga solo importi piccoli.
- 1 · Configura il profilo, una volta per rete: nella pagina Gas pagato dal sito il controller firma una transazione di configurazione (solo questa volta paga un po' di gas). La configurazione permette all'EntryPoint ERC-4337 di chiamare contratti e inviare valore per il profilo, mai di cambiarne i dati o i controller. Un pulsante la disattiva con una sola transazione. La sua sezione 2 controlla tutto da sola, in sola lettura e senza wallet, e l'ultima riga dice se il sito paga già il gas di questo profilo.
- 2 · Iscriviti: nella pagina Iscrizione il profilo paga 5 USDC (gli USDC nativi di Circle, su Base, Arbitrum, Polygon, Avalanche o Arc), e il gas di questo pagamento lo paga il sito. I 5 USDC diventano un saldo unico, valido su tutte le reti del servizio. Ogni operazione pagata dal sito scala il prezzo della sua rete: 0,01 USDC su Base e Arc, 0,02 su Polygon e Avalanche, 0,03 su Arbitrum. Il saldo viene attivato dopo la verifica del pagamento, e ricevi un'email.
- Saldo e ricariche: inserisci il profilo nella pagina Iscrizione per vedere il saldo, senza wallet. Ricarica dalla stessa pagina, con altri 5 USDC. Ricevi un'email quando il saldo scende a 2,5, a 1 e a 0,5 USDC. Non viene mai addebitato niente in automatico.
- Ogni operazione: in UP Wallet (richieste delle dApp e invii dal pannello 6) l'opzione "Paga il gas con il relayer del sito" compare da sola quando il profilo è pronto sulla rete scelta, con il saldo e il prezzo. Il controller firma un messaggio in MetaMask (nessun gas). Vale per i trasferimenti e le transazioni delle dApp; scrivere dati o cambiare i controller richiede sempre gas sul controller.
I tuoi fondi dipendono dalla chiave del controller, su tutte le reti.
- Chi ha la chiave del controller controlla il profilo, con o senza il gas pagato dal sito: la chiave in MetaMask e nell'estensione UP è una chiave "calda", esposta come qualunque wallet collegato a internet. Tieni sul profilo solo quello che saresti disposto a perdere se quella chiave venisse rubata, oppure sposta il controller su un hardware wallet (vedi sotto).
- Una sola chiave controlla il profilo allo stesso indirizzo su tutte le reti: se viene rubata, sono esposte tutte insieme.
- La chiave di genesi non si può mai dismettere per le reti nuove. Ogni redeploy ripete la creazione originale del profilo, quindi su ogni nuova rete il profilo nasce controllato solo da quella chiave, qualunque cosa tu abbia cambiato altrove. Perderla vuol dire niente più deploy su reti nuove e, senza un backup, perdere il profilo su tutte le reti (passo 7). Se viene rubata, il ladro può deployare il profilo per primo su qualunque rete dove non esiste ancora.
- Due configurazioni, scegli tu. (A) La chiave di genesi è il controller di tutti i giorni, per esempio il tuo account MetaMask principale, e il backup sta da parte. (B) La chiave di genesi resta offline e un secondo controller, per esempio un hardware wallet, si usa tutti i giorni. Offline vuol dire davvero offline: la chiave resta anche nell'estensione UP (lì è il controller del profilo), quindi nella configurazione (B) toglila da MetaMask e tieni l'estensione solo su un computer di cui ti fidi. In entrambi i casi il backup c'è solo se un secondo controller ha gli stessi permessi: un controller quotidiano con meno permessi non è un backup.
- Ogni controller in più è una chiave in più che può essere rubata: tieni il backup offline e usalo solo per recuperare.
- Il gas pagato dal sito aggiunge un rischio specifico: nessuno dei suoi contratti ha un audit professionale, né l'estensione di LUKSO (
Extension4337, che LUKSO definisce sperimentale) né i paymaster del sito. Le revisioni assistite da AI non hanno trovato problemi gravi; i dettagli sono nel file AUDIT.md del progetto, sezioni 8 e 10. Tieni saldi piccoli, sul profilo e nell'iscrizione.
Cosa fanno questi strumenti — e cosa non fanno
- Non chiedono mai una chiave privata. L'unica cosa che incolli è la calldata — dato pubblico on-chain.
- La firma avviene sempre nel tuo wallet (MetaMask o simili). Queste pagine preparano solo la transazione e la passano al tuo wallet per l'approvazione.
- Eseguono automaticamente la verifica di indirizzo e bytecode, così un errore nella calldata viene intercettato prima della firma, non dopo.
- Prima di ogni transazione controllano che wallet firmatario, RPC e rete selezionata siano la stessa chain, e annullano una verifica precedente appena modifichi un dato.
- Non gestiscono le tue chiavi, i tuoi backup né la tua sicurezza — questa responsabilità resta interamente tua. Se non sei sicuro di distinguere i tuoi controller o di leggere un block explorer, fatti aiutare da chi lo sa fare prima di procedere.
Questa è un'attività on-chain irreversibile e autonoma. Nessuno — inclusi gli strumenti qui collegati — può annullare un deploy o un trasferimento una volta confermato. Prova prima con un importo piccolo, su una rete dove gli errori costano poco.
Strumenti
- Deploy — decodifica la calldata, verifica e deploya una Universal Profile all'indirizzo predetto su un'altra rete. Alla fine rimanda alla pagina del backup.
- Controller di backup — aggiunge un controller di backup, o rimuove uno perso, su qualsiasi rete dove il profilo esiste, LUKSO compresa. Autorizza anche la chiave di un dispositivo, quella del telefono dell'app UP Wallet o quella del computer dell'estensione del browser, senza permessi di amministrazione, e la revoca. Ogni controller può avere un nome ("PC ufficio · estensione", "MetaMask backup"), salvato sul profilo su ogni rete, per riconoscerlo da ogni dispositivo.
- Autorizza un dispositivo su LUKSO (sperimentale) — per un profilo usato solo su LUKSO: autorizza la chiave dell'app o dell'estensione UP Wallet firmando con il wallet ufficiale di LUKSO (l'estensione Universal Profile, o l'app Universal Profiles), senza MetaMask e senza estrarre chiavi. Il percorso completo, dal profilo nuovo alla prima firma, è nell'onboarding ChainIntegrate.
- Sola verifica — controlla se un deploy esiste già su un'altra rete. Legge solo dati pubblici da un RPC: non serve nessun wallet, ma puoi connettere facoltativamente la tua Universal Profile per compilare automaticamente l'indirizzo da controllare, invece di digitarlo a mano.
- Test — conferma che il tuo controller possa operare il profilo deployato.
- Identità — il profilo su un'altra rete, confrontato con LUKSO: nome, immagini e link, cosa possiede (valuta, token e NFT, con le loro immagini), chi lo controlla e se c'è un backup, e cosa può fare lì (ricevere NFT, gas relay). La lettura non richiede wallet. La sezione 6 allinea il profilo a quello di LUKSO, con una transazione firmata dal tuo controller.
- Pubblica implementazione — se la pagina di Verifica o di Deploy segnala che l'implementazione LSP0 o Key Manager del tuo profilo manca sulla rete di destinazione, la pubblica lì allo stesso indirizzo, ripetendo il deploy deterministico originale di LUKSO. Può farlo chiunque, costa solo gas.
- UP Wallet (sperimentale) — il wallet del tuo profilo su LUKSO e su ogni rete dove l'hai rideployato, con lo stesso indirizzo: vedi cosa possiede, invii valuta, token e NFT, e usi le dApp tramite WalletConnect con il profilo come account. La pagina verifica che profilo e controller siano compatibili, mostra e simula ogni richiesta e firma solo dopo la tua conferma. La scheda del profilo dice se le richieste sono solo simulate e chi paga il gas (il sito o il tuo controller): toccali per cambiarli. "Tutte le reti" mostra cosa possiede il profilo su ogni rete dove esiste, con un totale stimato in dollari. Parti in modalità simulazione, con importi piccoli.
- UP Wallet per Android (prototipo, in prova) — lo stesso UP Wallet come app Android, per usare il profilo sulle dApp dal telefono e inviare dal profilo. Dalla versione 0.9.0 l'app firma da sola, con una chiave che crea sul telefono e che non esce mai (cifrata con il Keystore di Android, sbloccata con impronta o PIN a ogni firma): niente MetaMask e nessun altro wallet. Autorizza quella chiave una volta su ogni rete dalla pagina Controller di backup, "Autorizza un dispositivo" (senza permessi di amministrazione: non può cambiare controller o permessi, ma può usare tutti i fondi della UP); un telefono perso si revoca dalla stessa pagina, e prima il pannello "Questo telefono" manda al profilo il saldo della chiave (con cui paga il gas). È il wallet sperimentale del manutentore, con un rischio più alto di un wallet esterno: importi piccoli. Le dApp si collegano con un link WalletConnect incollato nell'app o condiviso con l'app, oppure inquadrandone il codice QR su un altro schermo; una notifica ti avvisa quando una dApp manda una richiesta, e un pulsante ti riporta alla dApp quando ha la sua risposta. Cosa conserva l'app e con quali servizi parla: informativa sulla privacy; il codice è su GitHub.
- Scaricarla: dal telefono apri la pagina delle versioni: la più recente è in cima; sotto "Assets" tocca il file
up-wallet-v….apk.
- Installarla: apri il file scaricato. L'app non è sul Play Store, quindi la prima volta Android dice che non può installare app da questa fonte (per esempio Chrome) e propone Impostazioni: toccalo, attiva "Consenti da questa fonte" per quell'app, poi torna indietro e l'installazione prosegue. Dopo puoi disattivarlo; ti servirà di nuovo al prossimo aggiornamento. Se Play Protect dice che l'app è sconosciuta o non verificata, tocca "Altri dettagli" e poi "Installa comunque". A un aggiornamento Play Protect può proporre prima di analizzare l'app: lascialo fare, dice che l'app sembra sicura e l'aggiornamento prosegue (è il controllo di Google sulle app di sviluppatori che non ha ancora verificato).
- Aggiornarla: installa l'APK più recente sopra il vecchio, allo stesso modo: impostazioni e sessioni restano. Tutte le versioni sono firmate con la stessa chiave, quindi Android rifiuta come aggiornamento un APK fatto da altri.
- Cosa cancella la chiave del telefono (non ha copie, e i dati dell'app non vanno nei backup): disinstallare l'app, anche per reinstallarla (mai disinstallare per aggiornare: si installa sopra); cancellare i dati dell'app dalle impostazioni di Android; togliere il blocco schermo (Android rende la chiave inutilizzabile per sempre, e l'app lo dice; su alcuni telefoni anche cambiarne il tipo); il ripristino di fabbrica del telefono. Prima di una di queste cose, manda alla UP il saldo della chiave ("Questo telefono") e revoca la chiave dalla pagina Backup; dopo, crea una nuova chiave e autorizzala di nuovo. Un'impronta cambiata non la cancella.
- UP Wallet per il browser (prototipo, in prova) — lo stesso UP Wallet come estensione del browser per computer, per Chrome, Edge e Brave: il profilo sulle dApp dal computer senza MetaMask. L'estensione crea una sua chiave, conservata solo cifrata e aperta con una passkey (Windows Hello, Gestore password di Google, un telefono o una chiave di sicurezza) o con una password, a ogni firma, in una piccola finestra di firma che mostra cosa si firma. Autorizzala una volta su ogni rete dalla pagina Controller di backup, "Autorizza un dispositivo", come quella del telefono (senza permessi di amministrazione, ma con accesso a tutti i fondi della UP); il pannello "Questo computer" dell'estensione apre quella pagina con l'indirizzo già inserito. Le dApp si collegano con WalletConnect e restano collegate anche a wallet chiuso, finché il browser è aperto: una richiesta apre il wallet da sola. Il pannello "Questo computer" mostra anche il saldo della chiave stessa (con cui paga il gas quando non lo paga il sito), che "Manda il saldo della chiave alla UP" sposta sul profilo: fallo prima di revocare o eliminare una chiave, perché una chiave persa non ha copie. È il wallet sperimentale del manutentore: importi piccoli. Il codice è su GitHub.
- Installarla: dalla pagina delle versioni scarica
up-wallet-extension-v….zip (non "Source code") e decomprimilo in una cartella che tieni per sempre, per esempio Documenti\UP-Wallet-Extension, non in Download (una pulizia di Download la porterebbe via e l'estensione smetterebbe di funzionare); in chrome://extensions attiva "Modalità sviluppatore", premi "Carica estensione non pacchettizzata" e scegli quella cartella. Per aggiornarla, decomprimi la nuova versione nella stessa cartella (in "Estrai tutto" di Windows la destinazione è quella cartella, non una nuova al suo interno), poi in chrome://extensions premi di nuovo "Carica estensione non pacchettizzata" e scegli la stessa cartella: l'estensione mantiene il suo id, quindi la chiave resta. Il solo pulsante di ricarica può lasciare la versione vecchia. Controlla la versione sulla scheda dell'estensione, poi chiudi e riapri il wallet. Non rimuovere mai l'estensione per aggiornarla: rimuoverla cancella la sua chiave, che non ha copie (servirebbe una nuova chiave, da autorizzare di nuovo su ogni rete, e la revoca della vecchia). Se la cartella è stata cancellata per errore, la chiave è ancora nel browser (sta con l'estensione, non nella cartella): non premere "Rimuovi" sull'errore; decomprimi di nuovo la stessa versione nella stessa cartella e premi "Carica estensione non pacchettizzata" su di essa.
- Una chiave per dispositivo, per scelta: ogni computer e ogni telefono ha la sua chiave, mai esportata né copiata. Un nuovo dispositivo vuol dire una nuova chiave e un "Autorizza un dispositivo" (MetaMask, una volta per rete): un dispositivo perso si revoca da solo, e gli altri continuano a funzionare.
- Ricezione NFT (sperimentale) — permette al profilo rideployato di ricevere NFT ERC-721 / ERC-1155 (per esempio acquisti sui marketplace), con una sola transazione che lascia invariati i permessi del controller.
- Gas pagato dal sito (sperimentale) — configura il profilo, una volta per rete, perché il sito possa pagarne il gas: una transazione del controller, che un pulsante annulla. Include una verifica della configurazione in sola lettura, che dice anche se il sito paga il gas di questo profilo.
- Iscrizione (sperimentale) — iscriviti al gas pagato dal sito, o ricarica: 5 USDC pagati dal profilo, un saldo unico per tutte le reti, un prezzo per operazione secondo la rete. Mostra il saldo appena inserisci il profilo.
Riepilogo, passo per passo
- Controlla se il profilo esiste già sulla rete di destinazione: Sola verifica.
- Solo se la Verifica o il Deploy dicono che manca un'implementazione sulla rete: Pubblica implementazione.
- Deploya il profilo allo stesso indirizzo (la pagina recupera e controlla la calldata di creazione): Deploy.
- Controlla il risultato: di nuovo Sola verifica.
- Aggiungi un controller di backup: Controller di backup.
- Prova un'operazione con il tuo controller (la chiave del passo 1 sopra): Test.
- Allinea il profilo (nome, immagini, link) a quello di LUKSO: Identità, sezione 6.
- Fai ricevere al profilo NFT ERC-721 / ERC-1155: Ricezione NFT.
- Gas pagato dal sito, se lo vuoi: configura il profilo con Gas pagato dal sito, poi iscriviti su Iscrizione.
- Usa il profilo: UP Wallet (o l'app Android).