Convertir bytes32 a bytes2 ordenados, bytes4, etc.

Por ejemplo, necesito dividir mi variable bytes32 en fragmentos y poner el resultado en 5 variables, guardando el orden, bytes2, bytes2, bytes2, bytes2, bytes8, bytes1(también conocido como byte), el orden debe guardarse y realmente no me importa el resto de los bytes. .

¿Solidity tiene algunas herramientas para eso? O solo es posible con operaciones de bits.

Encontré algunas dificultades para trabajar con estos tipos de bajo nivel.

ACTUALIZACIÓN: Así que preparé esta función que analiza los numBytesbytes desde sourceel startbyte.

function bytesChunck(bytes32 source, uint start, uint numBytes) constant returns(uint _result){
            uint counter = 0;
            uint result;

            for(uint i = 0; i < numBytes; i++) {
                result += uint8(source[start + i]);
            }
            return result;
            // 
    }

luego simplemente convierto el resultado en los bytes necesarios, como bytes8(result). Pero parece estar desbordado, ya que si tengo como 8 bytes, los primeros bytes siempre son cero. ¿Algunas ideas? :)

Gracias.

Esto es un poco confuso. Cuando dice "guardar el orden", ¿quiere decir mantener los bytes en el orden original o quiere decir ordenarlos? Además, ¿puede darnos 5 vars que suman 32 bytes para que podamos saber lo que quiere? Por último, lo primero que se pensó es que sería mejor, si es posible, dividir los bytes grandes en estos cinco fragmentos antes de interactuar con el contrato. ¿Es realmente necesario realizar este paso dentro del contrato inteligente? Controlar el costo de la gasolina tiende a evitar este tipo de cosas en Solidity.
@RobHitchens gracias por el comentario. Me gustaría guardar el pedido original (no ordenar de nuevo). Agregaré muestras un poco más tarde.

Respuestas (1)

Tu pregunta no es lo suficientemente clara. Cuando desee dividir 32 bytes en 5 variables que tienen una longitud total de 2+2+2+2+8+1 = 17usted, debe especificar qué bytes desea dividir (bytes de la izquierda o bytes de la derecha).

Escribí un ejemplo que resuelve tu problema hasta donde pude entenderlo. Comente la respuesta: explique qué necesita exactamente y cambiaré el código.

pragma solidity ^0.4.0;

contract BytesChunkTest
{
    bytes32 constant public test_source=0x000000000000000000ff11223344556677889900aabbccddeeff;

    bytes32 constant mask1 = 0xff00000000000000000000000000000000000000000000000000000000000000;
    bytes32 constant mask2 = 0xffff000000000000000000000000000000000000000000000000000000000000;
    bytes32 constant mask8 = 0xffffffffffffffff000000000000000000000000000000000000000000000000;
    uint    constant main_shift=15;

    function sourceToChunk(bytes32 source) constant
    returns
        (
            bytes2 r1_2,
            bytes2 r2_2,
            bytes2 r3_2,
            bytes2 r4_2,
            bytes8 r5_8,
            bytes1 r6_1
        )
    {

        r1_2 = bytes2(source<<(main_shift*8)&mask2);
        r2_2 = bytes2((source<<(main_shift+2)*8)&mask2);
        r3_2 = bytes2((source<<(main_shift+4)*8)&mask2);
        r4_2 = bytes2((source<<(main_shift+6)*8)&mask2);
        r5_8 = bytes8((source<<(main_shift+8)*8)&mask8);
        r6_1 = bytes1((source<<(main_shift+16)*8)&mask1);
    }


    function test() constant
    returns
        (
            bytes2,
            bytes2,
            bytes2,
            bytes2,
            bytes8,
            bytes1
        )
    {
        return sourceToChunk(test_source);
    }
}
Convertir bytes32 a bytes2 ordenados, bytes4, etc.
RespuestasAquíPolítica de privacidad1y, 0v