transaction fee is sufficient and simulate transaction success,but transaction is dropped.

[BillInUK]

Hello, I recently encountered an issue that occurs with a relatively high frequency. When I send a transaction to Solana's mainnet, I ensure that my gas fee is sufficient and I simulate the transaction successfully before sending it. However, after sending the transaction and receiving the txID, I am unable to find it on the blockchain explorer. Could you please help me understand the reason for this?

here is my code to transfer the spl token:

func TransferSPLToken(rpcClient *rpc.Client, tokenMintAccount solana.PublicKey,
    fromPrivateKey solana.PrivateKey, toNativeAccount solana.PublicKey, amount uint64, decimals uint8, memo string) (*solana.Signature, error) {

    ctx := context.Background()

    fromNativeAccount := fromPrivateKey.PublicKey()

    recent, err := rpcClient.GetLatestBlockhash(context.Background(), rpc.CommitmentProcessed)
    if err != nil {
        return nil, err
    }

    //fmt.Printf("transfer spl token from token account %v\n", fromNativeAccount)
    //fmt.Printf("transfer spl token to token account %v\n", toNativeAccount)
    //fmt.Printf("transfer spl token token mint account %v\n", tokenMintAccount)
    //fmt.Printf("transfer spl token owner native account %v\n", fromNativeAccount)
    //fmt.Printf("transfer spl token amount %v\n", amount)
    //fmt.Printf("transfer spl token decimals %v\n", decimals)

    fromTokenAccount, _, err := solana.FindAssociatedTokenAddress(fromNativeAccount, tokenMintAccount)
    if err != nil {
        return nil, err
    }
    //fmt.Printf("get from token account %v \n", fromTokenAccount)

    toTokenAccountExist := true
    toTokenAccount, _, err := solana.FindAssociatedTokenAddress(toNativeAccount, tokenMintAccount)
    if err != nil {
        return nil, err
    }
    if _, err := GetSPLTokenAccountByNative(rpcClient, toNativeAccount, tokenMintAccount); err != nil {
        toTokenAccountExist = false
    }
    //fmt.Printf("get to token account %v \n", toTokenAccount)

    var instructions []solana.Instruction
    computeBudgetPriceInst := computebudget.NewSetComputeUnitPriceInstructionBuilder().SetMicroLamports(1000).Build()
    computeBudgetLimitInst := computebudget.NewSetComputeUnitLimitInstructionBuilder().SetUnits(600000).Build()

    if !toTokenAccountExist {
        associated := associatedtokenaccount.NewCreateInstruction(fromNativeAccount, toNativeAccount, tokenMintAccount).Build()
        instructions = append(instructions, associated)
    }

    transferInst := token.NewTransferCheckedInstructionBuilder().
        SetAmount(amount).
        SetSourceAccount(fromTokenAccount).
        SetDestinationAccount(toTokenAccount).
        SetDecimals(decimals).
        SetMintAccount(tokenMintAccount).
        SetOwnerAccount(fromNativeAccount).
        Build()

    instructions = append(instructions, computeBudgetPriceInst)
    instructions = append(instructions, computeBudgetLimitInst)
    instructions = append(instructions, transferInst)
    if memo != "" {
        programID := solana.MemoProgramID
        accounts := []*solana.AccountMeta{solana.Meta(fromNativeAccount).SIGNER().WRITE()}
        data := []byte(memo)
        memoInst := solana.NewInstruction(programID, accounts, data)
        instructions = append(instructions, memoInst)
    }

    tx, err := solana.NewTransaction(instructions, recent.Value.Blockhash, solana.TransactionPayer(fromNativeAccount))
    if err != nil {
        return nil, err
    }

    if _, err = tx.Sign(
        func(key solana.PublicKey) *solana.PrivateKey {
            if fromNativeAccount.Equals(key) {
                return &fromPrivateKey
            }
            return nil
        },
    ); err != nil {
        return nil, err
    }

    // 模拟发送交易
    simulateResult, err := rpcClient.SimulateTransactionWithOpts(ctx, tx, &rpc.SimulateTransactionOpts{
        ReplaceRecentBlockhash: true,
    })
    if err != nil {
        return nil, fmt.Errorf("simulate transaction error %v", err)
    }
    if simulateResult.Value.Err != nil {
        return nil, fmt.Errorf("simulate transaction failed %v", simulateResult.Value.Err)
    }

    txId, err := rpcClient.SendTransactionWithOpts(ctx, tx, rpc.TransactionOpts{SkipPreflight: true})
    return &txId, err
}