Polysnap: Polywrap-Wasm-Wrapper spontan aufrufen

MetaMask Snaps ist der Fahrplan, um MetaMask zur erweiterbarsten Wallet der Welt zu machen. Als Entwickler kannst du deine Features und APIs auf völlig neue Weise in MetaMask einbringen. Web3-Entwickler sind der Kern dieses Wachstums, und diese Serie zielt darauf ab, die neuartigen MetaMask Snaps vorzustellen, die heute entwickelt werden.

Polysnap

Snap Repo: https://github.com/Niraj-Kamdar/Polysnap

Warum hast du es entwickelt?

Derzeit müssen Entwickler für jede neue Funktion, die sie MetaMask hinzufügen möchten, einen eigenen Snap erstellen. Polysnap bietet einen besseren Ansatz zur Wiederverwendung von Code. Eine große Auswahl an Polywrap-gestützten Wasm-Modulen wird auf IPFS gespeichert. Polysnap ermöglicht es App-Entwicklern, jeden auf IPFS bereitgestellten Wasm-Wrapper spontan und sicher mit einem einfachen JSON-RPC-Aufruf auszuführen, ohne einen neuen Snap erstellen zu müssen.

Nutzer einer Dapp, die auf Polysnap basiert, müssen nicht mehrere Snaps installieren, sondern nur Polysnap – was potenzielle Angriffsvektoren reduzieren kann. Eine Dapp, die Polysnap verwendet, kann sicherer sein als ein herkömmlicher Snap, da Polysnap alle Aktionen im Zusammenhang mit Host-Funktionen wie Internetzugang, Wallet-Zugriff usw. kontrolliert und vor der Ausführung von Code, der auf diese Funktionen angewiesen ist, stets eine Benutzerbestätigung erfordert.

Dapp-Entwickler müssen Nutzer nicht mehr auffordern, mehrere Snaps zu installieren, um ihre App zu betreiben – stattdessen können sie einfach einen einzigen Snap verwenden – Polysnap – und beliebige Polywrap-Wrapper ausführen.

Snap-Entwickler sind bei der Snap-Entwicklung nicht mehr auf JavaScript und das JavaScript-Ökosystem beschränkt. Sie können stattdessen Polywrap-Wrapper in Sprachen wie Rust, Go und AssemblyScript schreiben und die Wrapper über Polysnap aufrufen.

Kannst du uns durch die technische Implementierung führen?

Das Polysnap-Projekt besteht aus zwei Elementen:

1. Polysnap (MetaMask Snap)

2. Polysnap-Demo-Website

Der MetaMask Snap ist das Hauptfeature und der Schwerpunkt des Projekts. Die Website dient zur Demonstration des Snaps.

Der Snap

Polysnap lässt sich in 3 verschiedene Teile unterteilen.

1. Polywrap Client

2. Plugin Wrapper

3. WASM Wrapper

1. Polywrap Client

Polywrap entwickelt eine einheitliche Ausführungsumgebung für das Internet, die sicher, offen und nutzereigen ist.

Polywrap ermöglicht es uns, endlos erweiterbare Software zu erstellen, die mithilfe eines Polywrap Clients überall ausgeführt werden kann. Der Polywrap Client unterstützt die Ausführung von zwei Arten von Wrappern:

1. Wasm Wrapper – jedes sandboxed Wasm-Wrapper-Modul, das mithilfe der Polywrap-Toolchain erstellt und auf IPFS bereitgestellt wurde

2. Plugin Wrapper – jeder Host-Capability-Wrapper, der verschiedene Host-Funktionen wie HTTP, das Dateisystem und JSON-RPC für Wasm-Wrapper bereitstellt

Du kannst dir ansehen, wie wir den Polywrap Client verwenden, um jeden Wrapper mit einem einfachen JSON-RPC-Aufruf an den Polysnap aufzurufen.

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.');
  }
};
Kopieren

2. Plugin Wrapper

Plugin-Wrapper sind direkt mit dem Polywrap Client in Polysnap eingebettet. Diese Plugin-Wrapper stellen die Funktionen bereit, die innerhalb der SES-Umgebung von MetaMask verfügbar sind, z. B.: HTTP, Ethereum JSON-RPC

In diesem MVP haben wir Unterstützung für drei verschiedene Plugins hinzugefügt.

1. HTTP Plugin – stellt eine API bereit, die es ermöglicht, HTTP-GET/POST-Anfragen direkt aus dem Wasm-Wrapper heraus zu stellen

2. IPFS Plugin – stellt eine API zum Speichern, Pinnen und Abrufen von Dateien aus dem IPFS bereit

3. IPFS URI Resolver Plugin – stellt eine API bereit, um bereitgestellte Wasm-Wrapper aus dem IPFS aufzulösen

3. Wasm Wrapper

Wasm-Wrapper sind Wasm-Module, die mithilfe der Polywrap-Toolchain erstellt und auf IPFS bereitgestellt werden. Da Wasm eine sandboxed Umgebung ist, kann es keine I/O-Operationen durchführen, es sei denn, der Host stellt eine API bereit, die dies ermöglicht. Dadurch können alle Wasm-Wrapper sicher innerhalb des MetaMask Snaps ausgeführt werden. Polysnap kann keine Host-Funktionen ausführen, wie z. B. den Internetzugang, ohne die Hilfe von Plugin-Wrappern. Alle auf IPFS bereitgestellten Wrapper findest du unter: 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,
  });
}
Kopieren

Polysnap-Website

Die Polysnap-Website ist eine einfache Demo-Seite, die wir erstellt haben, um Polysnap in Aktion zu zeigen. Sie verfügt über eine Schaltfläche zum Verbinden einer MetaMask-Wallet und zum Installieren des Snaps sowie über ein Abfrage-Dashboard, das einen JSON-RPC-Aufruf an den Polysnap sendet und das Ergebnis anzeigt.

Um eine Anfrage an den Snap zu senden, gibt ein Nutzer drei Elemente an:

• Eine uri, die auf einen Wasm-Wrapper verweist (das Hackathon-Projekt unterstützt nur IPFS-URIs, aber eine zukünftige Version könnte auch ENS-Auflösung unterstützen)

• Den Namen der aufzurufenden method

• Ein JSON-Objekt args, das die Argumente enthält, die an die aufgerufene Methode übergeben werden

Wenn die Schaltfläche „Invoke" angeklickt wird, liest die Website die Werte in diesen Feldern und leitet sie an den Snap weiter. Der Snap öffnet ein Bestätigungsfenster, um die Genehmigung des Aufrufs anzufordern, und stellt so sicher, dass die App keine Aufrufe ohne die Zustimmung des Endnutzers durchführt.

Wenn der Aufruf genehmigt wird, verarbeitet der Polywrap Client im Snap den Aufruf und gibt das Ergebnis zurück. Das Ergebnis wird in einem Feld unterhalb der Schaltflächen angezeigt. In einer realen App würden Entwickler Aufrufe natürlich in der Regel programmatisch einrichten und das Ergebnis anders verwenden.

Wie der Name schon sagt, ist Polysnap ein einziger Snap mit der Leistungsfähigkeit vieler. Mit nur Polysnap können Entwickler jede Methode in jedem Polywrap-Wasm-Wrapper aufrufen, der in einer beliebigen Wasm-kompilierbaren Sprache geschrieben wurde.

Die Wrapper werden zur Laufzeit heruntergeladen und zwischengespeichert. Da Wasm-Wrapper sandboxed und zustandslos sind, fügt Polysnap der bereits sicheren Snap-Umgebung eine zusätzliche Sicherheitsebene hinzu.

Und das alles ist vollständig dezentralisiert.

Was sind die nächsten Schritte, wenn du dies implementieren würdest?

Hier ist die Liste aller Verbesserungen, die wir für die nächste Version von Polysnap vorgesehen haben:

• Unterstützung für weitere Plugin-Wrapper aktivieren, wie z. B.: Cache, Concurrency, Ethereum, Near, Tezos usw.

• Berechtigungsbasierte Sicherheit für den Zugriff auf jedes Polywrap-Plugin hinzufügen, damit die Sicherheit vom Endnutzer verwaltet werden kann

• Eine PolySnap-Installationswebsite erstellen, um den Snap vorzustellen, Dokumentation bereitzustellen und die Installation für Endnutzer zu vereinfachen

• Unterstützung für IPFS-, ENS- und HTTP-Polywrap-URI-Resolver hinzufügen

• App-Entwickler dabei unterstützen, benutzerdefinierte Konfigurationen für jeden Aufruf des Polywrap Clients einzureichen, die beim Aufruf über JSON-RPC mit MetaMask Snap konfigurierbar sind

• Benutzerdefinierte Cache-Management-Lösungen für von PolySnap zwischengespeicherte Wrapper unterstützen

Kannst du uns ein wenig über dich und dein Team erzählen?

Wir sind beide Mitglieder von dOrg, einer DAO aus freiberuflichen Softwareingenieuren und Designern, und außerdem Entwickler bei Polywrap.

• Kris – Ich bin Softwareingenieur im Web3-Bereich. Mein Leben veränderte sich 2020, als mich ein Freund mit dOrg und dem dezentralen Web bekannt machte. Ich trat bald dem Team bei Polywrap bei, um an der nächsten Generation von SDK-Entwicklertools mitzuwirken.

• Niraj – Ich bin Web3-Entwickler bei dOrg und arbeite derzeit als Core-Entwickler am Polywrap-Projekt. Ich bin seit 2 Jahren als Web3-Entwickler tätig und habe zu Badger, Opolis, Coordinape und Llama beigetragen, bevor ich zu Polywrap kam.

Welche Möglichkeiten siehst du mit MetaMask Snaps und den Chancen, die es für den Web3-Bereich eröffnet?

Wir glauben, dass MetaMask Snaps das Potenzial hat, MetaMask zu einem Hub zu machen, der Millionen neuer Nutzer in Web3 einführen wird. Sowohl die Entwicklererfahrung als auch die Sicherheit sind entscheidend für den Erfolg jedes Plugin-Ökosystems. Wir sind überzeugt, dass Polysnap beides zu MetaMask Snaps beitragen kann, indem es noch benutzerfreundlicher, erweiterbarer und sicherer wird.

Hast du Ratschläge für Entwickler, die MetaMask Snaps ausprobieren möchten?

MetaMask Snaps ermöglichen es, die Funktionen von MetaMask zu erweitern, indem neue Erweiterungs-Snaps für deine MetaMask-Wallet geschrieben werden. Es ist also ein sehr leistungsstarkes Tool, das zahlreiche Anwendungsfälle ermöglichen kann, wie z. B. die direkte Integration verschiedener L1-Wallets in MetaMask, mehr Einblicke in Transaktionen usw. Und wir möchten die Entwicklererfahrung für solche Anwendungsfälle mit Polysnap noch einfacher gestalten.

MetaMask Snaps ist noch neu, aber an nur einem Wochenende haben wir Teams dabei beobachtet, wie sie beeindruckende MetaMask Snaps entwickelt haben – sogar eine Cosmos-Wallet, die direkt in MetaMask lebt. Auch wenn das MetaMask-Snaps-Feature noch im Vorabversionsstatus ist: Fang früh an!

Oder anstatt einen neuen Snap zu schreiben, könntest du in Betracht ziehen, einen Polywrap-Wasm-Wrapper in einer Sprache wie Rust oder AssemblyScript zu schreiben. Du kannst ihn dann nicht nur mit Polysnap aufrufen, ohne einen eigenen neuen Snap schreiben zu müssen, sondern ihn auch überall mit dem Polywrap-Client verwenden.

Mit MetaMask Snaps entwickeln

So startest du mit MetaMask Snaps:

1. Schau dir die Entwicklerdokumentation an

2. Installiere MetaMask Flask

3. Schau dir einen MetaMask-Snaps-Leitfaden an

4. Bleib mit uns in Kontakt auf Twitter, GitHub Discussions und Discord

Halte bei unserem Team beim nächsten Hackathon in deiner Nähe Ausschau! Happy BUIDLing ⚒️

Haftungsausschluss: MetaMask Snaps werden im Allgemeinen von Dritten entwickelt, die nicht Consensys Software angehören. Die Nutzung von durch Dritte entwickelten MetaMask Snaps erfolgt nach eigenem Ermessen und auf eigenes Risiko, und du stimmst zu, dass du allein für etwaige Verluste oder Schäden verantwortlich bist, die aus solchen Aktivitäten resultieren. Consensys gibt keine ausdrückliche oder stillschweigende Garantie, weder mündlich noch schriftlich, in Bezug auf von Dritten entwickelte Snaps und lehnt jede Haftung für von Dritten entwickelte MetaMask Snaps ab. Die Nutzung von Blockchain-bezogener Software ist mit Risiken verbunden, die du bei der Verwendung von MetaMask Snaps vollständig übernimmst.