GoGoX (formerly GoGoVan) is the first app-based logistics platform in Asia committed to providing extensive logistics services through innovative technology. You can hire a van by using GoGoX mobile app or website anywhere anytime.

GoGoX Hong Kong | Van Hiring, Same Day Delivery, Courier Partner ...

GoGoX is an app-based platform providing delivery service for different countries in Asia.

GoGoX - Crunchbase Company Profile & Funding

In July 2020, entering its seventh anniversary, in order to convey the company&#x27;s long-term development strategy as well as to build a clear market positioning, GoGoVan officially rebranded to GOGOX.

GOGOX - Wikipedia

Information on acquisition, funding, cap tables, investors, and executives for GOGOX. Use the PitchBook Platform to explore the full profile.

GOGOX Company Profile: Acquisition & Investors | PitchBook

Steven will also tackle the challenges ... If you&#x27;re in Hanoi on 30 October, join us for insights that could reshape your company&#x27;s future. #VietnamVentureSummit #TalentAcquisition #GoGoX #Innovation #Entrepreneurship #GlobalLocal...

GoGoX | LinkedIn

About Us - GoGoX HK

GOGOX has 5 employees across 5 locations and $276.54 m in total funding,. See insights on GOGOX including office locations, competitors, revenue, financials, executives, subsidiaries and more at Craft.

GOGOX Company Profile - Office Locations, Competitors, Revenue, ...

We analyze your business needs and provide you with customised solutions. Tailor-made for e-commerce &amp; retail, event, food delivery, freight forwarder, etc.

GoGoX Hong Kong| Customised business solution

GOGOX symbolically reflects the company&#x27;s diligence to provide eXtraordinary eXperienceOrder Now · GOGOX being one of the largest logistics platforms in Asia Pacific, has all the eXpertise needed to drive eXponential growth for your businessRegister Now

Business Logistics Services Provider - GoGoX India

Our service provides you with flexible deployment of GoGoX’s extensive driver network. Without managing your own fleet, the company’s fixed cost is minimised. Even in peak seasons, our 100% order completion rate frees you from worrying about the inability to fulfil high logistics demand.

GoGoX Hong Kong | Retail Industry | Increase business efficiency

About Us GOGOX is a leading on-demand logistics and transportation platform that operates in Asia. We use technology to power […]

GoGoX Careers - GoGoX HK

Owler&#x27;s exclusive company and industry insights make it easy to find and monitor competitors, prospects, and key accounts – so you can increase your revenue and grow your business.

GOGOX - Owler

Founded in 2013 by Steven Lam, Nick Tang and Reeve Kwan, GogoX operates an on-demand delivery services platform that now has over 27.6 million shippers and 5.2 million drivers. The company says it operates in more than 340 cities across Hong Kong, mainland China, Singapore, South Korea and India.

GogoX, Hong Kong’s First Tech Unicorn Startup, Slumps In Trading ...

GOGOX is an app-based platform for moving and delivering goods in Asia. The company connects individuals and businesses directly to thousands of drivers and couriers for their delivery needs.On August 28th, 2018, GOGOX was merged with Kuaigou Dache.

GOGOX - Headquarters Locations, Products, Competitors, Financials, ...

GoGoX(formerly GoGoVan)is the first app-based platform dedicated to offering excellent, convenient and efficient delivery service in Asia.

GoGoX Hong Kong| About Us

GOGOX is the first on-demand logistics and transportation platform in Asia

GOGOX

Recently, Gogoro just rolled out on all new electric scooter called the Gogoro 2 Smartscooter along with its plans to add a of more than 500 battery stations to the already existing 350 all over . Looking back, just 2 years ago was when Gogoro revealed itself to the world and was known to the world as the Tesla on two wheels. network Taiwan Gogoro Smartscooters Gogoro is an emission free scooter that runs solely on electricity thanks to the Panasonic Lithium Ion 18650 battery. Gogoro’s existence stems from the hardships of living in a populated city with air pollution, sky rocketing gas prices, and the cram-full roads that brings peaking traffic. Many people who live in densely populated cities resort to scooters as transportation but scooters still run on expensive gas and emit CO2. Given these reasons, Gogoro hopes to be the replacement for scooters and aims to be the perfect transportation in densely populated cities. What makes Gogoro’s Smartscooter so special besides running 100% on electricity is its charging design. Instead of plugging into an outlet to recharge, the Smartscooter runs on swappable batteries. This battery swapping design is well supported by the Gogoro Energy Network. The Gogoro Energy Network is a modular battery swapping infrastructure designed to be deployed everywhere like gas stations. Riders would be able to swap out depleted batteries at this network for a monthly subscription fee. For example, if a rider is running out of battery, he or she could pull up to a battery station and exchange the low battery for a new one, refueling the vehicle in a matter of seconds. Additionally, Gogoro’s smart phone app would provide information on the vehicle’s battery level, the nearest swap stations, and the correct statistics on battery reservations. Gogoro Battery Charging Station Why we need Gogoro? Some of the world’s biggest cities are getting larger. According to the , 54% of the world’s population today lives in urban areas and is expected to increase to 66% by 2050. With so many people cramped in small areas, they will need effective and reliable transportation that doesn’t put weight on the environment. United Nations Gogoro will be the key to solving city pollution and traffic density by providing “a more intelligent and adaptive system for today’s most dynamic cities”. Like Tesla, Gogoro has bigger plans for its batteries and network of charging stations. According to Gogoro, the company now has a GoStation less than every 1.3 kilometer in Taipei. Additionally, Gogoro envisions its batteries to be able to be the power sources for data centers, homes, and offices with the confidence that its low-cost technology can better perform than a traditional lead acid battery. According to Gogoro, a charged battery at 50% to 75% capacity can power a house for an hour, a laptop for 25 hours, a home furnace for an evening, or server rack with 40 servers for 20 minutes. Infamous Gogoro Battery Packs What makes Gogoro an unique hardware startup? In many ways Gogoro is similar to Tesla. Gogoro, though transforming the traditional concept of scooter and transportation, is more of a technology company than a vehicle company. Like Tesla, Gogoro does not sell through dealerships but instead has its own stores that showcase its Gogoro Smartscooters, batteries, phone app, and charging stations. Image by SlashGear Gogoro Smartscooters are not just vehicles for transportation. There are 30 sensors on the scooter including a digital compass, a shock sensor, and a thermal sensor. The Gogoro Smartscooter can analyze riding patterns, optimize energy use, and dim its lights when necessary to maximize energy. Every 10 minutes, the scooter uploads information on its condition online. Riders can also download sound effects and lighting patterns to further customize their scooters. Everything creative and versatile can be done through its smartphone app. The co-founder of Gogoro, Horace Luke, comes from a background of being the chief innovation officer at HTC, a mobile phone and consumer electronics company. Horace Luke had visions of making Gogoro more than just a scooter, putting most things you can find and use on your smartphone on Gogoro as well. Display of Gogoro’s smartphone app. Gogoro’s Tomorrow & Upcoming Challenges. Despite their rapid success, Gogoro and its charging network is now facing the classic chicken and the egg problem. Like Tesla, Gogoro has the problem that people won’t buy scooters if the swap stations aren’t available, but it doesn’t make sense to do a mass rollout of swap stations without potential customers. For Gogoro, each swap station costs less than $10,000, which is a significant advantage over Tesla’s $500,000 cost of a car battery swap station. Gogoro is more likely to be able to afford to do a big rollout and then wait for the customers to come. Gogoro also needs to find cities that are willing to adopt its scooters and charging stations. Horace Luke says that Gogoro is in talks with a number of urban areas and that it has enough capital to launch in one or two big cities. However. cities needs to have the right population density and the population has to recognise electric scooters as the key to a better future. Some cities in Southeast Asia where scooters are already ubiquitous might potentially work in Gogoro’s favour. A smaller city like San Francisco or Amsterdam could also work. However, Gogoro would have to do a lot of work convincing the population that scooters are the most effective means of transportation. In whichever launch cities it chooses, Gogoro will also have to work out the complicated logistics of figuring out where the swap stations go. To sums things up, Gogoro launched a vehicle and powers it with a citywide network of proprietary battery swapping stations. These vehicles have integrated systems that make it them comparable to IoT gadgets. Gogoro’s batteries will be sold for other purposes while combating pollution by reducing smog, balancing power grids, and clearing city traffics. This seems like a lot to do, but to change the world and put it in a better place, maybe this is what you have to offer. is the Co-Founder of , a new age product development and sourcing management firm that focuses on manufacturing and go-to market strategies. Jasper Chou LYNKD

Taiwan Startup Gogoro aka The Scooter of Tesla

This tutorial shows you how to deploy and automate a Docker container using Pulumi in Google Cloud Platform's Cloud Run with minimum permissions. Here's the GitHub Repository for reference: https://github.com/superjose/deploy-to-cloud-run-go Get the CLIs: . Create a Google Cloud Account Install Google Cloud CLI Install Pulumi CLI - We need it to build the Docker container. Install Docker Bootstrap the project: Create a directory: pulumi mkdir pulumi Run to initialize a pulumi project with Go (It can be your language of choice pulumi new go Navigate to the directory. pulumi cd pulumi Navigate to and create a new project. cloud.google.com Take note of the (Usually the project's name). project-id Generate the necessary permissions using gcloud CLI Login with the Google Auth CLI: gcloud auth login (Optional) Set the project in google cloud CLI (Can be changed anytime). This saves you from passing into every command. --project [PROJECT-ID] gcloud If your machine has multiple GCP projects, skip this step and pass the flag into every command. --project gcloud Create a service account (The account that Pulumi will connect to): gcloud iam service-accounts create pulumi-gcp --description="Pulumi GCP" Download the credentials for the service accounts and store them locally (Remember to replace with your GCP Project Id): [PROJECT-ID] gcloud iam service-accounts keys create ~/keys/gcp/pulumi-service-account-key-file.json --iam-account=pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com Set Pulumi's gcp credentials config path:
(This will connect the service account with Pulumi) pulumi config set gcp:credentials ~/keys/gcp/pulumi-service-account-key-file.json Set the GCP Project by doing: pulumi config set gcp:project [PROJECT-ID] Create a file (Inside the dir) and add the required permissions in : roles.gcp.yml pulumi includedPermissions # https://cloud.google.com/iam/docs/creating-custom-roles#creating
# Yaml to define the Pulumi GCP Roles that need to be created with gcloud CLI
title: Pulumi GCP Roles
description: |
 This policy ensures that all GCP roles are created using Pulumi.
stage: GA
# https://cloud.google.com/iam/docs/permissions-reference
includedPermissions:
 - serviceusage.services.list
 - serviceusage.services.enable
 - serviceusage.services.disable
 - serviceusage.services.get
 - serviceusage.services.use
 # Permissions for GCR
 - storage.objects.create
 - storage.objects.delete # Optional: only include if you need to delete images
 - storage.objects.get
 # Permissions for Google Artifact Registry
 - artifactregistry.repositories.create
 - artifactregistry.repositories.delete
 - artifactregistry.repositories.get
 - artifactregistry.repositories.list
 - artifactregistry.repositories.update
 - artifactregistry.repositories.downloadArtifacts
 - artifactregistry.repositories.uploadArtifacts
 - artifactregistry.repositories.deleteArtifacts
 # Permissions
 # Permissions
 - run.services.create
 - run.services.get
 - run.services.list
 - run.services.update
 - run.services.delete
 - run.services.getIamPolicy
 - run.services.setIamPolicy
 - iam.serviceAccounts.actAs
# NOTE: This should be removed the first time you're creating a role.
# This etag is to update the current active role (As GCP lets you manage multiple roles)
# I'm commenting it out so I can always replace the role
# etag: BwYS74Xx5y4= Create the with the file above:
(We assume we're running this code from the directory) pulumi_admin_role pulumi gcloud iam roles create pulumi_admin_role --project=[PROJECT-ID] --file='./roles.gcp.yml' In case you need to make edits, change the file and use: gcloud iam roles update pulumi_admin_role --project=[PROJECT-ID] --file='./roles.gcp.yml' We're also adding the role (I haven't found a better way) (Otherwise we'd get 403 errors when refreshing and updating in Pulumi)1 serviceAccountAdmin gcloud projects add-iam-policy-binding [PROJECT-ID] --role roles/iam.serviceAccountAdmin --member serviceAccount:pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com (The following will add the new role to the service account) gcloud projects add-iam-policy-binding [PROJECT-ID] --role projects/[PROJECT-ID]/roles/pulumi_admin_role --member serviceAccount:pulumi-gcp@[PROJECT-ID].iam.gserviceaccount.com Our in the directory:
(Check the code for comments!) main.go pulumi We enable the required services (Artifact Registry, and Cloud Run). Artifact Registry is used to host the docker container image. Cloud Runner will launch the Docker image from Artifact Registry. We build the docker image locally (We specify the platform in case you're using an ARM chip like M1, M2, Snapdragon SQ, X Elite, etc.) We create a chain of "DependsOn" to notify Pulumi:
5.1 Services need to be enabled first
5.2 We create the Artifact Repository
5.3 We build the docker image and push it to Artifact Registry.
5.4 We pull the Docker Image from Artifact Registry and run it.
5.5 We add IAM permissions so it can be accessed from anywhere. package main

import (
	"errors"
	"log"
	"os"

	"github.com/joho/godotenv"
	"github.com/pulumi/pulumi-docker/sdk/v3/go/docker"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/artifactregistry"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudrun"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// This is the name you created in Google Cloud Platform (GCP).
const gcpProjectId = "deploy-to-cloud-run-go"

// The Docker Image Name
const dockerImageName = "my-app-docker"
const artifactRegistryServiceName = "artifact-registry-api"
const artifactRegistryRepoName = "my-app-artifact-repo"
const artifactRegistryRepoLocation = "us-east1"
const cloudRunAdminServiceName = "cloud-run-admin-service"
const cloudRunServiceName = "cloud-run-service"

// For more info: https://cloud.google.com/run/docs/locations
const cloudRunLocation = "us-east1"

// The tag for the Docker image
const imageTag = "latest"

// This is a url like: us-east1-docker.pkg.dev
// It is used to push the Docker image to Google Container Registry
// For more info: https://cloud.google.com/container-registry/docs/pushing-and-pulling
// The format is: <region>-docker.pkg.dev
var dockerGCPServer = cloudRunLocation + "-docker.pkg.dev"

// The full path to the Docker image
// It is used to deploy the Docker image to Google Cloud Run
// The format is: <region>-docker.pkg.dev/<project-id>/<repo-name>/<image-name>:<tag>
// For more info: https://cloud.google.com/run/docs/deploying
// Example: us-east1-docker.pkg.dev/deploy-to-cloud-run-go/my-app--artifact-repo/my-app-docker:latest
var dockerImageWithPath = dockerGCPServer + "/" + gcpProjectId + "/" + artifactRegistryRepoName + "/" + dockerImageName + ":" + imageTag

func main() {

	// Load the .env file
	err := godotenv.Load()

	if err != nil {
		log.Fatal("Error loading .env file")
	}

	pulumi.Run(func(ctx *pulumi.Context) error {

		enabledServices, serviceResultErr := enableServices(ctx)

		if serviceResultErr != nil {
			return serviceResultErr
		}

		artifactRegistryRepo, createArtifactErr := createArtifactRegistryNewRepository(ctx, &enabledServices)
		if createArtifactErr != nil {
			return createArtifactErr
		}

		dockerImage, buildAndPushErr := buildAndPushToContainerRegistry(ctx, &enabledServices, artifactRegistryRepo)

		if buildAndPushErr != nil {
			return buildAndPushErr
		}

		deployContainerErr := deployContainerToCloudRun(ctx, &enabledServices, dockerImage)

		if deployContainerErr != nil {
			return deployContainerErr
		}

		return nil
	})
}

type EnabledServices struct {
	CloudRunService *projects.Service `pulumi:"cloudRunService"`
	ArtifactRegistryService *projects.Service `pulumi:"artifactRegistryService"`
}

func enableServices(ctx *pulumi.Context) (EnabledServices, error) {

	cloudRunService, cloudRunAdminErr := projects.NewService(ctx, cloudRunAdminServiceName, &projects.ServiceArgs{
		Service: pulumi.String("run.googleapis.com"),
		Project: pulumi.String(gcpProjectId),
	})

	if cloudRunAdminErr != nil {
		return EnabledServices{}, cloudRunAdminErr
	}

	artifactRegistryService, err := projects.NewService(ctx, artifactRegistryServiceName, &projects.ServiceArgs{
		Service: pulumi.String("artifactregistry.googleapis.com"),
	})

	if err != nil {
		return EnabledServices{}, err
	}
	return EnabledServices{
		CloudRunService: cloudRunService,
		ArtifactRegistryService: artifactRegistryService,
	}, nil
}

func createArtifactRegistryNewRepository(ctx *pulumi.Context, enabledServices *EnabledServices) (*artifactregistry.Repository, error) {

	if enabledServices == nil || enabledServices.ArtifactRegistryService == nil {
		return nil, errors.New("enabledServices cannot be nil")
	}

	dependingResources := []pulumi.Resource{
		enabledServices.ArtifactRegistryService,
	}

	repo, err := artifactregistry.NewRepository(ctx, artifactRegistryRepoName, &artifactregistry.RepositoryArgs{
		Location: pulumi.String(artifactRegistryRepoLocation),
		RepositoryId: pulumi.String(artifactRegistryRepoName),
		Format: pulumi.String("DOCKER"),
		Description: pulumi.String("The repository that will hold social-log Docker images."),
	}, pulumi.DependsOn(dependingResources))

	if err != nil {
		return nil, err
	}

	return repo, nil
}

func buildAndPushToContainerRegistry(ctx *pulumi.Context, enabledServices *EnabledServices, artifactRegistryRepo *artifactregistry.Repository) (*docker.Image, error) {

	if enabledServices == nil || enabledServices.ArtifactRegistryService == nil {
		return nil, errors.New("enabledServices cannot be nil")
	}

	if artifactRegistryRepo == nil {
		return nil, errors.New("artifactRegistryRepo cannot be nil")
	}

	// Lookup GOOGLE_CREDENTIALS environment variable which should hold the path to the JSON key file
	jsonKeyPath, present := os.LookupEnv("GOOGLE_CREDENTIALS_FILE_PATH")
	if !present {
		return nil, errors.New("GOOGLE_CREDENTIALS_FILE_PATH environment variable is not set")
	}

	// Read the JSON key file
	jsonKey, err := os.ReadFile(jsonKeyPath)
	if err != nil {
		return nil, err
	}

	dependingSources := []pulumi.Resource{
		enabledServices.ArtifactRegistryService,
		artifactRegistryRepo,
	}

	// Build and push Docker image to Google Container Registry using the JSON key
	image, err := docker.NewImage(ctx, dockerImageName, &docker.ImageArgs{
		Build: &docker.DockerBuildArgs{
			Context: pulumi.String("../"), // Adjust the context according to your project structure

			ExtraOptions: pulumi.StringArray{
				// This option is needed for devices running on ARM architecture, such as Apple M1/M2/MX CPUs
				pulumi.String("--platform=linux/amd64"),
			},
		},
		ImageName: pulumi.String(dockerImageWithPath),
		Registry: &docker.ImageRegistryArgs{
			Server: pulumi.String(dockerGCPServer),
			Username: pulumi.String("_json_key"), // Special username for GCP
			Password: pulumi.String(string(jsonKey)), // Provide the contents of the key file
		},
	}, pulumi.DependsOn(dependingSources))
	if err != nil {
		return nil, err
	}

	return image, nil
}

func deployContainerToCloudRun(ctx *pulumi.Context, enabledServices *EnabledServices, dockerImage *docker.Image) error {

	if enabledServices == nil || enabledServices.CloudRunService == nil {
		return errors.New("enabledServices cannot be nil")
	}

	if dockerImage == nil {
		return errors.New("dockerImage cannot be nil")
	}

	dependingSources := []pulumi.Resource{
		enabledServices.CloudRunService,
		dockerImage,
	}

	appService, err := cloudrun.NewService(ctx, cloudRunServiceName, &cloudrun.ServiceArgs{
		Location: pulumi.String(cloudRunLocation), // Choose the appropriate region for your service
		Template: &cloudrun.ServiceTemplateArgs{
			Spec: &cloudrun.ServiceTemplateSpecArgs{
				Containers: cloudrun.ServiceTemplateSpecContainerArray{
					&cloudrun.ServiceTemplateSpecContainerArgs{
						Image: dockerImage.ImageName,
						Resources: &cloudrun.ServiceTemplateSpecContainerResourcesArgs{
							Limits: pulumi.StringMap{
								"memory": pulumi.String("256Mi"), // Adjust the memory limit as needed
							},
						},
					},
				},
			},
		},
		Traffics: cloudrun.ServiceTrafficArray{
			&cloudrun.ServiceTrafficArgs{
				Percent: pulumi.Int(100),
				LatestRevision: pulumi.Bool(true),
			},
		},
	}, pulumi.DependsOn(dependingSources))

	if err != nil {
		return err
	}

	_, iamErr := cloudrun.NewIamMember(ctx, "invoker", &cloudrun.IamMemberArgs{
		Service: appService.Name,
		Location: appService.Location,
		Role: pulumi.String("roles/run.invoker"),
		Member: pulumi.String("allUsers"),
	})

	if iamErr != nil {
		return iamErr
	}

	ctx.Export("containerUrl", appService.Statuses.Index(pulumi.Int(0)).Url().ToOutput(ctx.Context()))
	return nil
} Update the in your Dockerfile:
There's a , and in which you need to export your environment variable to ENV known issue here HOME /root # Set the ENV HOME before your ENTRYPOINT.
ENV HOME=/root

# This is specific to your project. 
ENTRYPOINT ["/whatever-is-your-entrypoint"] Create a .env file in the pulumi directory: Set the * to the one you saved on full path 11) GOOGLE_CREDENTIALS_FILE_PATH="/Users/myusername/keys/gcp/pulumi-service-account-key-file.json" Run pulumi up You should be up and running! Extras The go.mod module social-log-go

go 1.21

toolchain go1.22.0

require (
	github.com/pulumi/pulumi-gcp/sdk/v7 v7.11.2
	github.com/pulumi/pulumi/sdk/v3 v3.108.1
)

require (
	dario.cat/mergo v1.0.0 // indirect
	github.com/Masterminds/semver v1.5.0 // indirect
	github.com/Microsoft/go-winio v0.6.1 // indirect
	github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 // indirect
	github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect
	github.com/agext/levenshtein v1.2.3 // indirect
	github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
	github.com/atotto/clipboard v0.1.4 // indirect
	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
	github.com/blang/semver v3.5.1+incompatible // indirect
	github.com/charmbracelet/bubbles v0.16.1 // indirect
	github.com/charmbracelet/bubbletea v0.24.2 // indirect
	github.com/charmbracelet/lipgloss v0.7.1 // indirect
	github.com/cheggaaa/pb v1.0.29 // indirect
	github.com/cloudflare/circl v1.3.7 // indirect
	github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect
	github.com/cyphar/filepath-securejoin v0.2.4 // indirect
	github.com/djherbis/times v1.5.0 // indirect
	github.com/emirpasic/gods v1.18.1 // indirect
	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
	github.com/go-git/go-billy/v5 v5.5.0 // indirect
	github.com/go-git/go-git/v5 v5.11.0 // indirect
	github.com/gogo/protobuf v1.3.2 // indirect
	github.com/golang/glog v1.1.0 // indirect
	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
	github.com/golang/protobuf v1.5.3 // indirect
	github.com/google/uuid v1.3.0 // indirect
	github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 // indirect
	github.com/hashicorp/errwrap v1.1.0 // indirect
	github.com/hashicorp/go-multierror v1.1.1 // indirect
	github.com/hashicorp/hcl/v2 v2.17.0 // indirect
	github.com/inconshreveable/mousetrap v1.1.0 // indirect
	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
	github.com/joho/godotenv v1.5.1 // indirect
	github.com/kevinburke/ssh_config v1.2.0 // indirect
	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
	github.com/mattn/go-isatty v0.0.19 // indirect
	github.com/mattn/go-localereader v0.0.1 // indirect
	github.com/mattn/go-runewidth v0.0.15 // indirect
	github.com/mitchellh/go-ps v1.0.0 // indirect
	github.com/mitchellh/go-wordwrap v1.0.1 // indirect
	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
	github.com/muesli/cancelreader v0.2.2 // indirect
	github.com/muesli/reflow v0.3.0 // indirect
	github.com/muesli/termenv v0.15.2 // indirect
	github.com/opentracing/basictracer-go v1.1.0 // indirect
	github.com/opentracing/opentracing-go v1.2.0 // indirect
	github.com/pgavlin/fx v0.1.6 // indirect
	github.com/pjbgf/sha1cd v0.3.0 // indirect
	github.com/pkg/errors v0.9.1 // indirect
	github.com/pkg/term v1.1.0 // indirect
	github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 // indirect
	github.com/pulumi/esc v0.6.2 // indirect
	github.com/pulumi/pulumi-docker/sdk/v3 v3.6.1 // indirect
	github.com/rivo/uniseg v0.4.4 // indirect
	github.com/rogpeppe/go-internal v1.11.0 // indirect
	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect
	github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect
	github.com/sergi/go-diff v1.3.1 // indirect
	github.com/skeema/knownhosts v1.2.1 // indirect
	github.com/spf13/cobra v1.7.0 // indirect
	github.com/spf13/pflag v1.0.5 // indirect
	github.com/texttheater/golang-levenshtein v1.0.1 // indirect
	github.com/tweekmonster/luser v0.0.0-20161003172636-3fa38070dbd7 // indirect
	github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect
	github.com/uber/jaeger-lib v2.4.1+incompatible // indirect
	github.com/xanzy/ssh-agent v0.3.3 // indirect
	github.com/zclconf/go-cty v1.13.2 // indirect
	go.uber.org/atomic v1.9.0 // indirect
	golang.org/x/crypto v0.17.0 // indirect
	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
	golang.org/x/mod v0.14.0 // indirect
	golang.org/x/net v0.19.0 // indirect
	golang.org/x/sync v0.5.0 // indirect
	golang.org/x/sys v0.15.0 // indirect
	golang.org/x/term v0.15.0 // indirect
	golang.org/x/text v0.14.0 // indirect
	golang.org/x/tools v0.15.0 // indirect
	google.golang.org/genproto/googleapis/rpc v0.0.0-20230706204954-ccb25ca9f130 // indirect
	google.golang.org/grpc v1.57.1 // indirect
	google.golang.org/protobuf v1.31.0 // indirect
	gopkg.in/warnings.v0 v0.1.2 // indirect
	gopkg.in/yaml.v3 v3.0.1 // indirect
	lukechampine.com/frand v1.4.2 // indirect
) If you include this Run , and this will fetch all the packages for you go.mod go tidy Footnotes I fought against permissions for 5 days. The predefined GCP role brought in the additional permissions needed. 1* serviceAccountAdmin

Automate and Deploy a Docker Container to Google Cloud Run from Scratch Using Pulumi and Go

Welcome to our enlightening session of the "Behind the Startup" series. Today, we're thrilled to host Robby Greenfield IV, the visionary founder of Umoja, a trailblazing platform at the intersection of blockchain technology and financial innovation. With a rich background in financial engineering, product management, and a remarkable journey through giants like Goldman Sachs, Amazon, and ConsenSys, Robby brings a wealth of experience and insights. Umoja, born from a passion to democratize financial services, stands out as a beacon of innovation in the crypto world. Join us as Robby shares his inspiring journey, the genesis of Umoja, and how it's shaping the future of hedging in the cryptocurrency market. Revolutionizing Crypto Hedging: How Umoja Guarantees Market-Loss Insurance Without Liquidation Fears Ishan Pandey: Hi Robby, delighted to welcome you to our "Behind the Startup" series. Can you share insights into your background, and your involvement in prior ventures also what inspired you to found Umoja? Absolutely! Glad to be a part of the series. I’ve been a financial engineer & product manager for over a decade, and started my journey in crypto in 2011. I started my career at Goldman Sachs, and have since worked at Cisco Systems, Amazon, and ConsenSys. At ConsenSys, I was their Head of Social Impact, and deployed over a dozen dApps & blockchain initiatives across 17 emerging markets globally, having worked with the likes of the U.S. State Dept., the UNOPs, Oxfam International, Harvard, and the World Bank. Robby Greenfield IV: Umoja actually spun out of ConsenSys originally as ConsenSys Social Impact, focused on enabling digital humanitarian aid on-chain for the underbanked by offering digital wallets compatible with WhatsApp, NFC Cards, and feature phones. After disbursing over $3M to tens of thousands of beneficiaries across 6 countries, we pivoted into hedging after realizing many of our customers and competitors greatly struggled with FX hedging due to the international nature of their organizations. Given that we know fiat, and all RWAs will come on chain, and the fact that our team has decades of Web3 and TradFi experience,  it made sense to capture this opportunity and protocolize hedging. Ishan Pandey: How does Umoja address the unique challenges of the crypto market through its hedging solutions? Umoja enables anyone to hedge their crypto losses like a hedge fund without the fear of liquidation. To put it simply - it’s like a market-loss insurance plan to lock in your gains with zero technical knowledge. We do this by creating synthetic options replicated through the algorithmic trade of leveraged, perpetual futures. In this way, we don’t need LPs and can offer option-like exposure more flexibly and affordably than nearly every other options protocol and exchange in crypto - all while making it easy to use and understand by retail investors. Robby Greenfield IV: Ishan Pandey: How does Umoja's automated hedging solution stand out in the market, especially in comparison to other options exchanges? Robby Greenfield IV: We don’t require any LP liquidity, we’re up to 30x more affordable on up-front costs. We’re much more flexible to use (can opt out anytime from a hedge). We’re the simplest to use. We’re more customizable - able to create DeFi-niche hedges like that for Uniswap LP positions, or de-peg derivatives. This is particularly true for non ETH/BTC markets, where the options markets are very illiquid. What we’re creating is DeFi’s first risk primitive - enabling tokenized investment strategies with strong downside protection - rather than just something that generates yield on a declining asset. Ishan Pandey: Can you elaborate on how Umoja provides more flexibility in terms of the duration of hedges and strike options than any other options exchange? How does it enhance user experience? When you purchase a traditional option - whether in TradFi or in Crypto, you have to purchase it at a standardized strike rate and term (e.g., 5% at 1 Month). This is because crypto options markets are much more illiquid than TradFi options markets, and because options have attributes like strike rates and terms, liquidity has to be concentrated into separate, standardized bands. Too much flexibility will cause even more illiquidity - and thus it is not currently possible to hyper-customize your strike and terms with crypto options in the traditional market. Additionally, traditional crypto options face much higher counterparty risk, as there has to be someone who wants your exact option in order for you to get out of that position. Robby Greenfield IV: In contrast, since Umoja replicates the value of options through algo trading perpetual futures, our counterparty risk is much lower. No one needs to buy an option from Umoja hedgers, because they didn’t purchase one in the first place. The counterparty is the underlying asset’s future’s market. For example, BTC’s future’s market monthly trading volume for , whereas its monthly options trading volume for that same month was . That means Umoja’s synthetic options are nearly 30x more liquid. Additionally, we can hyper-customize strikes and terms because - again - it’s a synthetic option not bound by the standardized liquidity constraints of the traditional options market. January 2024 was $1.29T $43.34B Our UX is the best in crypto derivatives. Inspired by Uniswap, you can literally hedge your market losses in less than 20 seconds. By simplifying the options experience by making them more customizable and attaching them to a useful context - protecting one’s money & locking in your gains - it doesn’t make sense for any trader or retail investor to go anywhere else. Ishan Pandey: Can you walk us through the process of how users can select the right fund, pay a fee, provide collateral, and receive Hedge Tokens? How does this process make it easy for users to interact with the platform? Hedging on Umoja takes 5 simple steps: Robby Greenfield IV: Choose a token you want to protect. Choose how much of that token you want to protect. Choose the date up until you want to protect it. Choose a price at which your protection should start. Put down 10% collateral and pay a small fee to Umoja. That’s it. Hedgers are never liquidated and can opt-out the hedge at any time without suffering from high counterparty risk. Hedgers may, however, need to top-up their collateral from time to time depending on the length of their hedge and market volatility if they want to maintain their full coverage. If they decide not to, their coverage will gradually decay over time. Ishan Pandey: Can you discuss the significance of your partnership with the first Crypto Hedge Fund and Chainlink, and the pending partnerships with Avalanche, Gogopool, and Benqi? Though I don’t want to spill the beans too much - let’s say that there are some exciting developments coming to DeFi. ‘Zero-Loss’ staking via hedging-embedded, liquid-staking tokens, crypto hedge funds leveraging the protocol, and LP position hedging via price feeds are some of those developments. Robby Greenfield IV: Ishan Pandey: With your background in blockchain and social impact, how do you see Umoja contributing to financial inclusion? Retail traders lost $1.8T over the last bear market - mainly due to not being able to protect themselves and buying the downside of whales and hedge funds. According to Pew Research Center polls in 2021 and 2022, some 20% of Black, Hispanic and Asian U.S. adults have bought, traded or used cryptocurrency, compared with 13% of white adults. This means that bear markets disproportionately affect communities of color, and having a way for those communities, and quite frankly, everyone to protect themselves from losses in a way that’s easy to use is an essential public good. Robby Greenfield IV: Ishan Pandey: In your opinion, how can widespread hedging positively impact the crypto ecosystem? It will create a world where people can opt to take on downside risk of a native asset. You can choose to either holde hedged ETH (uETH) at a premium, or normal ETH (and take on losses). Simply put - this makes DeFi and crypto at large more financially responsible. No more betting the mortgage or the dichotomy between WAGMI and going broke. Robby Greenfield IV: Don’t forget to like and share the story! This author is an independent contributor publishing via our brand-as-author program. Be it through direct compensation, media partnerships, or networking, the author has a vested interest in the company/ies mentioned in this story. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR Vested Interest Disclosure:

Robby Greenfield IV on Founding Umoja: Bridging Traditional Finance and Web3 with a Decade of Expert

উমোজা প্রতিষ্ঠায় রবি গ্রিনফিল্ড IV: এক দশকের বিশেষজ্ঞের সাথে ঐতিহ্যগত অর্থায়ন এবং ওয়েব3 ব্রিজিং

Robby Greenfield IV über die Gründung von Umoja: Mit einem Jahrzehnt Erfahrung verbindet er traditionelle Finanzen und Web3

Robby Greenfield IV sobre la fundación de Umoja: uniendo las finanzas tradicionales y la Web3 con una década de expertos

Robby Greenfield IV sur la création d'Umoja : relier la finance traditionnelle et le Web3 avec une décennie d'experts

उमोजा की स्थापना पर रॉबी ग्रीनफील्ड IV: एक दशक के विशेषज्ञ के साथ पारंपरिक वित्त और वेब3 को जोड़ना

Robby Greenfield IV が Umoja の設立について語る: 10 年にわたる専門家による従来の金融と Web3 の橋渡し

Umoja 설립에 관한 Robby Greenfield IV: 10년의 전문가와 전통적인 금융 및 Web3 연결

Robby Greenfield IV sobre a fundação do Umoja: unindo finanças tradicionais e Web3 com uma década de especialistas

Робби Гринфилд IV о создании «Умоджи»: соединение традиционных финансов и Web3 с десятилетним опытом экспертов

Robby Greenfield IV, Umoja'nın Kuruluşu: Geleneksel Finans ve Web3'ü On Yıllık Uzmanla Birleştirmek

Robby Greenfield IV về việc thành lập Umoja: Kết nối tài chính truyền thống và Web3 với một thập kỷ chuyên gia

罗比·格林菲尔德四世 (Robby Greenfield IV) 谈创立“团结”系统：通过十年的专家在传统金融和 Web3 之间架起桥梁

Disclaimer: this blog post is intended as an academic, ethnographic research piece. The authors are not employed by SEAL and did not benefit monetarily from authorship. SEAL DRILL TIME A message appeared in the Telegram chat application group chat: “Welcome to the SEAL Chaos Team's Simulation War Room. You're now part of a real-time exercise set in the Yearn ecosystem. Your mission involves diagnosing and responding to a simulated incident as if it were real and the stakes were high. In other words, do everything you would normally do, including triaging, patching, and (simulating) communicating with the public. After the simulation is complete, you'll have a chance to go over how you did and where room for improvement might be found…Good luck. The simulation is about to begin.” This message marked the second attack simulation (or “SEAL Drills”) on a major Decentralised Finance (DeFi) protocol by the “SEAL Chaos Team”. More broadly, it marks an effort to shift the security landscape of the cryptocurrency ecosystem and presents insights into how formal and informal accountability mechanisms are developed in open-source, permissionless infrastructure. Content Overview Introduction SEAL x Yearn: Attack Simulation Debrief Insights Conclusion Introduction To be clear, Web3 is not safe (yet?) for retail consumers and “normies” (normal people). Blockchain data platform that 2022 was the “biggest year ever for crypto hacking”, with $3.8 billion stolen. Decentralized Finance (DeFi) protocols, some of the most automated and transparent in terms of activity occurring on-chain, are also the most vulnerable at 82.1% of all cryptocurrency stolen. In what doesn’t look good for crypto’s reputation in the eyes of regulators, are breaking theft records. While it may be worth $10,000 – $100,000 for a professional security firm to audit the software code of a protocol's , these prices can be prohibitive to experimental, un-funded start-up projects. A list of some of the largest hacks in crypto history, including whether or not they were audited (many were), can be found at . is also increasing. The need for greater accountability within blockchain governance, in conjunction with appropriate regulatory measures, is clear. ‘Chainanalysis’ reports North Korea-linked hackers smart contracts rekt.news Crypto regulatory enforcement Accountability refers to the mechanisms and processes through which individuals, organizations, or institutions are held responsible for their decisions and actions in relation to others. This is typically achieved through a combination of social norms and institutional rules for monitoring, enforcement, and potential sanctions. In legal and corporate governance, is achieved between two actors when one is obliged to provide an account of its action, and the other has the power and authority to impose consequences as a result. accountability In technical modes of governance, “ ” refer to a design strategy to ensure that sufficient evidence of participation is provided in the rules of the protocol. Furthermore, scholars and practitioners ‘ethical considerations need to be embedded into the software development process’. This post builds upon these conceptualizations to explore the accountability mechanisms occurring in blockchain governance. Specifically, we investigate “off-chain” (off the blockchain) accountability mechanisms that are formalized and verifiable to explore the extent to which blockchain communities can effectively self-regulate to achieve certain policy objectives. accountability protocols argue that Anthropologists have in the politics and practices of hacking as a social phenomenon, in relation to the production of open-source software and freedom. By employing digital ethnographic methods, we observe the case study of the SEAL Chaos Team. The Chaos Team is one work stream of SEAL, a grant-funded not-for-profit organization that provides a platform for the security community to be able to collaborate on and launch ambitious and impactful security initiatives that would otherwise be difficult to execute. shown significant interest ‘Whitehat’ or ‘ is a process in which a hacker simulates an attack on a network or computer system to evaluate its security, with consent from that system’s owners. In other words, it is engaging in the tools, processes, and methods to find vulnerabilities and develop defenses before the bad guys do. White rescues can also mean engaging in the exploitation of a computer system with the intent to rescue funds ahead of an attacker. As a handful of volunteers, they engage in security-enhancing initiatives, including attack simulations to help protocol teams prepare their processes and coordination for real events, the incident help desk (SEAL-911), the legal Safe Harbor Agreement for Whitehats, incident playbooks, and threat intel sharing. Given that the team works on the most sensitive security issues and also with many anons (anonymous people), we were particularly sensitive around our ‘ethnographic op-sec’ (operational security), including not interrupting security exercises and how data was shared and stored. ethical’ hacking SEAL Chaos Team’s process includes engagement with a protocol team, background open-source research to understand the network services associated with the target protocol, a tabletop exercise to plan the simulation, and finally a window of time in which the simulated attack with occur (in a simulated operating environment) to test the protocol team’s response. In an interview with Isaac Patka, Founder of Shield3 security firm and leader of SEAL’s attack simulation (Chaos) team, he pointed out that in the early days of smart contract-enabled public blockchains, there was little distinction between whitehats and ‘blackhats’ (bad guys). Many projects released protocols without prohibitively expensive professional security audits, and it was expected that hackers would identify and exploit bugs, and often be rewarded with bug bounties for this. It was like “Let’s all try to wreck protocols as much as possible and see what survives.” The benefits of attack simulations can include improved security through identifying vulnerabilities, proactive defense, knowledge sharing, and training. With the Yearn attack simulation exercise coming up, the SEAL Chaos Team was prepared to “take this Yearn Plane ✈️ down!”. 🔥🔥🔥 SEAL x Yearn: Attack Simulation 🔥🔥🔥 It was 12:01 PM EST on September 20, 2023, when Isaac Patka posted in the War Room that the simulation had begun. The players on the ‘blue team’ (a.k.a. good guys) included a bunch of core contributors to the DeFi protocol ‘Yearn’, including Storm0x, FP, Poolpi Tako, wavey, dudesahn, Val, banteg, Spalen, and Rare Weasel. My access to observe the simulation had been granted by the red team attackers; renowned Web3 whitehat , and the coordinator of the simulation, Isaac Patka. 80 developer hours of work had gone into preparing the scenario, tools, notification channel, and ‘meme’ joke ads. Now, at the very beginning of the possible window of time for the exercise and halfway through an early dinner in my time zone, the simulation had begun. Samczsun Dudesahn was the first to respond, saying “Lmao wait it’s starting at the earliest possible time?”. “I’m eating lunch so will be a bit slow for a few mins 😂”. As the team spun up a voice channel to be able to talk and type at the same time, we were viewing a simulation of several Yearn vaults, and all had access to a second Telegram channel that was pinging us with incessant notifications with price updates from the open source block explorer ‘BlockScout’, Yearn vault liquidity reports, and an Arb Profit Report 😈 📈. Within moments, the Yearn team started to diagnose the situation, stating “Okay so clearly ETH price is being manipulated”. Dudesahn asks, “Where is this eth price being reported from?”. Poolpi tako replies, “Compound oracle”. Dudesahn says, “OK. So someone is attacking compound and it’s basically fucking us over”. The strategy of the attack was to manipulate the Compound oracle price, borrow USDC against that, and extract funds from the protocol. By 12.03 PM Storm0x had posted an urgent status report indicating an issue with Compound, mentioning the affected vaults and suggesting some strategies to mitigate the damage before halting the attack. “GOAL try to minimize damage impact, and assess if we need to take immediate action”. Pulling out an emergency procedure card, Val shares a link, and Storm0x stresses the importance of setting the deposit limit to zero. After some negotiation around the correct multi-signature wallet-based they could follow with the participants present and without needing to wake anyone else in a different time zone up, the team agreed that they had quorum to sign a transaction. governance process Before signing, the Yearn team priority was to simulate the steps on a fork in a local operating environment to confirm the strategy would allow them to safely exit. By 34 minutes into the simulation, the team was clear on the transactions affected in the vault, that it was an issue with Compound, and the need to minimize damage and assess immediate actions. Looking at their manuals, “would emergency shutdown do this?”. Poolpi stated “we have never used it in the past…”. Val asked FP, “Would you recommend collat target = 0 and tend, or emergency shutdown?” Storm0x emphasized, “can we get a simulation in local rpc to check that the steps are safe and we can deliver?”, referring to the ‘unwidening’ of strategy so it withdraws from the underlying protocols and returns funds it ‘borrowed’ from the vault. With that, Dudesahn commentated on the general sentiment, “we’re not fucked yet but we will be if we fail to withdraw”. At 37 minutes into the exercise, not only was the vulnerability identified but a strategy was in place. After testing the command, the team decided they have quorum and were happy to run this command to initiate an , a “set of actions that seek to unwind and divest funds back to the Vault as quickly and smoothly as possible, with as minimal losses as possible”. emergency exit mode The total time to safe harbour assets and declare it was 56 minutes, with Storm0x announcing and update in the chat “FUNDS ARE SAFU!! we are out from compound”. Debrief Upon debrief, the SEAL red team declared that Yearn’s effort was “impressive”. This was particularly regarding their pre-prepared emergency manuals, although the exercise itself warranted a review and update of these. The Yearn team responded rapidly to identify the root cause of the attack was a dependency on a price oracle and not an issue with their code. They did acknowledge they could have done some things better, particularly the time to action the emergency exit mode to limit new deposits. In a normal scenario with all of the standard tooling available, the response would have been even faster. Part of the immediate debrief procedure included consideration of if and how such a situation would be publicly communicated and reported on, including timestamps from the event. In the case of Yearn, a policy is in place, which they have in the past. public disclosure had to enact multiple times Although very serious, the simulation also featured compulsory memes “for the lulz”. The fork (copy of software) of Blockscout that Isaac had included joke advertisements to replace the Paypal ones, created by SEAL Chaos team member David Desjardins, including “seals 4 sale”. Insights What this case study reveals is greater insight into how accountability mechanisms form in the digital, private governance settings of public blockchain infrastructure. SEAL is offering a voluntary, centralized service in a decentralized, permissionless ecosystem to help improve coordination among Whitehat hackers, as well as security outcomes for protocols. While attack simulations are one work stream of SEAL, others include the SEAL 911 emergency notification channel and plans for a Request For Comment for a legal safe harbor agreement between protocol communities and Whitehat hackers, that is ratified on-chain by each protocol. Of course, any coordination mechanism, whether on-chain or off-the-blockchain, addresses some while potentially introducing others. For SEAL, this may include social engineering attempts to pose as a Whitehat or game the 911 channel, or lack of awareness of the state of a protocol community agreement with whitehat’s (whether ratified or revoked) in an emergency response scenario. vulnerabilities SEAL ran an ‘attack sim’ with Compound a couple of months ago, and already has a waitlist of high-profile DeFi protocols to follow the Yearn exercise. According to Isaac, simulations push teams to up their detection game and relentlessly "mitigate, then resolve” security-related matters. SEAL adds social resiliency to protocols. Attack simulations not only help a protocol to better prepare for unforeseen scenarios but also encourage teams to consider the issues that come with composable infrastructure, the cascade effects of how contagion in one protocol can spread, and how to communicate across protocol teams to coordinate responses (either in a simulation or in a live situation via the (optional and non-exclusive) SEAL 911 disclosure service. After the Yearn simulation, Isaac offered in the chat, “If anyone wants to contribute to future attack scenarios and doomsday scenarios, feel free”. Conclusion This piece is part of a broader research project on ‘ ’ that explores the relationship between social accountability and technological guarantees. In particular, it explores the extent to which blockchain communities can ‘self-regulate’, and how they utilize technical and social regulatory modalities to do so. In the case of the SEAL Chaos Team, this piece finds that blockchain governance embraces a form of ‘co-regulation’ between public protocol communities and private ‘whitehat hackers’. Wherever possible, social norms of accountability are embedded into the transparent, technical rules of the protocol. What this case study demonstrates is the possibility for novel forms of that are particularly suited to open-source, public, blockchain systems. Through public accountability mechanisms for private actors that align protocols and communities with regulatory requirements, and vice versa, Web3 may have a chance at improving security, whilst protecting some of its core values of permissionlessness and polycentricity. accountability in blockchain governance co-regulation References Bella, G., and Paulson. L.C. (2006). Accountability protocols: Formalized and verified. ACM Trans. Inf. Syst. Secur. 9, 2 (May 2006), 138–161. . https://doi.org/10.1145/1151414.1151416 Bovens, M. (2007). Analysing and Assessing Accountability: A Conceptual Framework. European Law Journal, 13(4), 447-468. . https://onlinelibrary.wiley.com/doi/full/10.1111/j.1468-0386.2007.00378.x Chainanalysis Team. (2023, February 1). 2022 Biggest Year Ever For Crypto Hacking. . Chainalysis https://www.chainalysis.com/blog/2022-biggest-year-ever-for-crypto-hacking/ Coleman, E. G. (2013). . Princeton University Press. Coding freedom: The ethics and aesthetics of hacking Finck, Michèle, Digital Co-Regulation: Designing a Supranational Legal Framework for the Platform Economy (June 20, 2017). European Law Review (2018 Forthcoming), LSE Legal Studies Working Paper No. 15/2017, Available at SSRN: . https://ssrn.com/abstract=2990043 Kang, J. J. (2022, November 30). The Conversation. . North Korea’s nuclear program is funded by stolen cryptocurrency. Could it collapse now that FTX has? http://theconversation.com/north-koreas-nuclear-program-is-funded-by-stolen-cryptocurrency-could-it-collapse-now-that-ftx-has-195559 Malwa, S. (2020, September 29). . Decrypt. . Hackers Drain $15 Million From ‘Unreleased’ Yearn Finance Project https://decrypt.co/43203/hackers-drain-15-million-from-unreleased-yearn-finance-project Nabben, K. (2023). Blockchain Governance: Accountability in Decentralised Technology Communities [Substack newsletter]. . . Kelsie - on the Cataclysmia of Digital Infrastructure https://kelsienabben.substack.com/p/blockchain-governance-accountability Nabben, K., Burrrata, Michael Zargham, and Jessica Zartler. “DAO Vulnerabilities: A map of Lido governance risks and opportunities”. BlockScience Medium ( ). Available at: . blog https://medium.com/block-science/dao-vulnerabilities-a-map-of-lido-governance-risks-opportunities-92bc6384ff68 Rekt. (2023). Rekt.News, Leaderboard. Available online: . Accessed September, 2023. https://rekt.news/leaderboard/ . (2023, September 22). X (Formerly Twitter). . Samczsun (@samczsun) / X https://twitter.com/samczsun Solidus Labs. 2023. . Retrieved September 25, 2023, from . US Regulators Broke Crypto Enforcement Records in 2022 https://www.soliduslabs.com/research/2023-crypto-enforcement-trends Yearn. (n.d.). . GitHub. Retrieved September 26, 2023, from . Yearn-security/disclosures at master · yearn/yearn-security https://github.com/yearn/yearn-security/tree/master/disclosures Yearn Finance. (2023). . . Governance and Operations. yearn.fi https://docs.yearn.fi/contributing/governance/governance-and-operations Zuber, N., Gogoll, J., Kacianka, S., Pretschner, A., & Nida-Rümelin, J. (2022). Empowered and embedded: Ethics and agile processes. , (1), Article 1. . Humanities and Social Sciences Communications 9 https://doi.org/10.1057/s41599-022-01206-4 - by and Primavera De Filippi, October 25, 2023 Kelsie Nabben

SEAL DRILLS: Attack Simulations to Improve Web3 Security 

Throughout my career, I have primarily focused on developing backend systems using . Despite dabbling in front-end work, I always found myself gravitating back toward development. In order to expand my skill set, I have experimented with writing backend applications using different programming languages such as JavaScript/Typescript and Rust. I have tested various technologies and frameworks, some of which I found more enjoyable than others. Nonetheless, there remains one language that I have yet to explore: Python API Go. When I first started using Golang, it felt a little unfamiliar due to its simplicity, unique error handling, and some unusual design choices like struct tags. However, even before getting fully accustomed to these "quirks", I quickly realized several things about Go that I genuinely appreciate. Interestingly, these same features can be seen as challenges in my primary programming language, Python. In this article, I will share my initial thoughts on using Go as a Python engineer. I will highlight the aspects of Go that I appreciate, which may not be as prominent in Python. These include: built-in tools packaging backend focus setting up Docker performance By the end of this article, you will understand why Go is an excellent option for backend applications and how it compares to Python in terms of convenience. Tooling When it comes to building software, the main task is writing code. However, there are several potential problems that can arise during this process. These can include: incorrect formatting bugs common code issues As engineers and humans, it's impossible to guarantee that our work is completely flawless. This is where automated tools like linters, unit tests, and static analysis can be incredibly useful in providing additional assistance. When working with Python, formatting can be a challenge. While the most popular tool for formatting is , it requires installation and configuration. However, configuration can be difficult as there are multiple ways to do it, with being the default option according to , but not all tools support it. black pyproject.toml PEP 518 In terms of linting, prior to the release of in 2022, Python developers had to rely on and its various plugins, which were inconvenient to configure. Thankfully, now supports many features and can be configured via the file. ruff flake8 ruff pyproject.toml Similarly, if you want more powerful testing capabilities than what is offered by the built-in , you'll need to install and configure additional tools and addons. It's important to ensure that all of these components work together properly in your CI system as well. unittest When working with Go, the development experience can be quite different. Upon installation, you will have access to a wide range of tools to aid your local development. Compared to Python, formatting rules in Go are less strict. For example, there is no fixed line length. However, Go has a built-in formatting tool that can be accessed through the command, eliminating the need for additional installation or configuration. go fmt Another useful tool in Go is the command, which helps to identify common coding mistakes such as unreachable code or useless comparisons. In addition, external linters like can be used to detect bugs and performance issues with ease. go vet staticcheck For testing purposes, Go provides a command that automatically discovers tests within your application and supports features such as caching and code coverage. However, if you require more advanced testing capabilities such as suites or mocking, you will need to install a toolkit like . Overall, while Go provides a highly effective testing experience, it's worth noting that writing tests in Python using is arguably one of the most enjoyable testing experiences I have encountered across all programming languages. go test testify pytest It's also important to remember that there's no need to use type-checking tools such as with Go, as it's a compiled and statically-typed language. mypy In summary, once you've installed Go, you'll have access to the necessary tools to support your code-writing efforts. The next step is to focus on packaging and managing dependencies. Packaging Managing dependencies is crucial when building software. While Golang has an extensive standard library, more complex projects often require external packages. Luckily, Go provides excellent tools for effectively managing dependencies. Go projects come with two files: and . The file is particularly crucial as it lists all the direct and indirect dependencies along with their versions. The file is automatically generated to serve as a checksum of the dependencies. go.mod go.sum go.mod go.sum To install a package, you use the command. The good news is that this command saves the installed packages in the directory, so there is no need to manually create virtual environments or similar things. go get <package> $GOPATH/pkg/mod In addition, you can use the command to ensure consistency between the file and the source code in the module. This command will add any missing module requirements needed to build the current module's packages and dependencies. If there are any unused dependencies, will remove them from . go mod tidy go.mod go mod tidy go.mod Finally, publishing packages with Go is incredibly simple. To install them, you typically just need to use the repository link, such as . So, to publish your own package, all you have to do is properly set up your module in the file, create a public repository, and request the package at . After a short period of time, your package will be available in the Go module index. That's it. go get github.com/tobias-piotr/gouth0 go.mod https://pkg.go.dev/ Now compare this with Python. By default, Python doesn't even have a checksum file. If you want more advanced features, you'll need to install a tool like , which has many external dependencies. Managing project dependencies can be done through a file, but you'll need to create and maintain it yourself. Compared to Go, publishing packages to PyPI can also feel inconvenient. poetry Without further criticism of Python packaging, Go's packaging feels much simpler and more convenient. The next chapter will cover how Go's setup is beneficial when working with Docker. Docker When it comes to building web applications in the modern world, Docker is usually involved. It simplifies the process of setting up a project locally and deploying it to production. Creating a Dockerfile for a Golang project is remarkably easy for two primary reasons: the Go tooling mentioned earlier and the fact that Go is a compiled language. Additionally, the combination of these two factors leads to a very standardized method of setting up a project. This means that if you copy a Dockerfile from one Golang project to another, there is a high probability that it will work without any issues. This is quite different from the situation in Python. With all of this in mind, take a look at a Dockerfile from one of my Go projects: FROM golang:1.20.6-alpine AS builder

EXPOSE 8080

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=linux go build -o /main

# Local development
FROM builder as dev

ENV DEBUG=true

# Install air for hot reloading
RUN go install github.com/cosmtrek/air@latest

ENTRYPOINT ["air"]

# Production
FROM gcr.io/distroless/base-debian11 AS prod

WORKDIR /

COPY --from=builder /main /main

USER nonroot:nonroot

ENTRYPOINT ["/main"] Without diving too deep into the Docker syntax, this config simply downloads dependencies, compiles code, and runs the binary file. It's important to note that Go, being a compiled language, improves this process. For example, you can use a tool like to use the binary file and enable hot reloading while developing locally. Additionally, in production, a smaller base image can be used because no OS dependencies are required to start the binary file. This significantly reduces the image size of your app. air Starting a new project in Go is great because it's easy to set up a fully working and optimized Dockerfile. With tooling, packaging, and containerizing covered, we can finally focus on the language's features. Backend Focus When I first started working with Go, I had doubts about its suitability for backend development. However, it didn't take long for me to realize that Go is actually designed with backend development in mind. One of the main things that make Go well-suited for backend development is its standard library. This library includes a variety of useful packages for tasks such as encoding, cryptography, and database management. Most importantly, it also includes packages for building HTTP servers, which means you can create a semi-sophisticated API without needing to install any additional dependencies. For instance, I was able to develop an authentication API for interacting with Auth0 using just one external package (for structured logging). You can view the code here: . goloxy On top of that, there are many amazing packages available for developing web applications, including: web frameworks: Gin, Fiber, chi, Echo validation: validate, ozzo-validation, Valgo structured logging: zap, logrus, zerolog database interactions: GORM, sqlx, sqlc, Ent My preferred combination is Echo/chi as a web framework, Valgo for validation, zap for structured logging, sqlx for database interactions, and Fx for dependency injection. This setup has been effective for most of my projects, though it may vary depending on specific requirements. To highlight a difference with Python, configuring structured logging can be a challenge, even with a great framework like FastAPI. In an Echo app, I configure the zap logger in the following way: e.Use(middleware.RequestLoggerWithConfig(middleware.RequestLoggerConfig{
	LogProtocol: true,
	LogMethod: true,
	LogURI: true,
	LogStatus: true,
	LogRequestID: true,
	LogRemoteIP: true,
	LogLatency: true,
	LogError: true,
	LogValuesFunc: func(c echo.Context, v middleware.RequestLoggerValues) error {
		logger.Info(
			fmt.Sprintf("%s %s %s %v", v.Protocol, v.Method, v.URI, status),
			zap.String("protocol", v.Protocol),
			zap.String("method", v.Method),
			zap.String("uri", v.URI),
			zap.Int("status", status),
			zap.String("request_id", v.RequestID),
			zap.String("remote_ip", v.RemoteIP),
			zap.String("latency", v.Latency.String()),
			zap.Error(v.Error),
		)
		return nil
	},
})) In addition to creating a logger instance, which is usually just a few lines, this is all that is required to have complete control over the logger for each request. An example of setting up structured logging in a FastAPI app can be found using the package here: (adding it between the backticks, because it is way too long to be embedded). This is surely overwhelming, even when you are fully aware of what's going on there. structlog https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e To summarize, Go has excellent built-in and externally installable solutions for developing web apps. However, implementation is just the beginning. The next chapter will cover the performance of Golang code. Performance When examining the most popular uses of Go, examples include proxies, infrastructure management, and "typical" web development. One of the reasons for its popularity is the exceptional performance of Go, especially when compared to Python, which is known to have weaker performance. There are numerous factors that contribute to Go's superior performance. such as: lightweight design, which reduces runtime overhead efficient garbage collection impressive concurrency model with Goroutines strong typing and static analysis These are just a few examples of the reasons why Go is so well-performing. All of these features enable the creation of highly optimized applications that can efficiently handle large workloads and easily scale even further. It's possible that one might argue that performance isn't crucial in many applications. In such cases, you could simply select Python, take code from a previous FastAPI project, base it around asyncio, and it should perform well enough. This argument may be valid. However, performance isn't just about speed; it also relates to resources. You might not notice speed differences when comparing an app written in Golang to one in Python - the differences are in nanoseconds. However, you will definitely see the difference in resource usage. The app developed in Go will use significantly fewer resources. This will be evident through lower costs. I recommend watching where he explains how rewriting a SAAS project in Go resulted in reduced costs. Ben Davis' video When it comes to performance, Python doesn't have the best reputation. This is largely due to the GIL, dynamic typing, and awkward concurrency model. While there are optimizations available, such problems are less frequent in Go. Therefore, when prioritizing performance, Go may be the better option. Summary Based on my experience with various technologies, I have some personal favorites. However, when building software, it is important to consider multiple factors before choosing the best tech stack. For backend development, Go stands out as an excellent option, especially when performance and cost are crucial. Nevertheless, it's not without any flaws. I believe that in modern Python, FastAPI and Pydantic are its strongest features for web development. They offer features like dependency injection, Swagger documentation, exceptional validation, and error handling right out of the box. I also find pytest to be the most well-designed test writing tool I've encountered. In summary, Go lacks some of the drawbacks that Python has, but Python has a wealth of features and libraries for app development. Ultimately, it depends on your specific needs and trade-offs. Also published here.

GOGOX

gogox.com

-- employees

Since n.d.

COMPANY RANKING

GOGOX

EVERGREEN INDEX #5236

Representing this company? Click here to claim and customize this page!

GOGOX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

GOGOX

gogox.com

-- employees

Since n.d.

COMPANY RANKING

GOGOX

EVERGREEN INDEX #5236

RELATED COMPANIESRANK

STORIES ABOUT GOGOX

Representing this company? Click here to claim and customize this page!

GOGOX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!