unpackdev / solgo / 9149422546

func (d *Decompiler) DecodeLOG1() []Instruction {

        return d.decodeLogInstructions(LOG1, 1)

}

func (d *Decompiler) DecodeLOG2() []Instruction {

        return d.decodeLogInstructions(LOG2, 2)

}

func (d *Decompiler) DecodeLOG3() []Instruction {

        return d.decodeLogInstructions(LOG3, 3)

}

func (d *Decompiler) DecodeLOG4() []Instruction {

        return d.decodeLogInstructions(LOG4, 4)

}

func (d *Decompiler) decodeLogInstructions(opCode OpCode, topicCount int) []Instruction {

        instructions := d.GetInstructionsByOpCode(opCode)

        for _, instruction := range instructions {

                data, topics := d.decodeLogArgs(instruction.Offset, topicCount)

                instruction.Data = data

                _ = topics

        }

        return instructions

func (d *Decompiler) decodeLogArgs(offset, topicCount int) ([]byte, []string) {

        var stack [][]byte

        currentIndex := -1

        // Find the index of the LOG instruction

        for i, instr := range d.instructions {

                if instr.Offset == offset {

                        currentIndex = i

                        break

        if currentIndex == -1 {

                return nil, nil

        }

        for i := 0; i < currentIndex; i++ {

                instr := d.instructions[i]

                switch {

                case instr.OpCode.IsPush():

                        stack = append(stack, instr.Args)

                case instr.OpCode == SWAP1:

                        if len(stack) >= 2 {

                                stack[len(stack)-1], stack[len(stack)-2] = stack[len(stack)-2], stack[len(stack)-1]

                        }

                case instr.OpCode == SWAP2:

                        if len(stack) >= 3 {

                                stack[len(stack)-1], stack[len(stack)-3] = stack[len(stack)-3], stack[len(stack)-1]

                        }

                case instr.OpCode == SWAP3:

                        if len(stack) >= 4 {

                                stack[len(stack)-1], stack[len(stack)-4] = stack[len(stack)-4], stack[len(stack)-1]

                        }

                case instr.OpCode == SWAP4:

                        if len(stack) >= 5 {

                                stack[len(stack)-1], stack[len(stack)-5] = stack[len(stack)-5], stack[len(stack)-1]

                        }

                case instr.OpCode == DUP1:

                        if len(stack) >= 1 {

                                stack = append(stack, stack[len(stack)-1])

                        }

                case instr.OpCode == DUP2:

                        if len(stack) >= 2 {

                                stack = append(stack, stack[len(stack)-2])

                        }

                case instr.OpCode == DUP3:

                        if len(stack) >= 3 {

                                stack = append(stack, stack[len(stack)-3])

                        }

                case instr.OpCode == DUP4:

                        if len(stack) >= 4 {

                                stack = append(stack, stack[len(stack)-4])

                        }

                case instr.OpCode == POP:

                        if len(stack) > 0 {

                                stack = stack[:len(stack)-1]

                        }

        if len(stack) < topicCount+1 {

                return nil, nil

        }

        topics := make([]string, 0)

        var data []byte

        topicCountFound := 0

        // Iterate from the end of the stack to find topics and data

        for i := len(stack) - 1; i >= 0; i-- {

                if len(stack[i]) == 32 && topicCountFound < topicCount {

                        topics = append([]string{common.Bytes2Hex(stack[i])}, topics...) // Prepend to maintain order

                        topicCountFound++

                } else if data == nil {

                        data = stack[i]

                }

                if topicCountFound == topicCount && data != nil {

                        break

        if data == nil {

                return nil, nil

        }

        return data, topics