Polysnap : Invocation de wrappers Polywrap Wasm à la volée

MetaMask Snaps est la feuille de route pour faire de MetaMask le wallet le plus extensible au monde. En tant que développeur, vous pouvez intégrer vos fonctionnalités et vos API à MetaMask de manières totalement nouvelles. Les développeurs Web3 sont au cœur de cette croissance, et cette série vise à mettre en lumière les MetaMask Snaps innovants en cours de développement.

Polysnap

Dépôt du Snap : https://github.com/Niraj-Kamdar/Polysnap

Pourquoi l'avez-vous développé ?

Actuellement, les développeurs doivent créer un snap pour chaque nouvelle fonctionnalité qu'ils souhaitent ajouter à MetaMask. Polysnap propose une meilleure approche de la réutilisation du code. Une large sélection de modules Wasm propulsés par Polywrap est stockée sur IPFS. Polysnap permet aux développeurs d'applications d'exécuter n'importe quel wrapper Wasm déployé sur IPFS, à la volée et en toute sécurité, via un simple appel JSON RPC, sans avoir besoin de créer un nouveau Snap.

Les utilisateurs d'une dapp reposant sur Polysnap n'ont pas besoin d'installer plusieurs snaps : il leur suffit d'installer Polysnap, ce qui contribue à réduire les vecteurs d'attaque potentiels. Une dapp utilisant Polysnap peut être plus sécurisée qu'un snap traditionnel, car Polysnap contrôle toutes les actions liées aux capacités de l'hôte, comme l'accès à Internet, l'accès au wallet, etc., et exige toujours une confirmation de l'utilisateur avant d'exécuter tout code reposant sur ces capacités.

Les développeurs de dapps n'ont pas besoin de demander aux utilisateurs d'installer plusieurs Snaps pour faire fonctionner leur application ; ils peuvent simplement utiliser un seul Snap — Polysnap — et exécuter n'importe quel wrapper Polywrap.

Les développeurs de Snaps ne sont plus limités à JavaScript et à l'écosystème JavaScript pour le développement de Snaps. Ils peuvent désormais écrire des wrappers Polywrap dans des langages comme Rust, Go et AssemblyScript, et appeler ces wrappers via Polysnap.

Pouvez-vous nous présenter l'implémentation technique ?

Le projet Polysnap se compose de deux éléments :

1. Polysnap (MetaMask Snap)

2. Le site de démonstration Polysnap

Le MetaMask Snap est la fonctionnalité principale et le cœur du projet. Le site sert à en faire la démonstration.

Le Snap

Polysnap peut être divisé en 3 parties distinctes.

1. Client Polywrap

2. Plugin Wrapper

3. WASM Wrapper

1. Client Polywrap

Polywrap développe un environnement d'exécution unifié pour Internet, sécurisé, ouvert et appartenant aux utilisateurs.

Polywrap nous permet de créer des logiciels infiniment extensibles qui s'exécutent partout grâce à un Client Polywrap. Le Client Polywrap prend en charge deux types de wrappers :

1. Wasm Wrapper — tout module wrapper Wasm sandboxé, construit et déployé sur IPFS à l'aide de la chaîne d'outils Polywrap

2. Plugin Wrapper — tout wrapper de capacités hôte qui expose différentes fonctionnalités de l'hôte, comme HTTP, le système de fichiers et JSON-RPC, aux wrappers Wasm.

Vous pouvez découvrir comment nous utilisons le Client Polywrap pour invoquer n'importe quel wrapper via un simple appel JSON-RPC à Polysnap.

export const onRpcRequest: OnRpcRequestHandler = async ({
  origin,
  request,
}) => {
  switch (request.method) {
    case 'wrap_invoke':
      const invocation = request.params as unknown as InvokerOptions;
      const isApproved = await wallet.request({
        method: 'snap_confirm',
        params: [
          {
            prompt: `${origin}`.substring(0, 40),
            description: `URI: ${invocation.uri}\nMethod: ${invocation.method}`,
            textAreaContent: `Args ${JSON.stringify(invocation.args)}`,
          },
        ],
      });

      if (isApproved === true) {
        const client = await getClient();
        const response = await client.invoke<any>(invocation);
        if (!response.ok) {
          throw response.error;
        }
        return deserializeMap(response.value);
      }
      throw new Error('User declined invocation');
    default:
      throw new Error('Method not found.');
  }
};
Copier

2. Plugin Wrapper

Les Plugin Wrappers sont directement intégrés à Polysnap via le Client Polywrap. Ces Plugin Wrappers exposent les capacités disponibles dans l'environnement SES de MetaMask, par exemple : HTTP, Ethereum JSON-RPC.

Nous avons ajouté la prise en charge de trois plugins différents dans ce MVP.

1. HTTP Plugin — expose une API permettant d'effectuer des requêtes HTTP GET/POST directement depuis le Wasm Wrapper

2. IPFS Plugin — expose une API pour stocker, épingler et récupérer des fichiers depuis IPFS

3. IPFS URI Resolver Plugin — expose une API pour résoudre les Wasm Wrappers déployés depuis IPFS

3. Wasm Wrapper

Les Wasm Wrappers sont des modules Wasm construits et déployés sur IPFS à l'aide de la chaîne d'outils Polywrap. Étant donné que Wasm est un environnement sandboxé, il ne peut effectuer aucune opération d'entrée/sortie à moins que l'hôte n'expose une API pour le permettre. De ce fait, tout Wasm Wrapper peut être exécuté en toute sécurité dans le MetaMask Snap. Polysnap ne peut exécuter aucune fonction hôte, comme l'accès à Internet, sans l'aide des Plugin Wrappers. Vous pouvez consulter tous les wrappers déployés sur IPFS sur : wrappers.io

export async function getClient(): Promise<PolywrapClient> {
  const ipfsResolverWrapperResult = await ipfsResolverPlugin(
    {},
  ).createWrapper();
  // IPFS URI RESOLVER
  if (!ipfsResolverWrapperResult.ok) {
    throw ipfsResolverWrapperResult.error;
  }
  const ipfsUriResolver = new WrapperResolver(
    Uri.from('ens/ipfs-resolver.polywrap.eth'),
    ipfsResolverWrapperResult.value,
  );

  // IPFS RESOLVER
  const ipfsWrapperResult = await ipfsPlugin({}).createWrapper();
  if (!ipfsWrapperResult.ok) {
    throw ipfsWrapperResult.error;
  }
  const ipfsResolver = new WrapperResolver(
    Uri.from('ens/ipfs.polywrap.eth'),
    ipfsWrapperResult.value,
  );

  // HTTP RESOLVER
  const httpWrapperResult = await httpPlugin({}).createWrapper();
  if (!httpWrapperResult.ok) {
    throw httpWrapperResult.error;
  }
  const httpResolver = new WrapperResolver(
    Uri.from('ens/http.polywrap.eth'),
    httpWrapperResult.value,
  );

  // AGGREGATED RESOLVER
  const resolver = RecursiveResolver.from([
    httpResolver,
    ipfsResolver,
    ipfsUriResolver,
    new ExtendableUriResolver(),
  ]);

  return new PolywrapClient({
    interfaces: [
      {
        interface: new Uri('wrap://ens/uri-resolver.core.polywrap.eth'),
        implementations: [
          new Uri('wrap://ens/ipfs-resolver.polywrap.eth'),
        ],
      },
    ],
    envs: [
      {
        uri: new Uri('wrap://ens/ipfs.polywrap.eth'),
        env: {
          provider: defaultIpfsProviders[0],
          fallbackProviders: defaultIpfsProviders.slice(1),
        },
      },
    ],
    resolver,
  });
}
Copier

Site Polysnap

Le site Polysnap est un site de démonstration simple que nous avons créé pour présenter PolySnap en action. Il comporte un bouton permettant de connecter un wallet MetaMask et d'installer le Snap, ainsi qu'un tableau de bord de requêtes qui soumet un appel JSON RPC à Polysnap et affiche le résultat.

Pour envoyer une invocation au Snap, l'utilisateur fournit trois éléments :

• Un uri qui pointe vers un Wasm Wrapper (le projet hackathon ne prend en charge que les URI IPFS, mais une version future pourrait également prendre en charge la résolution ENS)

• Le nom de la method à invoquer

• Un objet json args contenant les arguments qui seront transmis à la méthode invoquée

Lorsque le bouton « Invoke » est cliqué, le site lit les valeurs de ces champs et les transmet au Snap. Le Snap ouvre une fenêtre de confirmation pour demander l'approbation de l'invocation, garantissant ainsi que l'application n'effectue aucune invocation sans le consentement de l'utilisateur final.

Si l'invocation est approuvée, le Client Polywrap dans le Snap gère l'invocation et retourne le résultat. Ce résultat s'affiche dans un encadré sous les boutons. Bien entendu, dans une application réelle, les développeurs configureraient généralement les invocations de manière programmatique et utiliseraient le résultat différemment.

Comme son nom l'indique, Polysnap est un seul Snap doté de la puissance de plusieurs. Avec Polysnap uniquement, les développeurs peuvent invoquer n'importe quelle méthode dans n'importe quel Polywrap Wasm Wrapper écrit dans n'importe quel langage compilable en Wasm.

Les wrappers sont téléchargés à l'exécution et mis en cache. Étant donné que les Wasm Wrappers sont sandboxés et sans état, Polysnap ajoute une couche de sécurité supplémentaire à l'environnement Snap déjà sécurisé.

Et tout cela est entièrement décentralisé.

Quelles sont les prochaines étapes si vous deviez implémenter cela ?

Voici la liste de toutes les améliorations que nous avons envisagées pour la prochaine version de Polysnap :

• Activer la prise en charge de davantage de Plugin Wrappers, tels que : Cache, Concurrency, Ethereum, Near, Tezos, etc.

• Ajouter une sécurité basée sur les permissions pour l'accès à chaque plugin Polywrap, permettant à l'utilisateur final de gérer la sécurité.

• Créer un site d'installation PolySnap pour présenter le Snap, héberger la documentation et faciliter l'installation pour les utilisateurs finaux

• Ajouter la prise en charge des URI Resolvers Polywrap pour IPFS, ENS et HTTP

• Permettre aux développeurs d'applications de soumettre des configurations personnalisées pour chaque invocation du Client Polywrap, configurables lors de l'invocation via JSON-RPC avec MetaMask Snap

• Prendre en charge des solutions de gestion de cache personnalisées pour les wrappers mis en cache par PolySnap

Pouvez-vous nous parler un peu de vous et de votre équipe ?

Nous sommes tous deux membres de dOrg, une DAO composée d'ingénieurs logiciels et de designers freelances, et également développeurs chez Polywrap.

• Kris — Je suis ingénieur logiciel dans le Web3. Ma vie a changé en 2020 lorsqu'un ami m'a présenté dOrg et le web décentralisé. J'ai rapidement rejoint l'équipe de Polywrap pour contribuer à la création de la prochaine génération d'outils de développement SDK.

• Niraj — Je suis développeur Web3 chez dOrg et je travaille actuellement sur le projet Polywrap en tant que développeur Core. Je travaille en tant que développeur Web3 depuis 2 ans et j'ai contribué à Badger, Opolis, Coordinape et Llama avant de rejoindre Polywrap.

Quelles opportunités voyez-vous avec MetaMask Snaps et les possibilités qu'il ouvre pour l'espace Web3 ?

Nous pensons que MetaMask Snaps a le potentiel de faire de MetaMask un hub qui permettra d'intégrer des millions de nouveaux utilisateurs au Web3. L'expérience développeur et la sécurité sont primordiales pour le succès de tout écosystème de plugins. Nous croyons que Polysnap peut apporter les deux à MetaMask Snaps en le rendant encore plus facile à utiliser, extensible et sécurisé.

Avez-vous des conseils à partager avec les développeurs souhaitant essayer MetaMask Snaps ?

MetaMask Snaps permet d'étendre les capacités de MetaMask en écrivant de nouveaux MetaMask Snaps d'extension pour votre wallet MetaMask. C'est donc un outil très puissant qui peut permettre de nombreux cas d'usage, comme l'intégration de différents wallets L1 directement dans MetaMask, l'obtention d'informations plus détaillées sur les transactions, etc. Et nous souhaitons rendre l'expérience développeur pour ces cas d'usage encore plus simple avec Polysnap.

MetaMask Snaps est encore récent, mais en seulement un week-end, nous avons vu des équipes construire des MetaMask Snaps incroyables — dont même un wallet Cosmos intégré à MetaMask. Même si la fonctionnalité MetaMask Snaps est encore en phase de pré-production, commencez tôt !

Ou plutôt que d'écrire un nouveau Snap, vous pourriez envisager d'écrire un Polywrap Wasm Wrapper dans un langage comme Rust ou AssemblyScript. Vous pourrez alors non seulement l'invoquer avec Polysnap sans avoir à écrire votre propre Snap, mais aussi l'utiliser partout avec le client Polywrap.

Développer avec MetaMask Snaps

Pour démarrer avec MetaMask Snaps :

1. Consultez la documentation développeur

2. Installez MetaMask Flask

3. Consultez un guide MetaMask Snaps

4. Restez connecté avec nous sur Twitter, les discussions GitHub et Discord

Gardez un œil sur notre équipe lors du prochain hackathon près de chez vous ! Bonne construction ⚒️

Avertissement : Les MetaMask Snaps sont généralement développés par des tiers autres que Consensys Software. L'utilisation de MetaMask Snaps développés par des tiers se fait à votre seule discrétion et à vos propres risques, et implique votre accord selon lequel vous serez seul responsable de toute perte ou dommage résultant de ces activités. Consensys ne donne aucune garantie expresse ou implicite, qu'elle soit orale ou écrite, concernant les Snaps développés par des tiers, et décline toute responsabilité pour les MetaMask Snaps développés par des tiers. L'utilisation de logiciels liés à la blockchain comporte des risques, que vous assumez entièrement lors de l'utilisation de MetaMask Snaps.