build.yml

name: Build
on:
  push:
    branches:
      - fix/*
      - feature/*
      - release/*
      - develop
      - main
      - linux-builds-fix
jobs:
  build:
    runs-on: ${{ matrix.build-target.runner }}
    continue-on-error: false
    strategy:
      matrix:
        build-target:
          # =============
          # JSON Toolkit
          # =============

          # WASM Targets
          - crate: radix-engine-toolkit
            target-triple: wasm32-unknown-unknown
            runner: ubuntu-latest
          
          # ===============
          # UniFFI Toolkit
          # ===============

          # Linux Targets
          - crate: radix-engine-toolkit-uniffi
            target-triple: x86_64-unknown-linux-gnu
            runner: ubuntu-20.04
          - crate: radix-engine-toolkit-uniffi
            target-triple: aarch64-unknown-linux-gnu
            runner: ubuntu-latest
          
          # PC Targets
          - crate: radix-engine-toolkit-uniffi
            target-triple: x86_64-pc-windows-gnu
            runner: ubuntu-latest
          
          # Android Targets
          - crate: radix-engine-toolkit-uniffi
            target-triple: aarch64-linux-android
            runner: ubuntu-latest
          - crate: radix-engine-toolkit-uniffi
            target-triple: armv7-linux-androideabi
            runner: ubuntu-latest
          
          # MacOS Targets
          - crate: radix-engine-toolkit-uniffi
            target-triple: aarch64-apple-darwin
            runner: macos-latest
          - crate: radix-engine-toolkit-uniffi
            target-triple: x86_64-apple-darwin
            runner: macos-latest
          
          # iOS Targets
          - crate: radix-engine-toolkit-uniffi
            target-triple: x86_64-apple-ios
            runner: macos-latest
          - crate: radix-engine-toolkit-uniffi
            target-triple: aarch64-apple-ios
            runner: macos-latest
          - crate: radix-engine-toolkit-uniffi
            target-triple: aarch64-apple-ios-sim
            runner: macos-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Install Rust Target
        run: |
          # Install Nightly 
          rustup toolchain install nightly

          # Update both toolchains
          rustup update stable
          rustup update nightly

          # Add target
          rustup target install ${{ matrix.build-target.target-triple }}
          rustup +nightly target install ${{ matrix.build-target.target-triple }}

          # Install the nightly toolchain of the target of this machine.
          DEFAULT_TARGET=$(rustc -vV | sed -n 's|host: ||p')
          rustup component add rust-src --toolchain nightly-$DEFAULT_TARGET
      # - name: Cache Dependencies
      #   uses: mozilla-actions/sccache-action@v0.0.3
      # Installing Build Dependencies
      - name: Build Dependencies (aarch64 linux)
        if: ${{ matrix.build-target.target-triple == 'aarch64-unknown-linux-gnu' }}
        run: | 
          sudo apt-get update
          sudo apt-get install -y gcc-aarch64-linux-gnu
          echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
          echo "CC=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
          echo "AR=aarch64-linux-gnu-gcc-ar" >> $GITHUB_ENV
      - name: Build Dependencies (android)
        uses: nttld/setup-ndk@v1
        id: setup-ndk
        if: ${{ matrix.build-target.target-triple == 'aarch64-linux-android' || matrix.build-target.target-triple == 'armv7-linux-androideabi' }}
        with:
          ndk-version: r25b
      - name: Build Dependencies (aarch64 android)
        if: ${{ matrix.build-target.target-triple == 'aarch64-linux-android' }}
        env:
          ANDROID_NDK_HOME: ${{ steps.setup-ndk.outputs.ndk-path }}
        run: | 
          echo "CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android21-clang" >> $GITHUB_ENV
          echo "CC=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android21-clang" >> $GITHUB_ENV
          echo "AR=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar" >> $GITHUB_ENV
      - name: Build Dependencies (armv7 android)
        if: ${{ matrix.build-target.target-triple == 'armv7-linux-androideabi' }}
        env:
          ANDROID_NDK_HOME: ${{ steps.setup-ndk.outputs.ndk-path }}
        run: | 
          echo "CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi19-clang" >> $GITHUB_ENV
          echo "CC=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi19-clang" >> $GITHUB_ENV
          echo "AR=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar" >> $GITHUB_ENV
      - name: Build Dependencies (aarch64/x86_64 windows)
        if: ${{ matrix.build-target.target-triple == 'x86_64-pc-windows-gnu' }}
        run: | 
          sudo apt-get install -y mingw-w64
          echo "CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc" >> $GITHUB_ENV
          echo "CC=x86_64-w64-mingw32-gcc" >> $GITHUB_ENV
          echo "AR=x86_64-w64-mingw32-gcc-ar" >> $GITHUB_ENV
      - name: Build
        working-directory: ${{ matrix.build-target.crate }}
        # env:
        #   SCCACHE_GHA_ENABLED: "true"
        #   RUSTC_WRAPPER: "sccache"
        run: |
          cargo build \
            --target ${{ matrix.build-target.target-triple }} \
            --release
      - name: Clean Build Artifacts
        run: find "./${{ matrix.build-target.crate }}/target/${{ matrix.build-target.target-triple }}/release" -mindepth 1 -maxdepth 1 -type d -exec rm -r {} \;
      - name: Upload Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: ${{ matrix.build-target.crate }}-${{ matrix.build-target.target-triple }}
          path: "./${{ matrix.build-target.crate }}/target/${{ matrix.build-target.target-triple }}/release"
  generate-uniffi-bindings:
    needs: [build]
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Clone uniffi-bindgen-cs
        uses: actions/checkout@v3
        with:
          repository: radixdlt/uniffi-bindgen-cs
          path: uniffi-bindgen-cs
          submodules: 'recursive'
          ref: f1a6ef67449b47028fd5c3d8e5c6d3b80ddefd2b
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Generate the Bindings
        run: |
          # Generating the path of the dynamic library
          DYNAMIC_LIBRARY_PATH="./artifacts/radix-engine-toolkit-uniffi-x86_64-unknown-linux-gnu/libradix_engine_toolkit_uniffi.so"
          OUTPUT_DIRECTORY="./uniffi-bindings"

          for LANGUAGE in "swift" "kotlin" "python" 
          do
            cargo run \
              --manifest-path="./uniffi-bindgen/Cargo.toml" -- \
              generate ./radix-engine-toolkit-uniffi/src/radix_engine_toolkit_uniffi.udl \
              --language $LANGUAGE \
              --out-dir $OUTPUT_DIRECTORY \
              --lib-file $DYNAMIC_LIBRARY_PATH
          done

          cargo run \
            --manifest-path="./uniffi-bindgen-cs/bindgen/Cargo.toml" -- \
            ./radix-engine-toolkit-uniffi/src/radix_engine_toolkit_uniffi.udl \
            --out-dir $OUTPUT_DIRECTORY \
            --lib-file $DYNAMIC_LIBRARY_PATH
      - name: Upload Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: uniffi-bindings
          path: uniffi-bindings
  build-test-kit:
    needs: [build]
    runs-on: macos-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Generate Test Kit
        run: cargo run
        working-directory: generator
      - name: Upload Generated Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: "test-kit"
          path: "./generator/output"
  publish-swift-spm:
    needs: [build, generate-uniffi-bindings]
    runs-on: macos-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Checkout Swift Engine Toolkit
        uses: actions/checkout@v3
        with:
          repository: radixdlt/swift-engine-toolkit
          token: ${{ secrets.RADIX_BOT_PAT }}
          path: ./swift-engine-toolkit
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Build XCFramework
        working-directory: artifacts
        run: |
          PLISTBUDDY_EXEC="/usr/libexec/PlistBuddy"
          # The name of the crate that we will be creating the XCFramework and the bindings for.
          CRATE_NAME="radix-engine-toolkit-uniffi"
          
          # Creating the include directory - this will be used in the XCFramework build steps
          mkdir include
          cp uniffi-bindings/radix_engine_toolkit_uniffiFFI.h include/radix_engine_toolkit_uniffiFFI.h

          # Replace the generated module map with the one we actually want.
          echo "framework module RadixEngineToolkit {" > "./include/module.modulemap"
          echo "  umbrella header \"radix_engine_toolkit_uniffiFFI.h\"" >> "./include/module.modulemap"
          echo "  export *" >> "./include/module.modulemap"
          echo "  module * { export * }" >> "./include/module.modulemap"
          echo "}" >> "./include/module.modulemap"
          
          # Using Lipo to combine some of the libraries into fat libraries.
          mkdir ./macos-arm64_x86_64/
          mkdir ./ios-simulator-arm64_x86_64

          lipo -create \
              "./$CRATE_NAME-aarch64-apple-darwin/libradix_engine_toolkit_uniffi.dylib" \
              "./$CRATE_NAME-x86_64-apple-darwin/libradix_engine_toolkit_uniffi.dylib" \
              -o "./macos-arm64_x86_64/libradix_engine_toolkit_uniffi.dylib"
          lipo -create \
              "./$CRATE_NAME-aarch64-apple-ios-sim/libradix_engine_toolkit_uniffi.dylib" \
              "./$CRATE_NAME-x86_64-apple-ios/libradix_engine_toolkit_uniffi.dylib" \
              -o "./ios-simulator-arm64_x86_64/libradix_engine_toolkit_uniffi.dylib"
              
          for TARGET_TRIPLE in "$CRATE_NAME-aarch64-apple-ios"  "macos-arm64_x86_64" "ios-simulator-arm64_x86_64"
          do
            FRAMEWORK_PATH="$TARGET_TRIPLE/RadixEngineToolkit.framework"
            mkdir -p $FRAMEWORK_PATH/Headers
            mkdir -p $FRAMEWORK_PATH/Modules
             # Move the dylib into the framework, renaming it to match the framework name
            mv $TARGET_TRIPLE/libradix_engine_toolkit_uniffi.dylib $FRAMEWORK_PATH/RadixEngineToolkit
            # Copy headers to Headers folder and modulemap to Modules folder
            cp include/radix_engine_toolkit_uniffiFFI.h $FRAMEWORK_PATH/Headers/
            cp include/module.modulemap $FRAMEWORK_PATH/Modules/
            "$PLISTBUDDY_EXEC" -c "Add :CFBundleIdentifier string com.radixpublishing.RadixEngineToolkit" \
                            -c "Add :CFBundleName string RadixEngineToolkit" \
                            -c "Add :CFBundleDisplayName string RadixEngineToolkit" \
                            -c "Add :CFBundleVersion string 1.0.0" \
                            -c "Add :CFBundleShortVersionString string 1.0.0" \
                            -c "Add :CFBundlePackageType string FMWK" \
                            -c "Add :CFBundleExecutable string RadixEngineToolkit" \
                            -c "Add :MinimumOSVersion string 16.4" \
                            -c "Add :CFBundleSupportedPlatforms array" \
                            $FRAMEWORK_PATH/Info.plist
            case $TARGET_TRIPLE in
              aarch64-apple-ios)
                  "$PLISTBUDDY_EXEC" -c "Add :CFBundleSupportedPlatforms:0 string iPhoneOS" $FRAMEWORK_PATH/Info.plist
              ;;
              ios-simulator-arm64_x86_64)
                  "$PLISTBUDDY_EXEC" -c "Add :CFBundleSupportedPlatforms:0 string iPhoneOS" \
                                     -c "Add :CFBundleSupportedPlatforms:1 string iPhoneSimulator" \
                                      $FRAMEWORK_PATH/Info.plist
              ;;
              macos-arm64_x86_64)
                  "$PLISTBUDDY_EXEC" -c "Add :CFBundleSupportedPlatforms:0 string MacOSX" $FRAMEWORK_PATH/Info.plist
              ;;
              *)
              ;;
            esac
            
            install_name_tool -id @rpath/RadixEngineToolkit.framework/RadixEngineToolkit $FRAMEWORK_PATH/RadixEngineToolkit
          done
              
          # Creating the XCFramework
          xcodebuild -create-xcframework \
              -framework "./$CRATE_NAME-aarch64-apple-ios/RadixEngineToolkit.framework" \
              -framework "./macos-arm64_x86_64/RadixEngineToolkit.framework" \
              -framework "./ios-simulator-arm64_x86_64/RadixEngineToolkit.framework" \
              -output "RadixEngineToolkit.xcframework"

      - name: Publish to Swift Engine Toolkit
        run: |
          BRANCH=${{ github.ref_name }}
          BUILD_CRATE_MANIFEST="./radix-engine-toolkit-uniffi/Cargo.toml"
          CRATE_VERSION=$(cargo read-manifest --manifest-path $BUILD_CRATE_MANIFEST |  jq -r '.version')
          LAST_COMMIT_SHA=$(git rev-parse --short HEAD)
          SPM_VERSION="$CRATE_VERSION-$LAST_COMMIT_SHA"
          SET_UPSTREAM_FLAG=""

          cd swift-engine-toolkit
          REMOTE_BRANCH=$(git ls-remote --heads origin $BRANCH)

          if [ -z "$REMOTE_BRANCH" ]
          then
            git checkout -b $BRANCH
            # Allows creating branch on remote
            SET_UPSTREAM_FLAG="-u"
          else
            git fetch origin $BRANCH
            git checkout $BRANCH
            git pull origin $BRANCH
          fi

          cp -R ../artifacts/RadixEngineToolkit.xcframework ./Sources/RadixEngineToolkit
          cp -R ../artifacts/uniffi-bindings/radix_engine_toolkit_uniffi.swift ./Sources/EngineToolkit/radix_engine_toolkit_uniffi.swift
          
          sed -i "" -E 's/[[:<:]]radix_engine_toolkit_uniffiFFI[[:>:]]/RadixEngineToolkit/g' ./Sources/EngineToolkit/radix_engine_toolkit_uniffi.swift

          git add .
          git commit -m "Update RET from $BRANCH - $LAST_COMMIT_SHA"
          git tag -a $SPM_VERSION -m "RET update from $BRANCH - $LAST_COMMIT_SHA"
          git push $SET_UPSTREAM_FLAG origin $BRANCH
          git push origin $SPM_VERSION
      - name: Upload Artifacts
        uses: actions/upload-artifact@v3
        with:
          name: "RadixEngineToolkit.xcframework"
          path: "./artifacts/RadixEngineToolkit.xcframework"
  publish-kotlin-maven:
    needs: [build, generate-uniffi-bindings]
    runs-on: macos-latest
    permissions:
      contents: read
      packages: write
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Create Kotlin Library
        working-directory: interop/kotlin
        run:
          ./bootstrap.sh
      - name: Setup Gradle
        uses: gradle/gradle-build-action@v2
        with:
          gradle-version: 8.0.2
          arguments: wrapper -p interop/kotlin/ret-kotlin
      - name: Build and publish Kotlin
        uses: gradle/gradle-build-action@v2
        with:
          arguments: build publish
          build-root-directory: interop/kotlin/ret-kotlin
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  publish-android-maven:
    needs: [build, generate-uniffi-bindings]
    runs-on: macos-latest
    permissions:
      contents: read
      packages: write
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Set up JDK 1.8
        uses: actions/setup-java@v3
        with:
          distribution: 'adopt'
          java-version: '17'
      - name: Setup Android SDK
        uses: android-actions/setup-android@v2
      - name: Create Android Library
        working-directory: interop/android
        run:
          ./bootstrap.sh
      - name: Setup Gradle
        uses: gradle/gradle-build-action@v2
        with:
          gradle-version: 8.0.2
          arguments: wrapper -p interop/android/ret-android
      - name: Build and publish Android
        uses: gradle/gradle-build-action@v2
        with:
          arguments: build publish
          build-root-directory: interop/android/ret-android
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  publish-dotnet-nuget:
    needs: [build, generate-uniffi-bindings]
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Setup .NET SDK
        uses: actions/setup-dotnet@5a3fa01c67e60dba8f95e2878436c7151c4b5f01
        with:
          dotnet-version: 7.0.x
      - name: Configure Version
        run: |
          BRANCH=${{ github.ref_name }}
          BUILD_CRATE_MANIFEST="./radix-engine-toolkit-uniffi/Cargo.toml"
          CRATE_VERSION=$(cargo read-manifest --manifest-path $BUILD_CRATE_MANIFEST |  jq -r '.version')
          LAST_COMMIT_SHA=$(git rev-parse --short HEAD)
          VERSION="$CRATE_VERSION-commit-$LAST_COMMIT_SHA"

          sed -i "s/\(<version>\)[^<>]*\(<\/version>\)/\1$VERSION\2/g" ./interop/csharp/RadixDlt.RadixEngineToolkit.nuspec

          echo "Configured Version: $VERSION"
      - name: Copying UniFFI Bindings
        run: |
          # We copy the UniFFI bindings to the interop/csharp/generated/ directory
          mkdir ./interop/csharp/generated
          cp ./artifacts/uniffi-bindings/radix_engine_toolkit_uniffi.cs ./interop/csharp/generated
      - name: Copying Libraries
        run: |
          # We copy the UniFFI bindings to the interop/csharp/native directory
          mkdir ./interop/csharp/native

          mkdir ./interop/csharp/native/x86_64-unknown-linux-gnu
          cp ./artifacts/radix-engine-toolkit-uniffi-x86_64-unknown-linux-gnu/libradix_engine_toolkit_uniffi.so ./interop/csharp/native/x86_64-unknown-linux-gnu
          
          mkdir ./interop/csharp/native/aarch64-unknown-linux-gnu
          cp ./artifacts/radix-engine-toolkit-uniffi-aarch64-unknown-linux-gnu/libradix_engine_toolkit_uniffi.so ./interop/csharp/native/aarch64-unknown-linux-gnu
          
          mkdir ./interop/csharp/native/x86_64-apple-darwin
          cp ./artifacts/radix-engine-toolkit-uniffi-x86_64-apple-darwin/libradix_engine_toolkit_uniffi.dylib ./interop/csharp/native/x86_64-apple-darwin
          
          mkdir ./interop/csharp/native/aarch64-apple-darwin
          cp ./artifacts/radix-engine-toolkit-uniffi-aarch64-apple-darwin/libradix_engine_toolkit_uniffi.dylib ./interop/csharp/native/aarch64-apple-darwin
          
          mkdir ./interop/csharp/native/x86_64-pc-windows-gnu
          cp ./artifacts/radix-engine-toolkit-uniffi-x86_64-pc-windows-gnu/radix_engine_toolkit_uniffi.dll ./interop/csharp/native/x86_64-pc-windows-gnu
      - name: NuGet Pack
        working-directory: interop/csharp/
        run: dotnet pack --configuration Release --output .
      - name: Publish Packages
        working-directory: interop/csharp/
        run: dotnet nuget push RadixDlt.RadixEngineToolkit.*.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_ORG_API_KEY }}
  publish-python-package:
    needs: [build, generate-uniffi-bindings]
    runs-on: ubuntu-latest
    permissions:
      contents: read
      id-token: write
      packages: write
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Fetch secrets
        uses: radixdlt/public-iac-resuable-artifacts/fetch-secrets@main
        with:
          role_name: ${{ secrets.PYPI_SECRET_ROLE_NAME }}
          app_name: 'radix-engine-toolkit'
          step_name: 'pypi-credentials'
          secret_prefix: 'PYPI'
          secret_name: ${{ secrets.PYPI_SECRET_NAME }}
          parse_json: true
      - uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Set up Python 3.11
        uses: actions/setup-python@v4
        with:
          python-version: 3.11
      - name: Install Dependencies
        run: | 
          python3 -m pip install black build twine
          sudo apt-get install mypy
      - name: Copy bindings
        run: |
          mkdir ./interop/python/radix_engine_toolkit
          cp \
            ./artifacts/uniffi-bindings/radix_engine_toolkit_uniffi.py \
            ./interop/python/radix_engine_toolkit/__init__.py
      - name: Dynamic Library Script replacement
        run: |
          python3 ./interop/python/replacement.py ./interop/python/radix_engine_toolkit/__init__.py
          rm ./interop/python/replacement.py
      - name: Stubs generation
        run: |
          stubgen \
            ./interop/python/radix_engine_toolkit/__init__.py \
            --output ./interop/python/
      - name: Code Formatting
        run: |
          black ./interop/python/
      - name: Copy Dynamic Libraries
        run: |
          cp \
            ./artifacts/radix-engine-toolkit-uniffi-aarch64-apple-darwin/libradix_engine_toolkit_uniffi.dylib \
            ./interop/python/radix_engine_toolkit/aarch64-apple-darwin
          cp \
            ./artifacts/radix-engine-toolkit-uniffi-x86_64-apple-darwin/libradix_engine_toolkit_uniffi.dylib \
            ./interop/python/radix_engine_toolkit/x86_64-apple-darwin
          cp \
            ./artifacts/radix-engine-toolkit-uniffi-aarch64-unknown-linux-gnu/libradix_engine_toolkit_uniffi.so \
            ./interop/python/radix_engine_toolkit/aarch64-unknown-linux-gnu
          cp \
            ./artifacts/radix-engine-toolkit-uniffi-x86_64-unknown-linux-gnu/libradix_engine_toolkit_uniffi.so \
            ./interop/python/radix_engine_toolkit/x86_64-unknown-linux-gnu
          cp \
            ./artifacts/radix-engine-toolkit-uniffi-x86_64-pc-windows-gnu/radix_engine_toolkit_uniffi.dll \
            ./interop/python/radix_engine_toolkit/x86_64-pc-windows-gnu
      - name: Build Package
        working-directory: ./interop/python/
        run: python3 -m build 
      - name: Check Builds
        working-directory: ./interop/python/
        run: |
          python3 -m twine check dist/*
      - name: Publish
        working-directory: ./interop/python/
        env:
          TWINE_USERNAME: ${{ env.PYPI_USERNAME }}
          TWINE_PASSWORD: ${{ env.PYPI_PASSWORD }}
        run: |
          python3 -m twine upload dist/*