> ## Documentation Index
> Fetch the complete documentation index at: https://docs.glider.fi/llms.txt
> Use this file to discover all available pages before exploring further.

# Portfolio Creation

> A guide to creating and configuring portfolios using the Glider API

Creating portfolios is a two-step process with the Glider API:

1. Generate a signature request that the user must sign with their wallet
2. Submit the signed message to create the portfolio

Once created, you can configure the portfolio's structure and settings.

## Step 1: Generate a Signature Request

First, you need to request a signable message that will be used to create the portfolio:

```javascript theme={null}
const response = await fetch(
  "/v1/portfolio/create/signature",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      userAddress: "0xYourWalletAddress", // The wallet that will own the portfolio
      chainIds: [8453], // Chain IDs where the portfolio will exist (Base = 8453)
    }),
  }
);

const signatureData = await response.json();
```

The response will include a message that needs to be signed by the user's wallet:

```json theme={null}
{
  "success": true,
  "data": {
    "userAddress": "0xYourWalletAddress",
    "chainIds": [8453],
    "accountIndex": 0,
    "kernelVersion": "0.3.2",
    "signatureAction": {
      "reason": "portfolio-permission",
      "type": "personal_sign",
      "message": "I authorize Glider to manage my portfolio\n\n0x8ad4d95c3c3d0a1e87bfdb1d2401905db4a97d8e05e77d69e5d79397da128b81"
    }
  },
  "correlationId": "corr_abcd1234",
  "requestId": "req_efgh5678",
  "timestamp": "2023-05-21T12:34:56.789Z"
}
```

## Step 2: Sign the Message

Have the user sign the message using their wallet:

```javascript theme={null}
// Sign the message with the wallet (using viem, ethers, or other library)
const signature = await wallet.signMessage(signatureData.data.signatureAction.message);
```

## Step 3: Submit the Signature to Create the Portfolio

Once you have the signature, submit it along with the original request data to create the portfolio:

```javascript theme={null}
const createResponse = await fetch(
  "/v1/portfolio/create",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      userAddress: signatureData.data.userAddress,
      chainIds: signatureData.data.chainIds,
      accountIndex: signatureData.data.accountIndex,
      kernelVersion: signatureData.data.kernelVersion,
      signatureAction: signatureData.data.signatureAction,
      signature: signature, // Add the signature from the user
    }),
  }
);

const portfolioResult = await createResponse.json();
const portfolioId = portfolioResult.data.portfolioId;
```

## Step 4: Configure the Portfolio Template

After creating the portfolio, you need to configure its template with assets and settings:

```javascript theme={null}
const updateResponse = await fetch(
  `/v1/portfolio/${portfolioId}/update`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      templateData: {
        name: "70/30 ETH-USDC Portfolio",
        description: "A simple portfolio with 70% ETH and 30% USDC allocation",
        entry: {
          blockType: "weight",
          weightType: "specified-percentage",
          weightings: ["70", "30"],
          children: [
            {
              blockType: "asset",
              assetId: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE:8453" // ETH on Base
            },
            {
              blockType: "asset",
              assetId: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913:8453" // USDC on Base
            }
          ]
        },
        tradingSettings: {
          type: "threshold",
          triggerPercentage: 5
        }
      }
    }),
  }
);

const updatedPortfolio = await updateResponse.json();
```

## Alternative: Create from Template

You can also create a portfolio directly from a template:

```javascript theme={null}
const createFromTemplateResponse = await fetch(
  "/v1/portfolios/create-from-template",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      templateId: "tmpl_xyz123", // The ID of the template to use
      userAddress: "0xYourWalletAddress", // The wallet that will own the portfolio
      chainIds: [8453], // Chain IDs where the portfolio will exist
      name: "My Custom Portfolio", // Optional custom name
      description: "Created from a template", // Optional custom description
    }),
  }
);

const templatePortfolioResult = await createFromTemplateResponse.json();
const templatePortfolioId = templatePortfolioResult.data.portfolioId;
```

## Template Data Structure

The template data defines how your portfolio is structured:

* `name`: The display name of the portfolio
* `description`: A description of the portfolio
* `entry`: The portfolio structure
  * `blockType`: The type of portfolio structure (e.g., "weight" for weighted allocation)
  * `weightType`: For weighted portfolios, specifies how weights are calculated (e.g., "specified-percentage")
  * `weightings`: Array of string percentages for each asset
  * `children`: Array of assets or nested structures
    * For assets: `{ blockType: "asset", assetId: "0xTokenAddress:chainId" }`
* `tradingSettings`: Rebalancing settings
  * `type`: "threshold" or "calendar"
  * `triggerPercentage`: For threshold type, the deviation percentage that triggers rebalancing
  * `frequency`: For calendar type, how often to rebalance (e.g., "daily", "weekly", "monthly")

## Session Key Resignation

If a portfolio's session keys need to be refreshed, you can resign the portfolio:

```javascript theme={null}
// Step 1: Get a new signature request for the existing portfolio
const resignResponse = await fetch(
  `/v1/portfolio/${portfolioId}/resign`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({}), // No body required
  }
);

const resignData = await resignResponse.json();

// Step 2: Have the user sign the new message
const newSignature = await wallet.signMessage(resignData.data.signatureAction.message);

// Step 3: Submit the new signature
const resubmitResponse = await fetch(
  `/v1/portfolio/${portfolioId}/resubmit-signature`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-API-KEY": API_KEY,
    },
    body: JSON.stringify({
      signature: newSignature,
      signatureAction: resignData.data.signatureAction
    }),
  }
);

const resubmitResult = await resubmitResponse.json();
```

## Next Steps

After creating a portfolio, you can:

1. [Deposit assets](/guides/portfolio-deposits) into the portfolio
2. [Start automation](/guides/portfolio-automation) to enable automatic rebalancing
3. [Update the portfolio](/guides/portfolio-updating) structure or settings as needed

For more detailed information about the available endpoints, see the [Portfolio Management](/api-reference/endpoints/portfolio-management) and [Portfolio Creation](/api-reference/endpoints/portfolio-creation) API references.