public SerializedBundle(byte[] _data)
                {
                    byte32         = new Byte32();
                    bytesVec2      = new ByteVector2();
                    bytesVec3      = new ByteVector3();
                    SerializedData = _data;
                    BufIdx         = 0;


                    var totalLen = byte32.ReadInt(SerializedData, ref BufIdx);

                    var version = byte32.ReadInt(SerializedData, ref BufIdx);

                    var vertexCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    Vertices = DeserializeVectors(vertexCount);

                    var triangleCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    Triangles = DeserializeTris(triangleCount);

                    var hullSitesCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    HullSites = DeserializeHullSites(hullSitesCount);

                    var siteCornerCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    SiteCorners = DeserializeSiteCorners(siteCornerCount);

                    var siteNeighborsCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    SiteNeighbors = DeserializeSiteNeighbors(siteNeighborsCount);

                    var sitePositionsCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    SitePositions = DeserializeSitePositions(sitePositionsCount);

                    var sitesHavingCornerCount = byte32.ReadInt(SerializedData, ref BufIdx);

                    SitesHavingCorner = DeserializeSitesHavingCorner(sitesHavingCornerCount);
                }
        public static unsafe void curve25519_donna(byte *mypublic, byte *secret, byte *basepoint)
        {
            Long19 bp    = new Long19();
            Long19 x     = new Long19();
            Long19 z     = new Long19();
            Long19 zmone = new Long19();
            Byte32 e     = new Byte32();
            int    i;

            for (i = 0; i < 32; ++i)
            {
                e.Items[i] = secret[i];
            }
            e.Items[0]  &= 248;
            e.Items[31] &= 127;
            e.Items[31] |= 64;

            fexpand(bp.Items, basepoint);
            cmult(x.Items, z.Items, e.Items, bp.Items);
            crecip(zmone.Items, z.Items);
            fmul(z.Items, x.Items, zmone.Items);
            freduce_coefficients(z.Items);
            fcontract(mypublic, z.Items);
        }
Exemple #3
0
    unsafe void testSizeof()
    {
        Debug.Log(sizeof(Byte1));
        Debug.Log(sizeof(Byte2));
        Debug.Log(sizeof(Byte4));
        Debug.Log(sizeof(Byte8));
        Debug.Log(sizeof(Byte16));
        Debug.Log(sizeof(Byte32));
        Debug.Log(sizeof(Byte64));
        Debug.Log(sizeof(Byte128));
        Debug.Log(sizeof(Byte256));
        Debug.Log(sizeof(Byte512));
        Debug.Log(sizeof(Byte1024));
        Debug.Log(sizeof(Byte2048));
        Debug.Log(sizeof(Byte4096));
        Debug.Log(sizeof(Byte8192));

        var a1    = new Byte1[2];
        var a2    = new Byte2[2];
        var a4    = new Byte4[2];
        var a8    = new Byte8[2];
        var a16   = new Byte16[2];
        var a32   = new Byte32[2];
        var a64   = new Byte64[2];
        var a128  = new Byte128[2];
        var a256  = new Byte256[2];
        var a512  = new Byte512[2];
        var a1024 = new Byte1024[2];
        var a2048 = new Byte2048[2];
        var a4096 = new Byte4096[2];
        var a8192 = new Byte8192[2];

        fixed(Byte1 *ptr = a1)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte2 *ptr = a2)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte4 *ptr = a4)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte8 *ptr = a8)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte16 *ptr = a16)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        };
        fixed(Byte32 *ptr = a32)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte64 *ptr = a64)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte128 *ptr = a128)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte256 *ptr = a256)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte512 *ptr = a512)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte1024 *ptr = a1024)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte2048 *ptr = a2048)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte4096 *ptr = a4096)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte8192 *ptr = a8192)
        {
            Debug.Log((int)(ptr + 1) - (int)ptr);
        }

        fixed(Byte8192 *ptr = a8192)
        {
            Byte16 *ptr2 = (Byte16 *)ptr;

            Debug.Log((int)(ptr2 + 1) - (int)ptr2);
        }
    }
                public SerializedBundle(TerraMesh _tm)
                {
                    Version = CUR_VERSION;

                    //Vector3 -- 12 bytes
                    Vertices = _tm.Vertices; //TODO Broken
                    //int - 4 bytes
                    Triangles = _tm.Triangles;
                    //int - 4 bytes
                    HullSites = _tm.HullSites;
                    //3 ints - 12 bytes
                    SiteCorners = _tm.SiteCorners;
                    //3 ints - 12 bytes
                    SiteNeighbors = _tm.SiteNeighbors;
                    //Vector3 -- 12 bytes
                    //SitePositions = _tm.SitePositions; //TODO BROKEN
                    //Variable -- need to track length for each set
                    SitesHavingCorner = _tm.SitesHavingCorner;

                    var totalSetCount = 0;

                    for (var cornerIdx = 0; cornerIdx < SitesHavingCorner.Length; ++cornerIdx)
                    {
                        totalSetCount += _tm.SitesHavingCorner[cornerIdx].Count;
                    }

                    var dataLen = sizeof(int);                           //Total size header

                    dataLen += sizeof(int);                              // Version
                    dataLen += sizeof(int);                              // Vertex count header
                    dataLen += Vertices.Length * sizeof(float) * 2;      // Vector2
                    dataLen += sizeof(int);                              // Triangle count header
                    dataLen += Triangles.Length * sizeof(int);           //int
                    dataLen += sizeof(int);                              // HullSites count header
                    dataLen += HullSites.Length * sizeof(int);           //int
                    dataLen += sizeof(int);                              // SiteCorners count header
                    dataLen += SiteCorners.Length * sizeof(int) * 3;     //int * 3
                    dataLen += sizeof(int);                              // SiteNeighbors count header
                    dataLen += SiteNeighbors.Length * sizeof(int) * 3;   // int * 3
                    dataLen += sizeof(int);                              // SitePositions count header
                    dataLen += SitePositions.Length * sizeof(float) * 3; // Vector3
                    dataLen += sizeof(int);                              // Site having corner set count
                    dataLen += SitesHavingCorner.Length * sizeof(int);   //Site Having corner count headers
                    dataLen += totalSetCount * sizeof(int);              //Sites having corner set indexes

                    SerializedData = new byte[dataLen];
                    BufIdx         = 0;

                    byte32    = new Byte32();
                    bytesVec2 = new ByteVector2();
                    bytesVec3 = new ByteVector3();

                    byte32.Write(SerializedData, ref BufIdx, dataLen);
                    byte32.Write(SerializedData, ref BufIdx, Version);
                    SerializeVertices(ref BufIdx, SerializedData);
                    SerializeTris(ref BufIdx, SerializedData);
                    SerializeHullSites(ref BufIdx, SerializedData);
                    SerializeSiteCorners(ref BufIdx, SerializedData);
                    SerializeSiteNeighbors(ref BufIdx, SerializedData);
                    SerializeSitePositions(ref BufIdx, SerializedData);
                    SerializeSitesHavingCorner(ref BufIdx, SerializedData);
                }
Exemple #5
0
        internal static void curve25519_donna(byte* mypublic, byte* secret, byte* basepoint)
        {
            Long19 bp = new Long19();
            Long19 x = new Long19();
            Long19 z = new Long19();
            Long19 zmone = new Long19();
            Byte32 e = new Byte32();
            int i;

            for (i = 0; i < 32; ++i)
                e.Items[i] = secret[i];
            e.Items[0] &= 248;
            e.Items[31] &= 127;
            e.Items[31] |= 64;

            fexpand(bp.Items, basepoint);
            cmult(x.Items, z.Items, e.Items, bp.Items);
            crecip(zmone.Items, z.Items);
            fmul(z.Items, x.Items, zmone.Items);
            freduce_coefficients(z.Items);
            fcontract(mypublic, z.Items);
        }
Exemple #6
0
 public ISignature CtSign(List <Byte64> cTransactionEntries, IPrivateKey privateKey, Byte32 blinding)
 {
     throw new System.NotImplementedException();
 }
Exemple #7
0
 public Byte64 CTransactionEntry(IPublicKey publicKey, Byte32 value, Byte32 blinding, Byte32 totalFees, int noParticipants)
 {
     throw new System.NotImplementedException();
 }
Exemple #8
0
 public bool VerifyRangeProof(byte[] rangeproof, Byte32 oldCommitment, Byte32 deltaCommitment)
 {
     throw new System.NotImplementedException();
 }
Exemple #9
0
 public byte[] GenerateRangeProof(Byte32 value, Byte32 blinding)
 {
     throw new System.NotImplementedException();
 }
Exemple #10
0
 public Byte32 GeneratePedersenCommitment(Byte32 value, Byte32 blinding)
 {
     throw new System.NotImplementedException();
 }