Esta é minha tentativa de criar um modelo CSS com os seguintes recursos:

• para viewports menores (< 1200px) coluna única, com estes itens:

  1. box-menu
  2. box-data
  3. box-footer

• para janelas de visualização maiores, mude para um layout de duas colunas:

  • coluna da esquerda: box-menue box-footer sem qualquer rolagem
  • coluna da direita: box-datapermitindo a rolagem desta coluna somente se o conteúdo for maior que a altura disponível

Aqui está meu código:

:root {
  --color-text: #521D03;
  --color-menu-background: #33dd00;
  --color-content-background: #FFFFFF;
  --color-lines: #521D03;
}

html,
body,
.container {
  height: 100%;
}

body {
  margin: 0;
}

.container {
  display: flex;
  flex-direction: column;
}

.button {
  display: block;
  font-weight: bold;
  font-size: 32px;
  line-height: 0.9em;
  text-decoration: none;
  letter-spacing: 0.02em;
  color: var(--color-text);
}

.box {
  padding: 1em;
  box-sizing: border-box;
  display: flex;
  flex-flow: column;
  color: var(--color-text);
}

.box-menu {
  background-color: var(--color-menu-background);
  text-align: center;
  justify-content: space-around;
}

.box-data {
  background-color: var(--color-content-background);
  background-color: #aaaaaa;
  flex: 1;
}

.box-footer {
  background-color: var(--color-menu-background);
  line-height: 1em;
  text-align: center;
}

.box-menu .menu-header {
  display: flex;
  flex-direction: column;
  justify-content: center;
}

.box-data .data-header {
  flex: 0 0 auto;
  display: flex;
  flex-direction: column;
  justify-content: center;
}

.box-data .data-content {
  flex: 1 1 auto;
  display: flex;
  flex-direction: column;
  justify-content: center;
}

.box-data .data-footer {
  flex: 0 1 150px;
  text-align: center;
}

/* Larger viewports */
@media (min-width: 1200px) {
  .container {
    flex-direction: row;
    flex-wrap: wrap;
  }

  .box-menu,
  .box-data,
  .box-footer {
    flex-basis: 50%;
  }

  .box-menu {
    height: calc(100% - 150px);
  }

  .box-footer {
    height: 150px;
  }

  .box-data {
    height: 100%;
    overflow-y: auto;
  }
}

<div class="container">
  <div class="box box-menu">

    <div class="menu-header">
      <h1>MY LOGO</h1>
    </div>

    <div class="menu-content">
      <a class="button" href="/">MENU 1</a>
      <a class="button" href="/">MENU 2</a>
      <a class="button" href="/">MENU 3</a>
    </div>

  </div>
  <div class="box box-data">

    <div class="data-header">
      <div class="nav-section">
        <h3>MY NAV</h3>
      </div>
    </div>

    <div class="data-content">
      MY LONG CONTENT

      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
      <p>
        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
      </p>
    </div>

    <div class="data-footer">
      <div class="menu-content">
        <a class="button clear">MY BUTTON</a>
      </div>
    </div>

  </div>

  <div class="box box-footer">
    MY FOOTER
  </div>

</div>

O código de viewport menor está funcionando bem. Quando ele muda para o layout de duas colunas, o box-footeré colocado (como esperado) depois do box-datacausando uma lacuna:

Tentei consertar com a orderpropriedade, mas ela altera a ordem dos itens, não a ordem do fluxo.

Pelo que entendi, o flex contará 1. superior esquerdo, 2. superior direito, 3. inferior esquerdo, etc. Em vez disso, para atender às minhas necessidades, deveria ser 1 superior esquerdo (menu), 2 inferiores esquerdos (rodapé) e 3 superiores direitos (dados).

Como colocar o box-footerlogo abaixo box-menusem deixar espaço?

Gostaria de gerar eficientemente uma lista de permutações "válidas" a partir de uma lista fornecida.

Por meio de um exemplo simples, suponha que eu gostaria de gerar as permutações de [1,2,3]onde 3está em uma das duas primeiras posições. Meu resultado de retorno seria então[[3,1,2], [3,2,1], [1,3,2],[2,3,1]]

Atualmente, posso resolver esse problema filtrando cada permutação em um loop. Não preciso gerar todas as permutações, pois posso usar uma bijeção de inteiros para uma permutação, apenas para economizar memória.

De qualquer forma, esse método não é realmente viável quando minha lista começa a crescer - há simplesmente muitas permutações para percorrer.

Um exemplo mais realista é que eu gostaria de gerar as permutações de [1,2,...20]com comprimento 10, onde minhas regras são algo como [1,2]deve aparecer nos três primeiros lugares (em qualquer ordem), [3,4]deve terminar nos cinco primeiros lugares (em qualquer ordem) e assim por diante (para qualquer entrada razoável do usuário).

Há 6.704425728 E+11valores para verificar no loop aqui, então, na verdade, são muitos.

Meus pensamentos iniciais são de que pode haver duas maneiras de fazer isso:

1. Gere apenas permutações válidas usando as regras para gerar subpermutações e, em seguida, combine-as.
2. De alguma forma, represente as permutações em uma árvore e aplique filtragem na árvore. Dessa forma, se um nó falhar em uma regra, todos os filhos desse nó também falharão na regra. Isso permitiria reduzir drasticamente a verificação em muitos casos (dependendo das regras).

Alguém já teve alguma experiência fazendo algo assim e poderia fornecer alguma orientação? Ou isso é simplesmente um problema complicado que requer computação monumental?

Estou usando o DuckDB para ler um arquivo CSV que contém strings vazias em alguns campos. No entanto, o DuckDB converte essas strings vazias para NULL.

Dados de amostra CSV:

"path","comment"
"","[{""comment"":""grand total"",""updatedByUser"":"",""dateTime"":""2025-03-27 09:08:38"",""threadStatus"":null,""threadAssignee"":null}]"
"East","[{""comment"":""Sub total"",""updatedByUser"":"",""dateTime"":""2025-03-27 09:09:03"",""threadStatus"":null,""threadAssignee"":null}]"

Consulta que estou usando:

SELECT * FROM read_csv('${path}', delim=',', header=True, columns={"path":"VARCHAR","comment":"VARCHAR"});

Quero que strings vazias ("") na pathcoluna permaneçam strings vazias, mas elas estão sendo convertidas em NULLs.

Como posso fazer com que esses valores permaneçam como strings vazias?

Estou executando um código de teste com um banco de dados MySQL usando SQLAlchemy. Não consigo conectar ao servidor usando a URL do banco de dados 'mysql://poopoo:peepee@localhost:32913/test', pois ele me recusa a autenticação.

Quando tento conectar ao banco de dados usando o DBeaver, recebo um erro informando que "Recuperação de chave pública não é permitida". Isso me levou a esta postagem , sugerindo que eu adicione ?allowPublicKeyRetrieval=true&useSSL=falseao final da URL. Posso confirmar que esse método funciona no DBeaver.

No entanto, ao adicioná-los à URL, seja em uma string ou com connect_args, um comando TypeErroré gerado, informando-me que esses são argumentos de palavra-chave inválidos para connect.

Como adiciono essas opções à minha conexão SQLAlchemy?

Estou usando testcontainerspara gerar o servidor de teste MySQL , mas não acho que isso seja relevante.

Dê uma olhada nesta regex bem simples em https://regex101.com/r/jt7KGW/1

Quero corresponder a todas as strings que começam com letter qe obter tudo depois da letter q, mas não pode conter xxx. Eu criei esta regex, que funciona muito bem:

/q(.+?)(?=xxx)/ 

Se eu testar essa regex com a string, q111xxxx q222xxx q333xxxreceberei de volta 111, 222and 333(como você pode ver no link acima). No entanto, se a string de entrada for q111xxxx q222xxx q333(eu removi o último xxx) eu só receberei de volta 111and 222mas eu realmente preciso da última correspondência (que é 333).

Depois de estudar por quase 2 horas, cheguei a esta solução abaixo que você pode conferir em https://regex101.com/r/7SYo4x/1

q(?:(?:.+?)(?=xxx)|.+$)

O que é muito feio e nada eficiente. Existe uma maneira melhor de fazer isso?

Tenho uma webapi hospedada no Azure App Service, ela tem identidade gerenciada e há um Application Insights existente que deu permissão de leitor para essa API hospedada.

No AppInsights, uma nova função foi atribuída e uma permissão de leitor foi concedida à API. Agora quero que a API leia dados do AppInsights.

Quero adicionar um método C# como uma API REST que lê os últimos 10 rastreamentos?

 // Use DefaultAzureCredential to authenticate with Managed Identity
            var credential = new DefaultAzureCredential();

            // Create a LogsQueryClient
            var client = new LogsQueryClient(credential);

            // Replace this with your Application Insights resource ID
            string appInsightsResourceId = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/microsoft.insights/components/{applicationInsightsName}";

            // KQL query to get the last 10 traces
            string kqlQuery = "traces | order by timestamp desc | take 10";

            // Execute the query
            Response<LogsQueryResult> queryResponse = await client.QueryWorkspaceAsync(
                appInsightsResourceId, 
                kqlQuery, 
                new QueryTimeRange(TimeSpan.FromHours(1))
            );

Não funcionou, ele retorna com credenciais de token inválidas.

Também tentei usar DefaultAzureCredentialso valor ManagedClientID, mas ainda não funcionou. Quero obter dados de logs/rastreamentos como um método http.

Estou tentando configurar módulos FX, mas tenho dúvidas e não consigo encontrar uma maneira de avançar. Basicamente, tenho um módulo para o servidor:

    func NewGRPCServer(
    lc fx.Lifecycle, log *zap.Logger, tracer trace.Tracer,
    srvsInterceptors []grpc.UnaryServerInterceptor, serverOpt []grpc.ServerOption,
) *grpc.Server {
    defaultRecoveryHandler := func(ctx context.Context, r interface{}) (err error) {
        logger.FromContext(ctx).Error("recovered from panic", zap.Any("panic", r), zap.Stack("stacktrace"))

        return status.Error(codes.Internal, "unexpected error")
    }

    interceptors := append([]grpc.UnaryServerInterceptor{
        LoggerToContextInterceptor(log),
        TracerToContextInterceptor(tracer),
        grpc_recovery.UnaryServerInterceptor(grpc_recovery.WithRecoveryHandlerContext(defaultRecoveryHandler)),
    }, srvsInterceptors...)

    otelHandler := otelgrpc.NewServerHandler(
        otelgrpc.WithTracerProvider(otel.GetTracerProvider()),
    )

    serverOpts := []grpc.ServerOption{
        grpc.ChainUnaryInterceptor(interceptors...),
        grpc.StatsHandler(otelHandler),
        grpc.KeepaliveEnforcementPolicy(
            keepalive.EnforcementPolicy{
                MinTime:             60 * time.Second,
                PermitWithoutStream: true,
            }),
        grpc.KeepaliveParams(
            keepalive.ServerParameters{
                Time:    60 * time.Second,
                Timeout: 10 * time.Second,
            },
        ),
    }

    serverOpts = append(serverOpts, serverOpt...)

    server := grpc.NewServer(serverOpts...)

    grpc_health_v1.RegisterHealthServer(server, health.NewServer())
    reflection.Register(server)

    return server
}

// NewListener creates a new network listener for the gRPC server using the gRPC server address parsed from the config.
func NewListener(cfg Config) (net.Listener, error) {
    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", cfg.GRPC))
    if err != nil {
        return nil, fmt.Errorf("dial connection: %w", err)
    }

    return lis, nil
}

func GRPCModule() fx.Option {
    return fx.Module(
        "grpc",
        fx.Provide(
            fx.Annotate(
                NewGRPCServer,
                fx.ParamTags(``, ``, ``, `optional:"true"`, `optional:"true"`),
            ),
        ),
        fx.Invoke(func(lc fx.Lifecycle, server *grpc.Server, config Config, log *zap.Logger) {
            lc.Append(fx.Hook{
                OnStart: func(ctx context.Context) error {
                    lis, err := NewListener(config)
                    if err != nil {
                        return err
                    }

                    go func(srv *grpc.Server, logger *zap.Logger) {
                        logger.Info("Starting gRPC server")
                        if err := srv.Serve(lis); err != nil && err != grpc.ErrServerStopped {
                            logger.Error("gRPC server failed", zap.Error(err))
                        }
                    }(server, log)

                    return nil
                },
                OnStop: func(ctx context.Context) error {
                    server.GracefulStop()
                    return nil
                },
            })
        }),
    )
}

E um módulo para UI:

func NewGRPCUIServer(
    lc fx.Lifecycle,
    logger *zap.Logger,
    tracer trace.Tracer,
    config Config,
) (*http.Server, error) {
    logger.Info("enter on new grpc ui server.")

    rpcGrpcHost := fmt.Sprintf("0.0.0.0:%d", config.GRPC)
    keepAliveOpt := grpc.WithKeepaliveParams(keepalive.ClientParameters{
        Time:                60 * time.Second,
        Timeout:             10 * time.Second,
        PermitWithoutStream: true,
    })

    cc, err := grpc.NewClient(
        rpcGrpcHost,
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
        keepAliveOpt,
    )
    if err != nil {
        logger.Error("Failed to connect to gRPC server for UI", zap.Error(err))
        return nil, err
    }

    h, err := standalone.HandlerViaReflection(context.Background(), cc, rpcGrpcHost)
    if err != nil {
        logger.Error("Failed to create UI handler", zap.Error(err))
        return nil, err
    }

    mux := http.NewServeMux()
    mux.Handle("/grpc-ui/", http.StripPrefix("/grpc-ui", h))

    return httplib.NewHTTPServerFx(
        lc,
        httplib.Config{
            ServerAddr:         fmt.Sprintf(":%d", config.UI),
            ServerReadTimeout:  15 * time.Second,
            ServerWriteTimeout: 15 * time.Second,
        },
        logger,
        tracer,
        mux,
    )
}

type GRPCUIParams struct {
    fx.In

    WebServer *http.Server `name:"grpc-ui-server"`
    Logger    *zap.Logger
}

func GRPCUIModule() fx.Option {
    return fx.Module(
        "x:ui",
        fx.Provide(
            NewGRPCUIServer,
            fx.Annotate(
                NewGRPCUIServer,
                fx.ParamTags(``, ``, ``, ``, ``),
                fx.ResultTags(`name:"grpc-ui-server"`),
            ),
        ),
        fx.Invoke(func(params GRPCUIParams) {
            params.Logger.Info("gRPC UI Server initialized:", zap.String("address", params.WebServer.Addr))
        }),
    )
}

Mas por algum motivo está falhando em handlerViaReflection:

h, err := standalone.HandlerViaReflection(context.Background(), cc, rpcGrpcHost)
if err != nil {
    logger.Error("Failed to create UI handler", zap.Error(err))
    return nil, err
}

E está dando erro porque o servidor gRPC ainda não iniciou. Coloquei um breakpoint aqui no módulo do servidor:

fx.Invoke(func(lc fx.Lifecycle, server *grpc.Server, config Config, log *zap.Logger) {
    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            lis, err := NewListener(config)
            if err != nil {
                return err
            }

            go func(srv *grpc.Server, logger *zap.Logger) {
                logger.Info("Starting gRPC server")
                if err := srv.Serve(lis); err != nil && err != grpc.ErrServerStopped {
                    logger.Error("gRPC server failed", zap.Error(err))
                }
            }(server, log)

            return nil
        },

E não entra; ele sempre vai para o módulo UI primeiro. Ele cria o servidor: NewGRPCServer, mas nunca o inicializa. Alguém sabe como posso resolver isso?

Problema

Estou construindo um aplicativo com um frontend Next.js e um backend Laravel usando Sanctum para autenticação SPA. Quando eu entro no aplicativo Next.js, consigo ver os cookies de autenticação sendo definidos no navegador, mas solicitações subsequentes para obter informações do usuário retornam erros "não autenticados". OBSERVAÇÃO: Tudo está funcionando corretamente no Postman.

Ambiente

• Frontend: Next.js
• Backend: Laravel com Sanctum
• Autenticação: Autenticação Laravel Sanctum SPA
• Tudo funciona corretamente ao testar no Postman

O que eu tentei

O processo de login funciona bem, e posso confirmar que os cookies são definidos no navegador após o login. No entanto, quando tento buscar as informações do usuário autenticado, recebo erros "não autorizado". Tentei a solicitação GET em "/api/v1/user" no Postman e funcionou.

Código

Minha função de login:

const baseUrl = process.env.NEXT_PUBLIC_BASE_URL;

async function fetchCsrfCookie() {
    await fetch(`${process.env.NEXT_PUBLIC_BASE_URL}/sanctum/csrf-cookie`, {
        method: 'GET',
        credentials: 'include',
    });
}

export const fetchSignIn = async (username: string, password: string) => {
    //   1) Init Sanctum
    await fetchCsrfCookie();

    // 2) Login
    const res = await fetch(`${baseUrl}/api/v1/login`, {
        method: 'POST',
        credentials: 'include',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ username, password, remember: true }),
    });
    if (!res.ok) {
        throw new Error('Login failed');
    }
    return res.json();
};

Buscar função do usuário:

export const fetchAuthUser = async () => {
    try {
        const res = await fetch(`${process.env.NEXT_PUBLIC_BASE_URL}/api/v1/user`, {
            method: 'GET',
            credentials: 'include',
            headers: {
                'Content-Type': 'application/json',
            },
        });

        if (!res.ok) {
            const errorData: any = await res.json();
            console.error('Error data:', errorData);
            throw new Error(errorData.message || res.statusText);
        }

        return res.json();
    } catch (error) {
        console.error(`Failed to fetch resource:`, error);
        throw error;
    }
};

Tenho uma lista de inteiros com duplicatas e preciso classificá-la pelo número dessas duplicatas.

Por exemplo:

input: n = [2, 4, 1, 2]
output: n = [4, 1, 2, 2]

Eu escrevi um código e notei que sort() não altera a lista. Mas se eu tentar usar sorted() com o mesmo argumento de chave, então funciona perfeitamente. Qual é a razão por trás disso?

Meu código:

nums = [2, 4, 1, 2]
nums.sort(key = lambda x: nums.count(x))
print(nums)

Ele pode ser conectado ao método sort() usando o algoritmo in-loco?

Estou enfrentando um problema em que o ID de assinatura retornado pelo meu script é diferente daquele mostrado em vrf.chain.link para a rede Sepolia, o que quando tento financiar o subid do meu script resulta em InvalidSubscriptionId.

Testcreatesubscription.s.sol:

// SPDX-License-Identifier: MIT

pragma solidity  ^0.8.19;
import {Script} from "forge-std/Script.sol";
import {CodeConstants} from "script/HelperConfig.s.sol";
import {IVRFCoordinatorV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/interfaces/IVRFCoordinatorV2Plus.sol";
import {console} from "forge-std/console.sol";

contract CreateSubscription is Script,CodeConstants{
    function run() public{
        createsubscription_onsepolia();
    }

    function createsubscription_onsepolia() public {
        if(block.chainid == ETH_SEPOLIA_CHAN_ID){
            vm.startBroadcast(0x57099326F00d72E00dc4416FF638136853E5330e);
            uint256 subid = IVRFCoordinatorV2Plus(0x9DdfaCa8183c41ad55329BdeeD9F6A8d53168B1B).createSubscription();
            vm.stopBroadcast();
            console.log("subid on sepolia: ",subid);
        }
    }
}

quando executo o script forge script/Testcreatesubscription.s.sol:CreateSubscription --rpc-url $SEPOLIA_RPC_URL --account sepolia_testing_account --broadcast -vvvv

sepolia_testing_account é minha conta metamask, que armazenei no keystore.

resultado dos logs:

== Logs == subsídio em sepolia: 1756636573672805867076888413.....

Configurando 1 EVM.

Rastros simulados na cadeia:

[88720] VRFCoordinatorV2_5::createSubscription() ├─ emitir SubscriptionCreated(subId: 175663657367280586707688841388762055..... [1.756e76], proprietário: 0x57099....) └─ ← [Retornar] 1756636573672805867076888413887... [1.756e76]

==========================

Corrente 11155111

Preço estimado do gás: 0,724514652 gwei

Total estimado de gás usado para script: 151638

Quantidade estimada necessária: 0,000109863952799976 ETH

=========================== Insira a senha do keystore:⠂ Sequência nº 1 em sepolia

sepolia ✅ [Sucesso] Hash: 0x93a569514837d5d7dd8f525e1fdf105b541fde506522cf9c6b7d0173779c0da7 Bloco: 8028451 Pago: 0,000043162465117744 ETH (109784 gás * 0,393158066 gwei)

✅ Sequência nº 1 em sepolia | Total pago: 0,000043162465117744 ETH (109784 gás * média de 0,393158066 gwei)

Embora os logs do script mostrem que meu ID de assinatura é 175663657367280586707688841388762055..., quando verifico vrf.chain.link na rede Sepolia, vejo um ID de assinatura completamente diferente: 426994294831235659204431318963817900788974...

Estou lutando com isso há horas, e nem o ChatGPT conseguiu descobrir. Alguém sabe o que posso estar fazendo errado? Qualquer ajuda seria muito apreciada!