Crypto-as-a-Service: Fund Go Account through Go Network

// 1. Create a Connection
// 1.1 List Your Enterprise
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export DESCRIPTION="<YOUR_PUBLIC_DESCRIPTION>"

curl -X POST \
  https://app.bitgo-test.com/api/address-book/v1/listing/global \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -d '{"description": "'"$DESCRIPTION"'"}'

// 1.2 Create Listing Entry
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export WALLET_ID="<YOUR_WALLET_ID>"
export DESCRIPTION="<YOUR_PUBLIC_DESCRIPTION>"

curl -X POST \
  https://app.bitgo-test.com/api/address-book/v1/listing/entry/global \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -d '{
    "walletId": "'"$WALLET_ID"'",
    "description": "'"$DESCRIPTION"'",
    "public": true
  }'

// 1.3 Get Listing Entry ID
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export CHILD_ENTERPRISE_ID="<CHILD_ENTERPRISE_ID>"
export USER_ID="<YOUR_USER_ID>"

curl -X GET \
  https://app.bitgo-test.com/api/address-book/v1/listing/global \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -H "enterprise-id: $CHILD_ENTERPRISE_ID" \
  -H "user-id: $USER_ID"

// 1.4 Create Counterparty Connection
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export CHILD_ENTERPRISE_ID="<CHILD_ENTERPRISE_ID>"
export USER_ID="<YOUR_USER_ID>"
export LISTING_ENTRY_ID="<YOUR_LISTING_ENTRY_ID>"
export TARGET_LISTING_ENTRY_ID="<COUNTERPARTY_TARGET_LISTING_ENTRY_ID>"
export LOCAL_LISTING_ENTRY_DESCRIPTION="<LOCAL_LISTING_ENTRY_DESCRIPTION>"

curl -X POST \
  https://app.bitgo-test.com/api/address-book/v1/connections \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -H "enterprise-id: $CHILD_ENTERPRISE_ID" \
  -H "user-id: $USER_ID" \
  -d '{
    "listingEntryId": "'"$LISTING_ENTRY_ID"'",
    "localListingEntryDescription": "'"$LOCAL_LISTING_ENTRY_DESCRIPTION"'",
    "targetListingEntryId": "'"$TARGET_LISTING_ENTRY_ID"'"
  }'

// 2. Create Settlement
export CHILD_ENTERPRISE_ID="<CHILD_ENTERPRISE_ID>"
export ACCOUNT_ID="<YOUR_ACCOUNT_ID>"
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export CONNECTION_ID="<CONNECTION_ID>"
export CONNECTION_UPDATED_AT="<CONNECTION_UPDATED_AT>"
export COUNTERPARTY_ACCOUNT_ID="<COUNTERPARTY_ACCOUNT_ID>"
export CURRENCY="<SENDING_ASSET>"
export QUANTITY="<SENDING_QUANTITY>"
export EXTERNAL_ID="<YOUR_EXTERNAL_ID>"

curl -X POST \
  https://app.bitgo-test.com/api/clearing/v1/enterprise/$CHILD_ENTERPRISE_ID/account/$ACCOUNT_ID/settlement \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -d '{
    "externalId": "'"$EXTERNAL_ID"'",
    "addressBookConnectionId": "'"$CONNECTION_ID"'",
    "addressBookConnectionUpdatedAt": "'"$CONNECTION_UPDATED_AT"'",
    "assetTransfers": [
      {
        "currency": "'"$CURRENCY"'",
        "quantity": "'"$QUANTITY"'"
      }
    ]
  }'

// 3. Sign Settlement (Optional)
// 3.1 Apply Signature
// Use JavaScript SDK or BitGo Express to generate signature
// See JavaScript example for implementation

// 3.2 Submit Signed Settlement
export ENTERPRISE_ID="<YOUR_ENTERPRISE_ID>"
export ACCOUNT_ID="<YOUR_ACCOUNT_ID>"
export SETTLEMENT_ID="<SETTLEMENT_ID>"
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export PAYLOAD="<SETTLEMENT_PAYLOAD>"
export SIGNATURE="<YOUR_PUBLIC_KEY>"

curl -X POST \
  https://app.bitgo-test.com/api/clearing/v1/enterprise/$ENTERPRISE_ID/account/$ACCOUNT_ID/settlement/$SETTLEMENT_ID/signing \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -d '{
    "payload": "'"$PAYLOAD"'",
    "signature": "'"$SIGNATURE"'"
  }'

// 4. Approve Settlement (Optional)
export APPROVAL_ID="<APPROVAL_ID>"
export SERVICE_USER_TOKEN="<SERVICE_USER_ACCESS_TOKEN>"
export OTP="<YOUR_OTP>"

curl -X PUT \
  https://app.bitgo-test.com/api/v2/pendingApprovals/$APPROVAL_ID \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $SERVICE_USER_TOKEN" \
  -d '{
    "state": "approved",
    "otp": "'"$OTP"'"
  }'

// 1. Create a Connection
// 1.1 List Your Enterprise
const BitGoJS = require('bitgo');

const bitgo = new BitGoJS.BitGo({
  accessToken: '<SERVICE_USER_ACCESS_TOKEN>',
  env: 'test',
});

async function listEnterprise() {
  const listing = await bitgo.post('/api/address-book/v1/listing/global').send({
    description: '<YOUR_PUBLIC_DESCRIPTION>',
  });

  console.log('Enterprise Listing:', listing);
  return listing;
}

listEnterprise().catch(console.error);

// 1.2 Create Listing Entry
async function createListingEntry() {
  const entry = await bitgo.post('/api/address-book/v1/listing/entry/global').send({
    walletId: '<YOUR_WALLET_ID>',
    description: '<YOUR_PUBLIC_DESCRIPTION>',
    public: true,
  });

  console.log('Listing Entry:', entry);
  return entry;
}

createListingEntry().catch(console.error);

// 1.3 Get Listing Entry ID
async function getListingEntryId() {
  const listing = await bitgo.get('/api/address-book/v1/listing/global')
    .set('enterprise-id', '<CHILD_ENTERPRISE_ID>')
    .set('user-id', '<YOUR_USER_ID>')
    .send();

  console.log('Listing:', listing);
  return listing;
}

getListingEntryId().catch(console.error);

// 1.4 Create Counterparty Connection
async function createConnection() {
  const connection = await bitgo.post('/api/address-book/v1/connections')
    .set('enterprise-id', '<CHILD_ENTERPRISE_ID>')
    .set('user-id', '<YOUR_USER_ID>')
    .send({
      listingEntryId: '<YOUR_LISTING_ENTRY_ID>',
      localListingEntryDescription: '<LOCAL_LISTING_ENTRY_DESCRIPTION>',
      targetListingEntryId: '<COUNTERPARTY_TARGET_LISTING_ENTRY_ID>',
    });

  console.log('Connection:', connection);
  return connection;
}

createConnection().catch(console.error);

// 2. Create Settlement
async function createSettlement() {
  const enterpriseId = '<CHILD_ENTERPRISE_ID>';
  const accountId = '<YOUR_ACCOUNT_ID>';
  
  const settlement = await bitgo.post(
    `/api/clearing/v1/enterprise/${enterpriseId}/account/${accountId}/settlement`
  ).send({
    externalId: '<YOUR_EXTERNAL_ID>',
    addressBookConnectionId: '<CONNECTION_ID>',
    addressBookConnectionUpdatedAt: '<CONNECTION_UPDATED_AT>',
    assetTransfers: [
      {
        currency: '<SENDING_ASSET>',
        quantity: '<SENDING_QUANTITY>',
      },
    ],
  });

  console.log('Settlement:', settlement);
  return settlement;
}

createSettlement().catch(console.error);

// 3. Sign Settlement (Optional)
// 3.1 Apply Signature
import { BitGoAPI } from '@bitgo/sdk-api';
import { coins } from '@bitgo/sdk-core';

const OFC_WALLET_ID = process.env.OFC_WALLET_ID;
const payload = process.env.PAYLOAD;
const walletPassphrase = process.env.OFC_WALLET_PASSPHRASE;

const bitgoAPI = new BitGoAPI({
  accessToken: process.env.TESTNET_ACCESS_TOKEN,
  env: 'test',
});

const coin = 'ofc';
bitgoAPI.register(coin, coins.Ofc.createInstance);

async function applySignature() {
  const wallet = await bitgoAPI.coin('ofc').wallets().get({ id: OFC_WALLET_ID });
  const tradingAccount = wallet.toTradingAccount();
  const signature = tradingAccount.signPayload({ payload, walletPassphrase });

  console.log('Signature:', signature);
  return signature;
}

applySignature().catch(console.error);

// 3.2 Submit Signed Settlement
async function submitSignedSettlement() {
  const enterpriseId = '<YOUR_ENTERPRISE_ID>';
  const accountId = '<YOUR_ACCOUNT_ID>';
  const settlementId = '<SETTLEMENT_ID>';
  
  const result = await bitgo.post(
    `/api/clearing/v1/enterprise/${enterpriseId}/account/${accountId}/settlement/${settlementId}/signing`
  ).send({
    payload: '<SETTLEMENT_PAYLOAD>',
    signature: '<YOUR_PUBLIC_KEY>',
  });

  console.log('Signed Settlement:', result);
  return result;
}

submitSignedSettlement().catch(console.error);

// 4. Approve Settlement (Optional)
async function approveSettlement() {
  const approvalId = '<APPROVAL_ID>';
  
  const approval = await bitgo.put(`/api/v2/pendingApprovals/${approvalId}`).send({
    state: 'approved',
    otp: '<YOUR_OTP>',
  });

  console.log('Approval:', approval);
  return approval;
}

approveSettlement().catch(console.error);