Polysnap: Invocando Polywrap Wasm Wrappers dinamicamente

MetaMask Snaps é o roteiro para tornar a MetaMask a carteira mais extensível do mundo. Como desenvolvedor, você pode trazer seus recursos e APIs para a MetaMask de maneiras totalmente novas. Os desenvolvedores Web3 são o núcleo desse crescimento, e esta série tem como objetivo destacar os novos MetaMask Snaps sendo construídos hoje.

Polysnap

Repositório do Snap: https://github.com/Niraj-Kamdar/Polysnap

Por que você o criou?

Atualmente, os desenvolvedores precisam criar um snap para cada nova funcionalidade que desejam adicionar à MetaMask. O Polysnap apresenta uma abordagem melhor para reutilização de código. Uma ampla seleção de módulos Wasm baseados no Polywrap é armazenada no IPFS. O Polysnap permite que desenvolvedores de aplicativos executem qualquer wrapper Wasm implantado no IPFS, de forma dinâmica e segura, com uma simples chamada JSON RPC, sem precisar criar um novo Snap.

Os usuários de um dapp que utiliza o Polysnap não precisam instalar múltiplos snaps — basta instalar o Polysnap, o que pode ajudar a reduzir potenciais vetores de ataque. Um dapp que usa o Polysnap pode ser mais seguro do que um snap tradicional, pois o Polysnap controla qualquer ação relacionada às capacidades do host, como acesso à internet, acesso à carteira, etc., e sempre exigirá confirmação do usuário antes de executar qualquer código que dependa dessas capacidades.

Os desenvolvedores de dapps não precisam pedir aos usuários que instalem múltiplos Snaps para executar seus aplicativos. Em vez disso, podem usar apenas um Snap — o Polysnap — e executar qualquer wrapper do Polywrap.

Os desenvolvedores de Snaps não estão mais restritos ao JavaScript e ao ecossistema JavaScript para o desenvolvimento de Snaps. Eles podem escrever wrappers Polywrap em linguagens como Rust, Go e AssemblyScript, e chamar os wrappers usando o Polysnap.

Você pode nos explicar a implementação técnica?

O projeto Polysnap é composto por dois elementos:

1. Polysnap (MetaMask Snap)

2. Site de demonstração do Polysnap

O MetaMask Snap é o principal recurso e o foco do projeto. O site é usado para demonstrar o Snap.

O Snap

O Polysnap pode ser dividido em 3 partes diferentes.

1. Polywrap Client

2. Plugin Wrapper

3. WASM Wrapper

1. Polywrap Client

O Polywrap está construindo um ambiente de execução unificado para a internet que é seguro, aberto e de propriedade dos usuários.

O Polywrap nos permite criar softwares infinitamente extensíveis que funcionam em qualquer lugar usando um Polywrap Client. O Polywrap Client suporta a execução de dois tipos de wrappers:

1. Wasm Wrapper - qualquer módulo wrapper Wasm em sandbox, construído e implantado no IPFS usando o toolchain do Polywrap

2. Plugin Wrapper - qualquer wrapper de capacidade do host que expõe diferentes funcionalidades do host, como HTTP, o sistema de arquivos e JSON-RPC, para os Wasm wrappers.

Você pode conferir como estamos usando o Polywrap Client para invocar qualquer wrapper com uma simples chamada JSON-RPC ao 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.');
  }
};
Copiar

2. Plugin Wrapper

Os Plugin wrappers são incorporados diretamente ao Polysnap com o Polywrap Client. Esses Plugin wrappers expõem as capacidades fornecidas dentro do ambiente SES da MetaMask. Ex: HTTP, Ethereum JSON-RPC

Adicionamos suporte para três plugins diferentes neste MVP.

1. HTTP Plugin - expõe uma API que permite fazer requisições HTTP GET/POST diretamente do Wasm Wrapper

2. IPFS Plugin - expõe uma API para armazenar, fixar e recuperar arquivos do IPFS

3. IPFS URI Resolver Plugin - expõe uma API para resolver Wasm Wrappers implantados no IPFS

3. Wasm Wrapper

Os Wasm wrappers são módulos Wasm construídos e implantados no IPFS usando o toolchain do Polywrap. Como o Wasm é um ambiente em sandbox, ele não pode realizar nenhuma operação de E/S a menos que o host exponha uma API para isso. Por causa disso, qualquer Wasm wrapper pode ser executado com segurança dentro do MetaMask Snap. O Polysnap não pode executar nenhuma função do host, como acessar a internet, sem a ajuda dos Plugin wrappers. Você pode conferir todos os wrappers implantados no IPFS em: 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,
  });
}
Copiar

Site do Polysnap

O site do Polysnap é um site de demonstração simples que criamos para mostrar o PolySnap em ação. Ele possui um botão para conectar uma carteira MetaMask e instalar o Snap, além de um painel de consultas que envia uma chamada JSON RPC ao Polysnap e exibe o resultado.

Para enviar uma invocação ao Snap, o usuário fornece três elementos:

• Um uri que resolve para um Wasm wrapper (o projeto do hackathon suporta apenas URIs do IPFS, mas uma versão futura também poderá suportar resolução ENS)

• O nome do method a ser invocado

• Um objeto json args que contém os argumentos que serão passados ao método invocado

Quando o botão "Invoke" é clicado, o site lê os valores nesses campos e os encaminha ao Snap. O Snap abre uma janela de confirmação para solicitar aprovação da invocação, garantindo que o aplicativo não faça nenhuma invocação sem o consentimento do usuário final.

Se a invocação for aprovada, o Polywrap Client no Snap processa a invocação e retorna o resultado. O resultado é exibido em uma caixa abaixo dos botões. Claro que, em um aplicativo real, os desenvolvedores normalmente configurariam as invocações de forma programática e utilizariam o resultado de maneira diferente.

Como o nome sugere, o Polysnap é um único Snap com o poder de muitos. Com apenas o Polysnap, os desenvolvedores podem invocar qualquer método em qualquer Wasm wrapper do Polywrap escrito em qualquer linguagem compilável para Wasm.

Os wrappers são baixados em tempo de execução e armazenados em cache. Como os Wasm wrappers são em sandbox e sem estado, o Polysnap adiciona uma camada extra de segurança ao ambiente Snap, que já é seguro por natureza.

E tudo isso é completamente descentralizado.

Quais são os próximos passos se você implementar isso?

Aqui está a lista de todas as melhorias que imaginamos para a próxima versão do Polysnap:

• Habilitar suporte para mais Plugin Wrappers, como: Cache, Concurrency, Ethereum, Near, Tezos, etc.

• Adicionar segurança baseada em permissões para acesso a cada plugin do Polywrap, garantindo que a segurança possa ser gerenciada pelo usuário final.

• Criar um site de instalação do PolySnap para apresentar o Snap, hospedar documentação e facilitar a instalação para os usuários finais

• Adicionar suporte para os URI Resolvers do Polywrap via IPFS, ENS e HTTP

• Suportar que desenvolvedores de aplicativos enviem configurações personalizadas para cada invocação do Polywrap Client, configurável ao invocar via JSON-RPC com o MetaMask Snap

• Suportar soluções personalizadas de gerenciamento de cache para wrappers armazenados em cache pelo PolySnap

Você pode nos contar um pouco sobre você e sua equipe?

Somos ambos membros da dOrg, uma DAO de engenheiros de software e designers freelancers, e também desenvolvedores na Polywrap.

• Kris - Sou engenheiro de software no Web3. Minha vida mudou em 2020 quando um amigo me apresentou à dOrg e à web descentralizada. Logo entrei na equipe da Polywrap para ajudar a construir a próxima geração de ferramentas para desenvolvedores de SDK.

• Niraj - Sou Desenvolvedor Web3 na dOrg e atualmente trabalho no projeto Polywrap como desenvolvedor Core. Tenho trabalhado como Desenvolvedor Web3 nos últimos 2 anos e contribuí para Badger, Opolis, Coordinape e Llama antes de ingressar na Polywrap.

Que oportunidades você enxerga com o MetaMask Snaps e as possibilidades que ele abre para o espaço Web3?

Acreditamos que o MetaMask Snaps tem o potencial de transformar a MetaMask em um hub que integrará milhões de novos usuários ao web3. Tanto a experiência do desenvolvedor quanto a segurança são fundamentais para o sucesso de qualquer ecossistema de plugins. Acreditamos que o Polysnap pode trazer ambos ao MetaMask Snaps, tornando-o ainda mais fácil de usar, extensível e seguro.

Algum conselho que você gostaria de compartilhar com desenvolvedores interessados em experimentar o MetaMask Snaps?

O MetaMask Snaps permite ampliar as capacidades da MetaMask escrevendo novos Snaps de extensão para sua carteira MetaMask. Portanto, é uma ferramenta muito poderosa que pode viabilizar inúmeros casos de uso, como integrar diferentes carteiras L1 diretamente na MetaMask, fornecer mais informações sobre as transações, etc. E queremos tornar a experiência do desenvolvedor para habilitar esses casos de uso ainda mais fácil com o Polysnap.

O MetaMask Snaps ainda é novo, mas em apenas um fim de semana vimos equipes construírem MetaMask Snaps incríveis — inclusive uma carteira Cosmos que funciona dentro da MetaMask. Mesmo que o recurso MetaMask Snaps ainda esteja em estado de pré-produção, comece cedo!

Ou, em vez de escrever um novo Snap, você pode considerar escrever um Wasm wrapper do Polywrap em uma linguagem como Rust ou AssemblyScript. Assim, você não só pode invocá-lo com o Polysnap sem precisar escrever um novo Snap, como também pode usá-lo em qualquer lugar com o cliente Polywrap.

Construindo com o MetaMask Snaps

Para começar com o MetaMask Snaps:

1. Confira a documentação para desenvolvedores

2. Instale o MetaMask Flask

3. Confira um guia do MetaMask Snaps

4. Fique conectado conosco no Twitter, nas discussões do GitHub e no Discord

Fique de olho na nossa equipe no próximo hackathon perto de você! Bom BUIDL ⚒️

Aviso legal: Os MetaMask Snaps são geralmente desenvolvidos por terceiros que não a Consensys Software. O uso de MetaMask Snaps desenvolvidos por terceiros é feito a seu próprio critério e risco, e com o entendimento de que você será o único responsável por qualquer perda ou dano resultante de tais atividades. A Consensys não oferece nenhuma garantia expressa ou implícita, seja verbal ou escrita, em relação a Snaps desenvolvidos por terceiros, e se isenta de toda responsabilidade por MetaMask Snaps desenvolvidos por terceiros. O uso de softwares relacionados a blockchain envolve riscos, e você os assume integralmente ao usar o MetaMask Snaps.